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;
1558 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1559 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1561 vat_main_t *vam = &vat_main;
1562 i32 retval = ntohl (mp->retval);
1563 if (vam->async_mode)
1565 vam->async_errors += (retval < 0);
1569 vam->retval = retval;
1570 vam->sw_if_index = ntohl (mp->sw_if_index);
1571 vam->result_ready = 1;
1575 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1576 (vl_api_vxlan_add_del_tunnel_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, "sw_if_index", ntohl (mp->sw_if_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_gre_add_del_tunnel_reply_t_handler
1593 (vl_api_gre_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_gre_add_del_tunnel_reply_t_handler_json
1610 (vl_api_gre_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_create_vhost_user_if_reply_t_handler
1627 (vl_api_create_vhost_user_if_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_create_vhost_user_if_reply_t_handler_json
1644 (vl_api_create_vhost_user_if_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_ip_address_details_t_handler
1661 (vl_api_ip_address_details_t * mp)
1663 vat_main_t *vam = &vat_main;
1664 static ip_address_details_t empty_ip_address_details = { {0} };
1665 ip_address_details_t *address = NULL;
1666 ip_details_t *current_ip_details = NULL;
1667 ip_details_t *details = NULL;
1669 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1671 if (!details || vam->current_sw_if_index >= vec_len (details)
1672 || !details[vam->current_sw_if_index].present)
1674 errmsg ("ip address details arrived but not stored\n");
1675 errmsg ("ip_dump should be called first\n");
1679 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1681 #define addresses (current_ip_details->addr)
1683 vec_validate_init_empty (addresses, vec_len (addresses),
1684 empty_ip_address_details);
1686 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1688 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1689 address->prefix_length = mp->prefix_length;
1693 static void vl_api_ip_address_details_t_handler_json
1694 (vl_api_ip_address_details_t * mp)
1696 vat_main_t *vam = &vat_main;
1697 vat_json_node_t *node = NULL;
1698 struct in6_addr ip6;
1701 if (VAT_JSON_ARRAY != vam->json_tree.type)
1703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1704 vat_json_init_array (&vam->json_tree);
1706 node = vat_json_array_add (&vam->json_tree);
1708 vat_json_init_object (node);
1711 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1712 vat_json_object_add_ip6 (node, "ip", ip6);
1716 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1717 vat_json_object_add_ip4 (node, "ip", ip4);
1719 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1723 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1725 vat_main_t *vam = &vat_main;
1726 static ip_details_t empty_ip_details = { 0 };
1727 ip_details_t *ip = NULL;
1728 u32 sw_if_index = ~0;
1730 sw_if_index = ntohl (mp->sw_if_index);
1732 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1733 sw_if_index, empty_ip_details);
1735 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1742 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1744 vat_main_t *vam = &vat_main;
1746 if (VAT_JSON_ARRAY != vam->json_tree.type)
1748 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1749 vat_json_init_array (&vam->json_tree);
1751 vat_json_array_add_uint (&vam->json_tree,
1752 clib_net_to_host_u32 (mp->sw_if_index));
1755 static void vl_api_map_domain_details_t_handler_json
1756 (vl_api_map_domain_details_t * mp)
1758 vat_json_node_t *node = NULL;
1759 vat_main_t *vam = &vat_main;
1760 struct in6_addr ip6;
1763 if (VAT_JSON_ARRAY != vam->json_tree.type)
1765 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1766 vat_json_init_array (&vam->json_tree);
1769 node = vat_json_array_add (&vam->json_tree);
1770 vat_json_init_object (node);
1772 vat_json_object_add_uint (node, "domain_index",
1773 clib_net_to_host_u32 (mp->domain_index));
1774 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1775 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1776 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1777 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1778 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1779 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1780 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1781 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1782 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1783 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1784 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1785 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1786 vat_json_object_add_uint (node, "flags", mp->flags);
1787 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1788 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1791 static void vl_api_map_domain_details_t_handler
1792 (vl_api_map_domain_details_t * mp)
1794 vat_main_t *vam = &vat_main;
1796 if (mp->is_translation)
1799 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1800 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1801 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1802 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1803 clib_net_to_host_u32 (mp->domain_index));
1808 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1809 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1810 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1811 format_ip6_address, mp->ip6_src,
1812 clib_net_to_host_u32 (mp->domain_index));
1814 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1815 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1816 mp->is_translation ? "map-t" : "");
1819 static void vl_api_map_rule_details_t_handler_json
1820 (vl_api_map_rule_details_t * mp)
1822 struct in6_addr ip6;
1823 vat_json_node_t *node = NULL;
1824 vat_main_t *vam = &vat_main;
1826 if (VAT_JSON_ARRAY != vam->json_tree.type)
1828 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1829 vat_json_init_array (&vam->json_tree);
1832 node = vat_json_array_add (&vam->json_tree);
1833 vat_json_init_object (node);
1835 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1836 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1837 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1841 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1843 vat_main_t *vam = &vat_main;
1844 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1845 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1849 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1851 vat_main_t *vam = &vat_main;
1852 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1853 "router_addr %U host_mac %U\n",
1854 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1855 format_ip4_address, &mp->host_address,
1856 format_ip4_address, &mp->router_address,
1857 format_ethernet_address, mp->host_mac);
1860 static void vl_api_dhcp_compl_event_t_handler_json
1861 (vl_api_dhcp_compl_event_t * mp)
1863 /* JSON output not supported */
1867 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1870 vat_main_t *vam = &vat_main;
1871 static u64 default_counter = 0;
1873 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1875 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1876 sw_if_index, default_counter);
1877 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1881 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1882 interface_counter_t counter)
1884 vat_main_t *vam = &vat_main;
1885 static interface_counter_t default_counter = { 0, };
1887 vec_validate_init_empty (vam->combined_interface_counters,
1888 vnet_counter_type, NULL);
1889 vec_validate_init_empty (vam->combined_interface_counters
1890 [vnet_counter_type], sw_if_index, default_counter);
1891 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1894 static void vl_api_vnet_interface_counters_t_handler
1895 (vl_api_vnet_interface_counters_t * mp)
1900 static void vl_api_vnet_interface_counters_t_handler_json
1901 (vl_api_vnet_interface_counters_t * mp)
1903 interface_counter_t counter;
1908 u32 first_sw_if_index;
1911 count = ntohl (mp->count);
1912 first_sw_if_index = ntohl (mp->first_sw_if_index);
1914 if (!mp->is_combined)
1916 v_packets = (u64 *) & mp->data;
1917 for (i = 0; i < count; i++)
1920 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1921 set_simple_interface_counter (mp->vnet_counter_type,
1922 first_sw_if_index + i, packets);
1928 v = (vlib_counter_t *) & mp->data;
1929 for (i = 0; i < count; i++)
1932 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1934 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1935 set_combined_interface_counter (mp->vnet_counter_type,
1936 first_sw_if_index + i, counter);
1943 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1945 vat_main_t *vam = &vat_main;
1948 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1950 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1959 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1961 vat_main_t *vam = &vat_main;
1964 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1966 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
1974 static void vl_api_vnet_ip4_fib_counters_t_handler
1975 (vl_api_vnet_ip4_fib_counters_t * mp)
1980 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1981 (vl_api_vnet_ip4_fib_counters_t * mp)
1983 vat_main_t *vam = &vat_main;
1984 vl_api_ip4_fib_counter_t *v;
1985 ip4_fib_counter_t *counter;
1992 vrf_id = ntohl (mp->vrf_id);
1993 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
1994 if (~0 == vrf_index)
1996 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
1997 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
1998 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1999 vec_validate (vam->ip4_fib_counters, vrf_index);
2000 vam->ip4_fib_counters[vrf_index] = NULL;
2003 vec_free (vam->ip4_fib_counters[vrf_index]);
2004 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2005 count = ntohl (mp->count);
2006 for (i = 0; i < count; i++)
2008 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2009 counter = &vam->ip4_fib_counters[vrf_index][i];
2010 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2011 counter->address = ip4;
2012 counter->address_length = v->address_length;
2013 counter->packets = clib_net_to_host_u64 (v->packets);
2014 counter->bytes = clib_net_to_host_u64 (v->bytes);
2019 static void vl_api_vnet_ip6_fib_counters_t_handler
2020 (vl_api_vnet_ip6_fib_counters_t * mp)
2025 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2026 (vl_api_vnet_ip6_fib_counters_t * mp)
2028 vat_main_t *vam = &vat_main;
2029 vl_api_ip6_fib_counter_t *v;
2030 ip6_fib_counter_t *counter;
2031 struct in6_addr ip6;
2037 vrf_id = ntohl (mp->vrf_id);
2038 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2039 if (~0 == vrf_index)
2041 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2042 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2043 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2044 vec_validate (vam->ip6_fib_counters, vrf_index);
2045 vam->ip6_fib_counters[vrf_index] = NULL;
2048 vec_free (vam->ip6_fib_counters[vrf_index]);
2049 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2050 count = ntohl (mp->count);
2051 for (i = 0; i < count; i++)
2053 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2054 counter = &vam->ip6_fib_counters[vrf_index][i];
2055 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2056 counter->address = ip6;
2057 counter->address_length = v->address_length;
2058 counter->packets = clib_net_to_host_u64 (v->packets);
2059 counter->bytes = clib_net_to_host_u64 (v->bytes);
2064 static void vl_api_get_first_msg_id_reply_t_handler
2065 (vl_api_get_first_msg_id_reply_t * mp)
2067 vat_main_t *vam = &vat_main;
2068 i32 retval = ntohl (mp->retval);
2070 if (vam->async_mode)
2072 vam->async_errors += (retval < 0);
2076 vam->retval = retval;
2077 vam->result_ready = 1;
2081 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2085 static void vl_api_get_first_msg_id_reply_t_handler_json
2086 (vl_api_get_first_msg_id_reply_t * mp)
2088 vat_main_t *vam = &vat_main;
2089 vat_json_node_t node;
2091 vat_json_init_object (&node);
2092 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2093 vat_json_object_add_uint (&node, "first_msg_id",
2094 (uint) ntohs (mp->first_msg_id));
2096 vat_json_print (vam->ofp, &node);
2097 vat_json_free (&node);
2099 vam->retval = ntohl (mp->retval);
2100 vam->result_ready = 1;
2103 static void vl_api_get_node_graph_reply_t_handler
2104 (vl_api_get_node_graph_reply_t * mp)
2106 vat_main_t *vam = &vat_main;
2107 api_main_t *am = &api_main;
2108 i32 retval = ntohl (mp->retval);
2109 u8 *pvt_copy, *reply;
2114 if (vam->async_mode)
2116 vam->async_errors += (retval < 0);
2120 vam->retval = retval;
2121 vam->result_ready = 1;
2124 /* "Should never happen..." */
2128 reply = (u8 *) (mp->reply_in_shmem);
2129 pvt_copy = vec_dup (reply);
2131 /* Toss the shared-memory original... */
2132 pthread_mutex_lock (&am->vlib_rp->mutex);
2133 oldheap = svm_push_data_heap (am->vlib_rp);
2137 svm_pop_heap (oldheap);
2138 pthread_mutex_unlock (&am->vlib_rp->mutex);
2140 if (vam->graph_nodes)
2142 hash_free (vam->graph_node_index_by_name);
2144 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2146 node = vam->graph_nodes[i];
2147 vec_free (node->name);
2148 vec_free (node->next_nodes);
2151 vec_free (vam->graph_nodes);
2154 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2155 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2156 vec_free (pvt_copy);
2158 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2160 node = vam->graph_nodes[i];
2161 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2165 static void vl_api_get_node_graph_reply_t_handler_json
2166 (vl_api_get_node_graph_reply_t * mp)
2168 vat_main_t *vam = &vat_main;
2169 api_main_t *am = &api_main;
2171 vat_json_node_t node;
2174 /* $$$$ make this real? */
2175 vat_json_init_object (&node);
2176 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2177 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2179 reply = (u8 *) (mp->reply_in_shmem);
2181 /* Toss the shared-memory original... */
2182 pthread_mutex_lock (&am->vlib_rp->mutex);
2183 oldheap = svm_push_data_heap (am->vlib_rp);
2187 svm_pop_heap (oldheap);
2188 pthread_mutex_unlock (&am->vlib_rp->mutex);
2190 vat_json_print (vam->ofp, &node);
2191 vat_json_free (&node);
2193 vam->retval = ntohl (mp->retval);
2194 vam->result_ready = 1;
2198 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2200 vat_main_t *vam = &vat_main;
2204 memset (&loc, 0, sizeof (loc));
2205 if (vam->noprint_msg)
2207 loc.local = mp->local;
2208 loc.priority = mp->priority;
2209 loc.weight = mp->weight;
2212 loc.sw_if_index = ntohl (mp->sw_if_index);
2216 loc.is_ipv6 = mp->is_ipv6;
2217 clib_memcpy (loc.ip_address, mp->ip_address,
2218 sizeof (loc.ip_address));
2220 vec_add1 (vam->locator_msg, loc);
2226 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
2227 ntohl (mp->sw_if_index),
2228 mp->priority, mp->weight);
2232 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
2233 mp->is_ipv6 ? format_ip6_address :
2235 mp->ip_address, mp->priority, mp->weight);
2238 fformat (vam->ofp, "%s", tmp_str);
2245 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2248 vat_main_t *vam = &vat_main;
2249 vat_json_node_t *node = NULL;
2251 struct in6_addr ip6;
2254 memset (&loc, 0, sizeof (loc));
2255 if (vam->noprint_msg)
2257 loc.local = mp->local;
2258 loc.priority = mp->priority;
2259 loc.weight = mp->weight;
2262 loc.sw_if_index = ntohl (mp->sw_if_index);
2266 loc.is_ipv6 = mp->is_ipv6;
2267 clib_memcpy (loc.ip_address, mp->ip_address,
2268 sizeof (loc.ip_address));
2270 vec_add1 (vam->locator_msg, loc);
2274 if (VAT_JSON_ARRAY != vam->json_tree.type)
2276 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2277 vat_json_init_array (&vam->json_tree);
2279 node = vat_json_array_add (&vam->json_tree);
2281 vat_json_init_object (node);
2285 vat_json_object_add_uint (node, "locator_index",
2286 ntohl (mp->sw_if_index));
2292 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2293 vat_json_object_add_ip6 (node, "locator", ip6);
2297 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2298 vat_json_object_add_ip4 (node, "locator", ip4);
2301 vat_json_object_add_uint (node, "priority", mp->priority);
2302 vat_json_object_add_uint (node, "weight", mp->weight);
2306 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2309 vat_main_t *vam = &vat_main;
2310 locator_set_msg_t ls;
2312 ls.locator_set_index = ntohl (mp->locator_set_index);
2313 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2314 vec_add1 (vam->locator_set_msg, ls);
2318 vl_api_lisp_locator_set_details_t_handler_json
2319 (vl_api_lisp_locator_set_details_t * mp)
2321 vat_main_t *vam = &vat_main;
2322 locator_set_msg_t ls;
2324 ls.locator_set_index = ntohl (mp->locator_set_index);
2325 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2326 vec_add1 (vam->locator_set_msg, ls);
2330 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2332 vat_main_t *vam = &vat_main;
2333 eid_table_t eid_table;
2335 memset (&eid_table, 0, sizeof (eid_table));
2336 eid_table.is_local = mp->is_local;
2337 eid_table.locator_set_index = mp->locator_set_index;
2338 eid_table.eid_type = mp->eid_type;
2339 eid_table.vni = mp->vni;
2340 eid_table.eid_prefix_len = mp->eid_prefix_len;
2341 eid_table.ttl = mp->ttl;
2342 eid_table.authoritative = mp->authoritative;
2343 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2344 vec_add1 (vam->eid_tables, eid_table);
2348 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2351 vat_main_t *vam = &vat_main;
2352 eid_table_t eid_table;
2354 memset (&eid_table, 0, sizeof (eid_table));
2355 eid_table.is_local = mp->is_local;
2356 eid_table.locator_set_index = mp->locator_set_index;
2357 eid_table.eid_type = mp->eid_type;
2358 eid_table.vni = mp->vni;
2359 eid_table.eid_prefix_len = mp->eid_prefix_len;
2360 eid_table.ttl = mp->ttl;
2361 eid_table.authoritative = mp->authoritative;
2362 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2363 vec_add1 (vam->eid_tables, eid_table);
2367 vl_api_lisp_eid_table_map_details_t_handler
2368 (vl_api_lisp_eid_table_map_details_t * mp)
2370 vat_main_t *vam = &vat_main;
2372 u8 *line = format (0, "%=10d%=10d",
2373 clib_net_to_host_u32 (mp->vni),
2374 clib_net_to_host_u32 (mp->vrf));
2375 fformat (vam->ofp, "%v\n", line);
2380 vl_api_lisp_eid_table_map_details_t_handler_json
2381 (vl_api_lisp_eid_table_map_details_t * mp)
2383 vat_main_t *vam = &vat_main;
2384 vat_json_node_t *node = NULL;
2386 if (VAT_JSON_ARRAY != vam->json_tree.type)
2388 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2389 vat_json_init_array (&vam->json_tree);
2391 node = vat_json_array_add (&vam->json_tree);
2392 vat_json_init_object (node);
2393 vat_json_object_add_uint (node, "vrf", clib_net_to_host_u32 (mp->vrf));
2394 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2400 format_decap_next (u8 * s, va_list * args)
2402 u32 next_index = va_arg (*args, u32);
2406 case LISP_GPE_INPUT_NEXT_DROP:
2407 return format (s, "drop");
2408 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2409 return format (s, "ip4");
2410 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2411 return format (s, "ip6");
2413 return format (s, "unknown %d", next_index);
2419 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2422 vat_main_t *vam = &vat_main;
2424 u8 *flag_str = NULL;
2426 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2428 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2429 foreach_lisp_gpe_flag_bit;
2432 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2433 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2435 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2437 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2439 ntohl (mp->encap_fib_id),
2440 ntohl (mp->decap_fib_id),
2441 format_decap_next, ntohl (mp->dcap_next),
2443 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2449 vl_api_lisp_gpe_tunnel_details_t_handler_json
2450 (vl_api_lisp_gpe_tunnel_details_t * mp)
2452 vat_main_t *vam = &vat_main;
2453 vat_json_node_t *node = NULL;
2454 struct in6_addr ip6;
2458 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2460 if (VAT_JSON_ARRAY != vam->json_tree.type)
2462 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2463 vat_json_init_array (&vam->json_tree);
2465 node = vat_json_array_add (&vam->json_tree);
2467 vat_json_init_object (node);
2468 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2471 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2472 vat_json_object_add_ip6 (node, "source address", ip6);
2473 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2474 vat_json_object_add_ip6 (node, "destination address", ip6);
2478 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2479 vat_json_object_add_ip4 (node, "source address", ip4);
2480 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2481 vat_json_object_add_ip4 (node, "destination address", ip4);
2483 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2484 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2485 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2486 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2487 vat_json_object_add_uint (node, "flags", mp->flags);
2488 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2489 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2490 vat_json_object_add_uint (node, "res", mp->res);
2491 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2493 vec_free (next_decap_str);
2497 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2500 vat_main_t *vam = &vat_main;
2502 fformat (vam->ofp, "%=20U\n",
2503 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2508 vl_api_lisp_map_resolver_details_t_handler_json
2509 (vl_api_lisp_map_resolver_details_t * mp)
2511 vat_main_t *vam = &vat_main;
2512 vat_json_node_t *node = NULL;
2513 struct in6_addr ip6;
2516 if (VAT_JSON_ARRAY != vam->json_tree.type)
2518 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2519 vat_json_init_array (&vam->json_tree);
2521 node = vat_json_array_add (&vam->json_tree);
2523 vat_json_init_object (node);
2526 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2527 vat_json_object_add_ip6 (node, "map resolver", ip6);
2531 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2532 vat_json_object_add_ip4 (node, "map resolver", ip4);
2537 vl_api_show_lisp_status_reply_t_handler
2538 (vl_api_show_lisp_status_reply_t * mp)
2540 vat_main_t *vam = &vat_main;
2541 i32 retval = ntohl (mp->retval);
2545 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2546 mp->feature_status ? "enabled" : "disabled",
2547 mp->gpe_status ? "enabled" : "disabled");
2550 vam->retval = retval;
2551 vam->result_ready = 1;
2555 vl_api_show_lisp_status_reply_t_handler_json
2556 (vl_api_show_lisp_status_reply_t * mp)
2558 vat_main_t *vam = &vat_main;
2559 vat_json_node_t node;
2560 u8 *gpe_status = NULL;
2561 u8 *feature_status = NULL;
2563 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2564 feature_status = format (0, "%s",
2565 mp->feature_status ? "enabled" : "disabled");
2566 vec_add1 (gpe_status, 0);
2567 vec_add1 (feature_status, 0);
2569 vat_json_init_object (&node);
2570 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2571 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2573 vec_free (gpe_status);
2574 vec_free (feature_status);
2576 vat_json_print (vam->ofp, &node);
2577 vat_json_free (&node);
2579 vam->retval = ntohl (mp->retval);
2580 vam->result_ready = 1;
2584 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2585 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2587 vat_main_t *vam = &vat_main;
2588 i32 retval = ntohl (mp->retval);
2592 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2595 vam->retval = retval;
2596 vam->result_ready = 1;
2600 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2601 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2603 vat_main_t *vam = &vat_main;
2604 vat_json_node_t *node = NULL;
2606 if (VAT_JSON_ARRAY != vam->json_tree.type)
2608 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2609 vat_json_init_array (&vam->json_tree);
2611 node = vat_json_array_add (&vam->json_tree);
2613 vat_json_init_object (node);
2614 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2616 vat_json_print (vam->ofp, node);
2617 vat_json_free (node);
2619 vam->retval = ntohl (mp->retval);
2620 vam->result_ready = 1;
2624 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2626 vat_main_t *vam = &vat_main;
2627 i32 retval = ntohl (mp->retval);
2631 fformat (vam->ofp, "%-20s%-16s\n",
2632 mp->status ? "enabled" : "disabled",
2633 mp->status ? (char *) mp->locator_set_name : "");
2636 vam->retval = retval;
2637 vam->result_ready = 1;
2641 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2644 vat_main_t *vam = &vat_main;
2645 vat_json_node_t node;
2648 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2649 vec_add1 (status, 0);
2651 vat_json_init_object (&node);
2652 vat_json_object_add_string_copy (&node, "status", status);
2655 vat_json_object_add_string_copy (&node, "locator_set",
2656 mp->locator_set_name);
2661 vat_json_print (vam->ofp, &node);
2662 vat_json_free (&node);
2664 vam->retval = ntohl (mp->retval);
2665 vam->result_ready = 1;
2669 format_policer_type (u8 * s, va_list * va)
2671 u32 i = va_arg (*va, u32);
2673 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2674 s = format (s, "1r2c");
2675 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2676 s = format (s, "1r3c");
2677 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2678 s = format (s, "2r3c-2698");
2679 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2680 s = format (s, "2r3c-4115");
2681 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2682 s = format (s, "2r3c-mef5cf1");
2684 s = format (s, "ILLEGAL");
2689 format_policer_rate_type (u8 * s, va_list * va)
2691 u32 i = va_arg (*va, u32);
2693 if (i == SSE2_QOS_RATE_KBPS)
2694 s = format (s, "kbps");
2695 else if (i == SSE2_QOS_RATE_PPS)
2696 s = format (s, "pps");
2698 s = format (s, "ILLEGAL");
2703 format_policer_round_type (u8 * s, va_list * va)
2705 u32 i = va_arg (*va, u32);
2707 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2708 s = format (s, "closest");
2709 else if (i == SSE2_QOS_ROUND_TO_UP)
2710 s = format (s, "up");
2711 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2712 s = format (s, "down");
2714 s = format (s, "ILLEGAL");
2719 format_policer_action_type (u8 * s, va_list * va)
2721 u32 i = va_arg (*va, u32);
2723 if (i == SSE2_QOS_ACTION_DROP)
2724 s = format (s, "drop");
2725 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2726 s = format (s, "transmit");
2727 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2728 s = format (s, "mark-and-transmit");
2730 s = format (s, "ILLEGAL");
2735 format_dscp (u8 * s, va_list * va)
2737 u32 i = va_arg (*va, u32);
2742 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2746 return format (s, "ILLEGAL");
2748 s = format (s, "%s", t);
2753 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2755 vat_main_t *vam = &vat_main;
2756 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2758 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2759 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2761 conform_dscp_str = format (0, "");
2763 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2764 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2766 exceed_dscp_str = format (0, "");
2768 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2769 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2771 violate_dscp_str = format (0, "");
2773 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2774 "rate type %U, round type %U, %s rate, %s color-aware, "
2775 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2776 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2777 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2779 format_policer_type, mp->type,
2782 clib_net_to_host_u64 (mp->cb),
2783 clib_net_to_host_u64 (mp->eb),
2784 format_policer_rate_type, mp->rate_type,
2785 format_policer_round_type, mp->round_type,
2786 mp->single_rate ? "single" : "dual",
2787 mp->color_aware ? "is" : "not",
2788 ntohl (mp->cir_tokens_per_period),
2789 ntohl (mp->pir_tokens_per_period),
2791 ntohl (mp->current_limit),
2792 ntohl (mp->current_bucket),
2793 ntohl (mp->extended_limit),
2794 ntohl (mp->extended_bucket),
2795 clib_net_to_host_u64 (mp->last_update_time),
2796 format_policer_action_type, mp->conform_action_type,
2798 format_policer_action_type, mp->exceed_action_type,
2800 format_policer_action_type, mp->violate_action_type,
2803 vec_free (conform_dscp_str);
2804 vec_free (exceed_dscp_str);
2805 vec_free (violate_dscp_str);
2808 static void vl_api_policer_details_t_handler_json
2809 (vl_api_policer_details_t * mp)
2811 vat_main_t *vam = &vat_main;
2812 vat_json_node_t *node;
2813 u8 *rate_type_str, *round_type_str, *type_str;
2814 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2816 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2818 format (0, "%U", format_policer_round_type, mp->round_type);
2819 type_str = format (0, "%U", format_policer_type, mp->type);
2820 conform_action_str = format (0, "%U", format_policer_action_type,
2821 mp->conform_action_type);
2822 exceed_action_str = format (0, "%U", format_policer_action_type,
2823 mp->exceed_action_type);
2824 violate_action_str = format (0, "%U", format_policer_action_type,
2825 mp->violate_action_type);
2827 if (VAT_JSON_ARRAY != vam->json_tree.type)
2829 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2830 vat_json_init_array (&vam->json_tree);
2832 node = vat_json_array_add (&vam->json_tree);
2834 vat_json_init_object (node);
2835 vat_json_object_add_string_copy (node, "name", mp->name);
2836 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2837 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2838 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2839 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2840 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2841 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2842 vat_json_object_add_string_copy (node, "type", type_str);
2843 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2844 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2845 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2846 vat_json_object_add_uint (node, "cir_tokens_per_period",
2847 ntohl (mp->cir_tokens_per_period));
2848 vat_json_object_add_uint (node, "eir_tokens_per_period",
2849 ntohl (mp->pir_tokens_per_period));
2850 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2851 vat_json_object_add_uint (node, "current_bucket",
2852 ntohl (mp->current_bucket));
2853 vat_json_object_add_uint (node, "extended_limit",
2854 ntohl (mp->extended_limit));
2855 vat_json_object_add_uint (node, "extended_bucket",
2856 ntohl (mp->extended_bucket));
2857 vat_json_object_add_uint (node, "last_update_time",
2858 ntohl (mp->last_update_time));
2859 vat_json_object_add_string_copy (node, "conform_action",
2860 conform_action_str);
2861 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2863 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2864 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2865 vec_free (dscp_str);
2867 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2868 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2870 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2871 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2872 vec_free (dscp_str);
2874 vat_json_object_add_string_copy (node, "violate_action",
2875 violate_action_str);
2876 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2878 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2879 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2880 vec_free (dscp_str);
2883 vec_free (rate_type_str);
2884 vec_free (round_type_str);
2885 vec_free (type_str);
2886 vec_free (conform_action_str);
2887 vec_free (exceed_action_str);
2888 vec_free (violate_action_str);
2892 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2895 vat_main_t *vam = &vat_main;
2896 int i, count = ntohl (mp->count);
2899 fformat (vam->ofp, "classify table ids (%d) : ", count);
2900 for (i = 0; i < count; i++)
2902 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
2903 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
2905 vam->retval = ntohl (mp->retval);
2906 vam->result_ready = 1;
2910 vl_api_classify_table_ids_reply_t_handler_json
2911 (vl_api_classify_table_ids_reply_t * mp)
2913 vat_main_t *vam = &vat_main;
2914 int i, count = ntohl (mp->count);
2918 vat_json_node_t node;
2920 vat_json_init_object (&node);
2921 for (i = 0; i < count; i++)
2923 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
2925 vat_json_print (vam->ofp, &node);
2926 vat_json_free (&node);
2928 vam->retval = ntohl (mp->retval);
2929 vam->result_ready = 1;
2933 vl_api_classify_table_by_interface_reply_t_handler
2934 (vl_api_classify_table_by_interface_reply_t * mp)
2936 vat_main_t *vam = &vat_main;
2939 table_id = ntohl (mp->l2_table_id);
2941 fformat (vam->ofp, "l2 table id : %d\n", table_id);
2943 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
2944 table_id = ntohl (mp->ip4_table_id);
2946 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
2948 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
2949 table_id = ntohl (mp->ip6_table_id);
2951 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
2953 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
2954 vam->retval = ntohl (mp->retval);
2955 vam->result_ready = 1;
2959 vl_api_classify_table_by_interface_reply_t_handler_json
2960 (vl_api_classify_table_by_interface_reply_t * mp)
2962 vat_main_t *vam = &vat_main;
2963 vat_json_node_t node;
2965 vat_json_init_object (&node);
2967 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
2968 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
2969 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
2971 vat_json_print (vam->ofp, &node);
2972 vat_json_free (&node);
2974 vam->retval = ntohl (mp->retval);
2975 vam->result_ready = 1;
2978 static void vl_api_policer_add_del_reply_t_handler
2979 (vl_api_policer_add_del_reply_t * mp)
2981 vat_main_t *vam = &vat_main;
2982 i32 retval = ntohl (mp->retval);
2983 if (vam->async_mode)
2985 vam->async_errors += (retval < 0);
2989 vam->retval = retval;
2990 vam->result_ready = 1;
2991 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
2993 * Note: this is just barely thread-safe, depends on
2994 * the main thread spinning waiting for an answer...
2996 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3000 static void vl_api_policer_add_del_reply_t_handler_json
3001 (vl_api_policer_add_del_reply_t * mp)
3003 vat_main_t *vam = &vat_main;
3004 vat_json_node_t node;
3006 vat_json_init_object (&node);
3007 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3008 vat_json_object_add_uint (&node, "policer_index",
3009 ntohl (mp->policer_index));
3011 vat_json_print (vam->ofp, &node);
3012 vat_json_free (&node);
3014 vam->retval = ntohl (mp->retval);
3015 vam->result_ready = 1;
3018 /* Format hex dump. */
3020 format_hex_bytes (u8 * s, va_list * va)
3022 u8 *bytes = va_arg (*va, u8 *);
3023 int n_bytes = va_arg (*va, int);
3026 /* Print short or long form depending on byte count. */
3027 uword short_form = n_bytes <= 32;
3028 uword indent = format_get_indent (s);
3033 for (i = 0; i < n_bytes; i++)
3035 if (!short_form && (i % 32) == 0)
3036 s = format (s, "%08x: ", i);
3037 s = format (s, "%02x", bytes[i]);
3038 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3039 s = format (s, "\n%U", format_white_space, indent);
3046 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3049 vat_main_t *vam = &vat_main;
3050 i32 retval = ntohl (mp->retval);
3053 fformat (vam->ofp, "classify table info :\n");
3054 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3055 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3056 ntohl (mp->miss_next_index));
3057 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3058 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3059 ntohl (mp->match_n_vectors));
3060 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3061 ntohl (mp->mask_length));
3063 vam->retval = retval;
3064 vam->result_ready = 1;
3068 vl_api_classify_table_info_reply_t_handler_json
3069 (vl_api_classify_table_info_reply_t * mp)
3071 vat_main_t *vam = &vat_main;
3072 vat_json_node_t node;
3074 i32 retval = ntohl (mp->retval);
3077 vat_json_init_object (&node);
3079 vat_json_object_add_int (&node, "sessions",
3080 ntohl (mp->active_sessions));
3081 vat_json_object_add_int (&node, "nexttbl",
3082 ntohl (mp->next_table_index));
3083 vat_json_object_add_int (&node, "nextnode",
3084 ntohl (mp->miss_next_index));
3085 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3086 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3087 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3088 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3089 ntohl (mp->mask_length), 0);
3090 vat_json_object_add_string_copy (&node, "mask", s);
3092 vat_json_print (vam->ofp, &node);
3093 vat_json_free (&node);
3095 vam->retval = ntohl (mp->retval);
3096 vam->result_ready = 1;
3100 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3103 vat_main_t *vam = &vat_main;
3105 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3106 ntohl (mp->hit_next_index), ntohl (mp->advance),
3107 ntohl (mp->opaque_index));
3108 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3109 ntohl (mp->match_length));
3113 vl_api_classify_session_details_t_handler_json
3114 (vl_api_classify_session_details_t * mp)
3116 vat_main_t *vam = &vat_main;
3117 vat_json_node_t *node = NULL;
3119 if (VAT_JSON_ARRAY != vam->json_tree.type)
3121 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3122 vat_json_init_array (&vam->json_tree);
3124 node = vat_json_array_add (&vam->json_tree);
3126 vat_json_init_object (node);
3127 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3128 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3129 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3131 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3133 vat_json_object_add_string_copy (node, "match", s);
3136 static void vl_api_pg_create_interface_reply_t_handler
3137 (vl_api_pg_create_interface_reply_t * mp)
3139 vat_main_t *vam = &vat_main;
3141 vam->retval = ntohl (mp->retval);
3142 vam->result_ready = 1;
3145 static void vl_api_pg_create_interface_reply_t_handler_json
3146 (vl_api_pg_create_interface_reply_t * mp)
3148 vat_main_t *vam = &vat_main;
3149 vat_json_node_t node;
3151 i32 retval = ntohl (mp->retval);
3154 vat_json_init_object (&node);
3156 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3158 vat_json_print (vam->ofp, &node);
3159 vat_json_free (&node);
3161 vam->retval = ntohl (mp->retval);
3162 vam->result_ready = 1;
3165 static void vl_api_policer_classify_details_t_handler
3166 (vl_api_policer_classify_details_t * mp)
3168 vat_main_t *vam = &vat_main;
3170 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3171 ntohl (mp->table_index));
3174 static void vl_api_policer_classify_details_t_handler_json
3175 (vl_api_policer_classify_details_t * mp)
3177 vat_main_t *vam = &vat_main;
3178 vat_json_node_t *node;
3180 if (VAT_JSON_ARRAY != vam->json_tree.type)
3182 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3183 vat_json_init_array (&vam->json_tree);
3185 node = vat_json_array_add (&vam->json_tree);
3187 vat_json_init_object (node);
3188 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3189 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3193 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3194 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3195 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3196 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3199 * Generate boilerplate reply handlers, which
3200 * dig the return value out of the xxx_reply_t API message,
3201 * stick it into vam->retval, and set vam->result_ready
3203 * Could also do this by pointing N message decode slots at
3204 * a single function, but that could break in subtle ways.
3207 #define foreach_standard_reply_retval_handler \
3208 _(sw_interface_set_flags_reply) \
3209 _(sw_interface_add_del_address_reply) \
3210 _(sw_interface_set_table_reply) \
3211 _(sw_interface_set_vpath_reply) \
3212 _(sw_interface_set_l2_bridge_reply) \
3213 _(bridge_domain_add_del_reply) \
3214 _(sw_interface_set_l2_xconnect_reply) \
3215 _(l2fib_add_del_reply) \
3216 _(ip_add_del_route_reply) \
3217 _(proxy_arp_add_del_reply) \
3218 _(proxy_arp_intfc_enable_disable_reply) \
3219 _(mpls_add_del_encap_reply) \
3220 _(mpls_add_del_decap_reply) \
3221 _(mpls_ethernet_add_del_tunnel_2_reply) \
3222 _(sw_interface_set_unnumbered_reply) \
3223 _(ip_neighbor_add_del_reply) \
3224 _(reset_vrf_reply) \
3225 _(oam_add_del_reply) \
3226 _(reset_fib_reply) \
3227 _(dhcp_proxy_config_reply) \
3228 _(dhcp_proxy_config_2_reply) \
3229 _(dhcp_proxy_set_vss_reply) \
3230 _(dhcp_client_config_reply) \
3231 _(set_ip_flow_hash_reply) \
3232 _(sw_interface_ip6_enable_disable_reply) \
3233 _(sw_interface_ip6_set_link_local_address_reply) \
3234 _(sw_interface_ip6nd_ra_prefix_reply) \
3235 _(sw_interface_ip6nd_ra_config_reply) \
3236 _(set_arp_neighbor_limit_reply) \
3237 _(l2_patch_add_del_reply) \
3238 _(sr_tunnel_add_del_reply) \
3239 _(sr_policy_add_del_reply) \
3240 _(sr_multicast_map_add_del_reply) \
3241 _(classify_add_del_session_reply) \
3242 _(classify_set_interface_ip_table_reply) \
3243 _(classify_set_interface_l2_tables_reply) \
3244 _(l2tpv3_set_tunnel_cookies_reply) \
3245 _(l2tpv3_interface_enable_disable_reply) \
3246 _(l2tpv3_set_lookup_key_reply) \
3247 _(l2_fib_clear_table_reply) \
3248 _(l2_interface_efp_filter_reply) \
3249 _(l2_interface_vlan_tag_rewrite_reply) \
3250 _(modify_vhost_user_if_reply) \
3251 _(delete_vhost_user_if_reply) \
3252 _(want_ip4_arp_events_reply) \
3253 _(input_acl_set_interface_reply) \
3254 _(ipsec_spd_add_del_reply) \
3255 _(ipsec_interface_add_del_spd_reply) \
3256 _(ipsec_spd_add_del_entry_reply) \
3257 _(ipsec_sad_add_del_entry_reply) \
3258 _(ipsec_sa_set_key_reply) \
3259 _(ikev2_profile_add_del_reply) \
3260 _(ikev2_profile_set_auth_reply) \
3261 _(ikev2_profile_set_id_reply) \
3262 _(ikev2_profile_set_ts_reply) \
3263 _(ikev2_set_local_key_reply) \
3264 _(delete_loopback_reply) \
3265 _(bd_ip_mac_add_del_reply) \
3266 _(map_del_domain_reply) \
3267 _(map_add_del_rule_reply) \
3268 _(want_interface_events_reply) \
3269 _(want_stats_reply) \
3270 _(cop_interface_enable_disable_reply) \
3271 _(cop_whitelist_enable_disable_reply) \
3272 _(sw_interface_clear_stats_reply) \
3273 _(trace_profile_add_reply) \
3274 _(trace_profile_apply_reply) \
3275 _(trace_profile_del_reply) \
3276 _(lisp_add_del_locator_set_reply) \
3277 _(lisp_add_del_locator_reply) \
3278 _(lisp_add_del_local_eid_reply) \
3279 _(lisp_add_del_remote_mapping_reply) \
3280 _(lisp_add_del_adjacency_reply) \
3281 _(lisp_gpe_add_del_fwd_entry_reply) \
3282 _(lisp_add_del_map_resolver_reply) \
3283 _(lisp_gpe_enable_disable_reply) \
3284 _(lisp_gpe_add_del_iface_reply) \
3285 _(lisp_enable_disable_reply) \
3286 _(lisp_pitr_set_locator_set_reply) \
3287 _(lisp_add_del_map_request_itr_rlocs_reply) \
3288 _(lisp_eid_table_add_del_map_reply) \
3289 _(vxlan_gpe_add_del_tunnel_reply) \
3290 _(af_packet_delete_reply) \
3291 _(policer_classify_set_interface_reply) \
3292 _(netmap_create_reply) \
3293 _(netmap_delete_reply) \
3294 _(ipfix_enable_reply) \
3295 _(pg_capture_reply) \
3296 _(pg_enable_disable_reply) \
3297 _(ip_source_and_port_range_check_add_del_reply) \
3298 _(ip_source_and_port_range_check_interface_add_del_reply)
3301 static void vl_api_##n##_t_handler \
3302 (vl_api_##n##_t * mp) \
3304 vat_main_t * vam = &vat_main; \
3305 i32 retval = ntohl(mp->retval); \
3306 if (vam->async_mode) { \
3307 vam->async_errors += (retval < 0); \
3309 vam->retval = retval; \
3310 vam->result_ready = 1; \
3313 foreach_standard_reply_retval_handler;
3317 static void vl_api_##n##_t_handler_json \
3318 (vl_api_##n##_t * mp) \
3320 vat_main_t * vam = &vat_main; \
3321 vat_json_node_t node; \
3322 vat_json_init_object(&node); \
3323 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3324 vat_json_print(vam->ofp, &node); \
3325 vam->retval = ntohl(mp->retval); \
3326 vam->result_ready = 1; \
3328 foreach_standard_reply_retval_handler;
3332 * Table of message reply handlers, must include boilerplate handlers
3336 #define foreach_vpe_api_reply_msg \
3337 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3338 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3339 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3340 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3341 _(CONTROL_PING_REPLY, control_ping_reply) \
3342 _(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
3343 _(CLI_REPLY, cli_reply) \
3344 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3345 sw_interface_add_del_address_reply) \
3346 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3347 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3348 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3349 sw_interface_set_l2_xconnect_reply) \
3350 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3351 sw_interface_set_l2_bridge_reply) \
3352 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3353 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3354 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3355 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3356 _(L2_FLAGS_REPLY, l2_flags_reply) \
3357 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3358 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3359 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3360 _(TAP_DELETE_REPLY, tap_delete_reply) \
3361 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3362 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3363 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3364 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3365 proxy_arp_intfc_enable_disable_reply) \
3366 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3367 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3368 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3369 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3370 mpls_ethernet_add_del_tunnel_reply) \
3371 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3372 mpls_ethernet_add_del_tunnel_2_reply) \
3373 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3374 sw_interface_set_unnumbered_reply) \
3375 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3376 _(RESET_VRF_REPLY, reset_vrf_reply) \
3377 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3378 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3379 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3380 _(RESET_FIB_REPLY, reset_fib_reply) \
3381 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3382 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3383 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3384 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3385 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3386 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3387 sw_interface_ip6_enable_disable_reply) \
3388 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3389 sw_interface_ip6_set_link_local_address_reply) \
3390 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3391 sw_interface_ip6nd_ra_prefix_reply) \
3392 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3393 sw_interface_ip6nd_ra_config_reply) \
3394 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3395 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3396 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3397 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3398 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3399 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3400 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3401 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3402 classify_set_interface_ip_table_reply) \
3403 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3404 classify_set_interface_l2_tables_reply) \
3405 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3406 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3407 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3408 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3409 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3410 l2tpv3_interface_enable_disable_reply) \
3411 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3412 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3413 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3414 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3415 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3416 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3417 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3418 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3419 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3420 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3421 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3422 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3423 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3424 _(SHOW_VERSION_REPLY, show_version_reply) \
3425 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3426 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3427 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3428 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3429 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3430 _(IP4_ARP_EVENT, ip4_arp_event) \
3431 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3432 _(IP_ADDRESS_DETAILS, ip_address_details) \
3433 _(IP_DETAILS, ip_details) \
3434 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3435 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3436 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3437 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3438 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3439 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3440 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3441 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3442 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3443 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3444 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3445 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3446 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3447 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3448 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3449 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3450 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3451 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3452 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3453 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3454 _(MAP_RULE_DETAILS, map_rule_details) \
3455 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3456 _(WANT_STATS_REPLY, want_stats_reply) \
3457 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3458 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3459 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3460 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3461 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3462 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
3463 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
3464 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
3465 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3466 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3467 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3468 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3469 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3470 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3471 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3472 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3473 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3474 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3475 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3476 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3477 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3478 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3479 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3480 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3481 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3482 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3483 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3484 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3485 lisp_add_del_map_request_itr_rlocs_reply) \
3486 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3487 lisp_get_map_request_itr_rlocs_reply) \
3488 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3489 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3490 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3491 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3492 _(POLICER_DETAILS, policer_details) \
3493 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3494 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3495 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3496 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3497 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3498 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3499 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3500 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3501 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3502 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3503 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3504 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3505 _(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
3506 _(IPFIX_DETAILS, ipfix_details) \
3507 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3508 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3509 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3510 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3511 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3512 ip_source_and_port_range_check_add_del_reply) \
3513 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3514 ip_source_and_port_range_check_interface_add_del_reply)
3516 /* M: construct, but don't yet send a message */
3520 vam->result_ready = 0; \
3521 mp = vl_msg_api_alloc(sizeof(*mp)); \
3522 memset (mp, 0, sizeof (*mp)); \
3523 mp->_vl_msg_id = ntohs (VL_API_##T); \
3524 mp->client_index = vam->my_client_index; \
3529 vam->result_ready = 0; \
3530 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3531 memset (mp, 0, sizeof (*mp)); \
3532 mp->_vl_msg_id = ntohs (VL_API_##T); \
3533 mp->client_index = vam->my_client_index; \
3537 /* S: send a message */
3538 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3540 /* W: wait for results, with timeout */
3543 timeout = vat_time_now (vam) + 1.0; \
3545 while (vat_time_now (vam) < timeout) { \
3546 if (vam->result_ready == 1) { \
3547 return (vam->retval); \
3553 /* W2: wait for results, with timeout */
3556 timeout = vat_time_now (vam) + 1.0; \
3558 while (vat_time_now (vam) < timeout) { \
3559 if (vam->result_ready == 1) { \
3561 return (vam->retval); \
3567 /* W_L: wait for results, with timeout */
3570 timeout = vat_time_now (vam) + 1.0; \
3572 while (vat_time_now (vam) < timeout) { \
3573 if (vam->result_ready == 1) { \
3575 return (vam->retval); \
3578 vam->noprint_msg = 0; \
3589 #define STR_VTR_OP_CASE(op) \
3590 case L2_VTR_ ## op: \
3594 str_vtr_op (u32 vtr_op)
3598 STR_VTR_OP_CASE (DISABLED);
3599 STR_VTR_OP_CASE (PUSH_1);
3600 STR_VTR_OP_CASE (PUSH_2);
3601 STR_VTR_OP_CASE (POP_1);
3602 STR_VTR_OP_CASE (POP_2);
3603 STR_VTR_OP_CASE (TRANSLATE_1_1);
3604 STR_VTR_OP_CASE (TRANSLATE_1_2);
3605 STR_VTR_OP_CASE (TRANSLATE_2_1);
3606 STR_VTR_OP_CASE (TRANSLATE_2_2);
3613 dump_sub_interface_table (vat_main_t * vam)
3615 const sw_interface_subif_t *sub = NULL;
3617 if (vam->json_output)
3620 ("JSON output supported only for VPE API calls and dump_stats_table");
3625 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3626 "Interface", "sw_if_index",
3627 "sub id", "dot1ad", "tags", "outer id",
3628 "inner id", "exact", "default", "outer any", "inner any");
3630 vec_foreach (sub, vam->sw_if_subif_table)
3633 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3634 sub->interface_name,
3636 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3637 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3638 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3639 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3640 if (sub->vtr_op != L2_VTR_DISABLED)
3643 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3644 "tag1: %d tag2: %d ]\n",
3645 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3646 sub->vtr_tag1, sub->vtr_tag2);
3654 name_sort_cmp (void *a1, void *a2)
3656 name_sort_t *n1 = a1;
3657 name_sort_t *n2 = a2;
3659 return strcmp ((char *) n1->name, (char *) n2->name);
3663 dump_interface_table (vat_main_t * vam)
3666 name_sort_t *nses = 0, *ns;
3668 if (vam->json_output)
3671 ("JSON output supported only for VPE API calls and dump_stats_table");
3676 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3678 vec_add2 (nses, ns, 1);
3679 ns->name = (u8 *)(p->key);
3680 ns->value = (u32) p->value[0];
3684 vec_sort_with_function (nses, name_sort_cmp);
3686 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3687 vec_foreach (ns, nses)
3689 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3696 dump_ip_table (vat_main_t * vam, int is_ipv6)
3698 const ip_details_t *det = NULL;
3699 const ip_address_details_t *address = NULL;
3702 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3704 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3711 fformat (vam->ofp, "%-12d\n", i);
3713 " %-30s%-13s\n", "Address", "Prefix length");
3718 vec_foreach (address, det->addr)
3722 is_ipv6 ? format_ip6_address : format_ip4_address,
3723 address->ip, address->prefix_length);
3731 dump_ipv4_table (vat_main_t * vam)
3733 if (vam->json_output)
3736 ("JSON output supported only for VPE API calls and dump_stats_table");
3740 return dump_ip_table (vam, 0);
3744 dump_ipv6_table (vat_main_t * vam)
3746 if (vam->json_output)
3749 ("JSON output supported only for VPE API calls and dump_stats_table");
3753 return dump_ip_table (vam, 1);
3757 counter_type_to_str (u8 counter_type, u8 is_combined)
3761 switch (counter_type)
3763 case VNET_INTERFACE_COUNTER_DROP:
3765 case VNET_INTERFACE_COUNTER_PUNT:
3767 case VNET_INTERFACE_COUNTER_IP4:
3769 case VNET_INTERFACE_COUNTER_IP6:
3771 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3773 case VNET_INTERFACE_COUNTER_RX_MISS:
3775 case VNET_INTERFACE_COUNTER_RX_ERROR:
3777 case VNET_INTERFACE_COUNTER_TX_ERROR:
3780 return "INVALID-COUNTER-TYPE";
3785 switch (counter_type)
3787 case VNET_INTERFACE_COUNTER_RX:
3789 case VNET_INTERFACE_COUNTER_TX:
3792 return "INVALID-COUNTER-TYPE";
3798 dump_stats_table (vat_main_t * vam)
3800 vat_json_node_t node;
3801 vat_json_node_t *msg_array;
3802 vat_json_node_t *msg;
3803 vat_json_node_t *counter_array;
3804 vat_json_node_t *counter;
3805 interface_counter_t c;
3807 ip4_fib_counter_t *c4;
3808 ip6_fib_counter_t *c6;
3811 if (!vam->json_output)
3813 clib_warning ("dump_stats_table supported only in JSON format");
3817 vat_json_init_object (&node);
3819 /* interface counters */
3820 msg_array = vat_json_object_add (&node, "interface_counters");
3821 vat_json_init_array (msg_array);
3822 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3824 msg = vat_json_array_add (msg_array);
3825 vat_json_init_object (msg);
3826 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3827 (u8 *) counter_type_to_str (i, 0));
3828 vat_json_object_add_int (msg, "is_combined", 0);
3829 counter_array = vat_json_object_add (msg, "data");
3830 vat_json_init_array (counter_array);
3831 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3833 packets = vam->simple_interface_counters[i][j];
3834 vat_json_array_add_uint (counter_array, packets);
3837 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3839 msg = vat_json_array_add (msg_array);
3840 vat_json_init_object (msg);
3841 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3842 (u8 *) counter_type_to_str (i, 1));
3843 vat_json_object_add_int (msg, "is_combined", 1);
3844 counter_array = vat_json_object_add (msg, "data");
3845 vat_json_init_array (counter_array);
3846 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3848 c = vam->combined_interface_counters[i][j];
3849 counter = vat_json_array_add (counter_array);
3850 vat_json_init_object (counter);
3851 vat_json_object_add_uint (counter, "packets", c.packets);
3852 vat_json_object_add_uint (counter, "bytes", c.bytes);
3856 /* ip4 fib counters */
3857 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
3858 vat_json_init_array (msg_array);
3859 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
3861 msg = vat_json_array_add (msg_array);
3862 vat_json_init_object (msg);
3863 vat_json_object_add_uint (msg, "vrf_id",
3864 vam->ip4_fib_counters_vrf_id_by_index[i]);
3865 counter_array = vat_json_object_add (msg, "c");
3866 vat_json_init_array (counter_array);
3867 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
3869 counter = vat_json_array_add (counter_array);
3870 vat_json_init_object (counter);
3871 c4 = &vam->ip4_fib_counters[i][j];
3872 vat_json_object_add_ip4 (counter, "address", c4->address);
3873 vat_json_object_add_uint (counter, "address_length",
3874 c4->address_length);
3875 vat_json_object_add_uint (counter, "packets", c4->packets);
3876 vat_json_object_add_uint (counter, "bytes", c4->bytes);
3880 /* ip6 fib counters */
3881 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
3882 vat_json_init_array (msg_array);
3883 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
3885 msg = vat_json_array_add (msg_array);
3886 vat_json_init_object (msg);
3887 vat_json_object_add_uint (msg, "vrf_id",
3888 vam->ip6_fib_counters_vrf_id_by_index[i]);
3889 counter_array = vat_json_object_add (msg, "c");
3890 vat_json_init_array (counter_array);
3891 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
3893 counter = vat_json_array_add (counter_array);
3894 vat_json_init_object (counter);
3895 c6 = &vam->ip6_fib_counters[i][j];
3896 vat_json_object_add_ip6 (counter, "address", c6->address);
3897 vat_json_object_add_uint (counter, "address_length",
3898 c6->address_length);
3899 vat_json_object_add_uint (counter, "packets", c6->packets);
3900 vat_json_object_add_uint (counter, "bytes", c6->bytes);
3904 vat_json_print (vam->ofp, &node);
3905 vat_json_free (&node);
3911 exec (vat_main_t * vam)
3913 api_main_t *am = &api_main;
3914 vl_api_cli_request_t *mp;
3918 unformat_input_t *i = vam->input;
3920 if (vec_len (i->buffer) == 0)
3923 if (vam->exec_mode == 0 && unformat (i, "mode"))
3928 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
3935 M (CLI_REQUEST, cli_request);
3938 * Copy cmd into shared memory.
3939 * In order for the CLI command to work, it
3940 * must be a vector ending in \n, not a C-string ending
3943 pthread_mutex_lock (&am->vlib_rp->mutex);
3944 oldheap = svm_push_data_heap (am->vlib_rp);
3946 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
3947 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
3949 svm_pop_heap (oldheap);
3950 pthread_mutex_unlock (&am->vlib_rp->mutex);
3952 mp->cmd_in_shmem = (u64) cmd;
3954 timeout = vat_time_now (vam) + 10.0;
3956 while (vat_time_now (vam) < timeout)
3958 if (vam->result_ready == 1)
3961 if (vam->shmem_result != NULL)
3962 fformat (vam->ofp, "%s", vam->shmem_result);
3963 pthread_mutex_lock (&am->vlib_rp->mutex);
3964 oldheap = svm_push_data_heap (am->vlib_rp);
3966 free_me = (u8 *) vam->shmem_result;
3969 svm_pop_heap (oldheap);
3970 pthread_mutex_unlock (&am->vlib_rp->mutex);
3978 api_create_loopback (vat_main_t * vam)
3980 unformat_input_t *i = vam->input;
3981 vl_api_create_loopback_t *mp;
3986 memset (mac_address, 0, sizeof (mac_address));
3988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3990 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
3996 /* Construct the API message */
3997 M (CREATE_LOOPBACK, create_loopback);
3999 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4006 api_delete_loopback (vat_main_t * vam)
4008 unformat_input_t *i = vam->input;
4009 vl_api_delete_loopback_t *mp;
4011 u32 sw_if_index = ~0;
4013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4015 if (unformat (i, "sw_if_index %d", &sw_if_index))
4021 if (sw_if_index == ~0)
4023 errmsg ("missing sw_if_index\n");
4027 /* Construct the API message */
4028 M (DELETE_LOOPBACK, delete_loopback);
4029 mp->sw_if_index = ntohl (sw_if_index);
4036 api_want_stats (vat_main_t * vam)
4038 unformat_input_t *i = vam->input;
4039 vl_api_want_stats_t *mp;
4043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4045 if (unformat (i, "enable"))
4047 else if (unformat (i, "disable"))
4055 errmsg ("missing enable|disable\n");
4059 M (WANT_STATS, want_stats);
4060 mp->enable_disable = enable;
4067 api_want_interface_events (vat_main_t * vam)
4069 unformat_input_t *i = vam->input;
4070 vl_api_want_interface_events_t *mp;
4074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4076 if (unformat (i, "enable"))
4078 else if (unformat (i, "disable"))
4086 errmsg ("missing enable|disable\n");
4090 M (WANT_INTERFACE_EVENTS, want_interface_events);
4091 mp->enable_disable = enable;
4093 vam->interface_event_display = enable;
4100 /* Note: non-static, called once to set up the initial intfc table */
4102 api_sw_interface_dump (vat_main_t * vam)
4104 vl_api_sw_interface_dump_t *mp;
4107 name_sort_t *nses = 0, *ns;
4108 sw_interface_subif_t *sub = NULL;
4110 /* Toss the old name table */
4112 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4114 vec_add2 (nses, ns, 1);
4115 ns->name = (u8 *)(p->key);
4116 ns->value = (u32) p->value[0];
4120 hash_free (vam->sw_if_index_by_interface_name);
4122 vec_foreach (ns, nses) vec_free (ns->name);
4126 vec_foreach (sub, vam->sw_if_subif_table)
4128 vec_free (sub->interface_name);
4130 vec_free (vam->sw_if_subif_table);
4132 /* recreate the interface name hash table */
4133 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4135 /* Get list of ethernets */
4136 M (SW_INTERFACE_DUMP, sw_interface_dump);
4137 mp->name_filter_valid = 1;
4138 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4141 /* and local / loopback interfaces */
4142 M (SW_INTERFACE_DUMP, sw_interface_dump);
4143 mp->name_filter_valid = 1;
4144 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4148 /* and vxlan-gpe tunnel interfaces */
4149 M (SW_INTERFACE_DUMP, sw_interface_dump);
4150 mp->name_filter_valid = 1;
4151 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4152 sizeof (mp->name_filter) - 1);
4155 /* and vxlan tunnel interfaces */
4156 M (SW_INTERFACE_DUMP, sw_interface_dump);
4157 mp->name_filter_valid = 1;
4158 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4161 /* and host (af_packet) interfaces */
4162 M (SW_INTERFACE_DUMP, sw_interface_dump);
4163 mp->name_filter_valid = 1;
4164 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4167 /* and l2tpv3 tunnel interfaces */
4168 M (SW_INTERFACE_DUMP, sw_interface_dump);
4169 mp->name_filter_valid = 1;
4170 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4171 sizeof (mp->name_filter) - 1);
4174 /* and GRE tunnel interfaces */
4175 M (SW_INTERFACE_DUMP, sw_interface_dump);
4176 mp->name_filter_valid = 1;
4177 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4180 /* Use a control ping for synchronization */
4182 vl_api_control_ping_t *mp;
4183 M (CONTROL_PING, control_ping);
4190 api_sw_interface_set_flags (vat_main_t * vam)
4192 unformat_input_t *i = vam->input;
4193 vl_api_sw_interface_set_flags_t *mp;
4196 u8 sw_if_index_set = 0;
4197 u8 admin_up = 0, link_up = 0;
4199 /* Parse args required to build the message */
4200 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4202 if (unformat (i, "admin-up"))
4204 else if (unformat (i, "admin-down"))
4206 else if (unformat (i, "link-up"))
4208 else if (unformat (i, "link-down"))
4210 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4211 sw_if_index_set = 1;
4212 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4213 sw_if_index_set = 1;
4218 if (sw_if_index_set == 0)
4220 errmsg ("missing interface name or sw_if_index\n");
4224 /* Construct the API message */
4225 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4226 mp->sw_if_index = ntohl (sw_if_index);
4227 mp->admin_up_down = admin_up;
4228 mp->link_up_down = link_up;
4233 /* Wait for a reply, return the good/bad news... */
4238 api_sw_interface_clear_stats (vat_main_t * vam)
4240 unformat_input_t *i = vam->input;
4241 vl_api_sw_interface_clear_stats_t *mp;
4244 u8 sw_if_index_set = 0;
4246 /* Parse args required to build the message */
4247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4249 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4250 sw_if_index_set = 1;
4251 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4252 sw_if_index_set = 1;
4257 /* Construct the API message */
4258 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4260 if (sw_if_index_set == 1)
4261 mp->sw_if_index = ntohl (sw_if_index);
4263 mp->sw_if_index = ~0;
4268 /* Wait for a reply, return the good/bad news... */
4273 api_sw_interface_add_del_address (vat_main_t * vam)
4275 unformat_input_t *i = vam->input;
4276 vl_api_sw_interface_add_del_address_t *mp;
4279 u8 sw_if_index_set = 0;
4280 u8 is_add = 1, del_all = 0;
4281 u32 address_length = 0;
4282 u8 v4_address_set = 0;
4283 u8 v6_address_set = 0;
4284 ip4_address_t v4address;
4285 ip6_address_t v6address;
4287 /* Parse args required to build the message */
4288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4290 if (unformat (i, "del-all"))
4292 else if (unformat (i, "del"))
4294 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4295 sw_if_index_set = 1;
4296 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4297 sw_if_index_set = 1;
4298 else if (unformat (i, "%U/%d",
4299 unformat_ip4_address, &v4address, &address_length))
4301 else if (unformat (i, "%U/%d",
4302 unformat_ip6_address, &v6address, &address_length))
4308 if (sw_if_index_set == 0)
4310 errmsg ("missing interface name or sw_if_index\n");
4313 if (v4_address_set && v6_address_set)
4315 errmsg ("both v4 and v6 addresses set\n");
4318 if (!v4_address_set && !v6_address_set && !del_all)
4320 errmsg ("no addresses set\n");
4324 /* Construct the API message */
4325 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4327 mp->sw_if_index = ntohl (sw_if_index);
4328 mp->is_add = is_add;
4329 mp->del_all = del_all;
4333 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4337 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4339 mp->address_length = address_length;
4344 /* Wait for a reply, return good/bad news */
4349 api_sw_interface_set_table (vat_main_t * vam)
4351 unformat_input_t *i = vam->input;
4352 vl_api_sw_interface_set_table_t *mp;
4354 u32 sw_if_index, vrf_id = 0;
4355 u8 sw_if_index_set = 0;
4358 /* Parse args required to build the message */
4359 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4361 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4362 sw_if_index_set = 1;
4363 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4364 sw_if_index_set = 1;
4365 else if (unformat (i, "vrf %d", &vrf_id))
4367 else if (unformat (i, "ipv6"))
4373 if (sw_if_index_set == 0)
4375 errmsg ("missing interface name or sw_if_index\n");
4379 /* Construct the API message */
4380 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4382 mp->sw_if_index = ntohl (sw_if_index);
4383 mp->is_ipv6 = is_ipv6;
4384 mp->vrf_id = ntohl (vrf_id);
4389 /* Wait for a reply... */
4394 api_sw_interface_set_vpath (vat_main_t * vam)
4396 unformat_input_t *i = vam->input;
4397 vl_api_sw_interface_set_vpath_t *mp;
4399 u32 sw_if_index = 0;
4400 u8 sw_if_index_set = 0;
4403 /* Parse args required to build the message */
4404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4406 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4407 sw_if_index_set = 1;
4408 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4409 sw_if_index_set = 1;
4410 else if (unformat (i, "enable"))
4412 else if (unformat (i, "disable"))
4418 if (sw_if_index_set == 0)
4420 errmsg ("missing interface name or sw_if_index\n");
4424 /* Construct the API message */
4425 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4427 mp->sw_if_index = ntohl (sw_if_index);
4428 mp->enable = is_enable;
4433 /* Wait for a reply... */
4438 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4440 unformat_input_t *i = vam->input;
4441 vl_api_sw_interface_set_l2_xconnect_t *mp;
4444 u8 rx_sw_if_index_set = 0;
4446 u8 tx_sw_if_index_set = 0;
4449 /* Parse args required to build the message */
4450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4452 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4453 rx_sw_if_index_set = 1;
4454 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4455 tx_sw_if_index_set = 1;
4456 else if (unformat (i, "rx"))
4458 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4460 if (unformat (i, "%U", unformat_sw_if_index, vam,
4462 rx_sw_if_index_set = 1;
4467 else if (unformat (i, "tx"))
4469 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4471 if (unformat (i, "%U", unformat_sw_if_index, vam,
4473 tx_sw_if_index_set = 1;
4478 else if (unformat (i, "enable"))
4480 else if (unformat (i, "disable"))
4486 if (rx_sw_if_index_set == 0)
4488 errmsg ("missing rx interface name or rx_sw_if_index\n");
4492 if (enable && (tx_sw_if_index_set == 0))
4494 errmsg ("missing tx interface name or tx_sw_if_index\n");
4498 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4500 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4501 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4502 mp->enable = enable;
4511 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4513 unformat_input_t *i = vam->input;
4514 vl_api_sw_interface_set_l2_bridge_t *mp;
4517 u8 rx_sw_if_index_set = 0;
4524 /* Parse args required to build the message */
4525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4527 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4528 rx_sw_if_index_set = 1;
4529 else if (unformat (i, "bd_id %d", &bd_id))
4531 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4532 rx_sw_if_index_set = 1;
4533 else if (unformat (i, "shg %d", &shg))
4535 else if (unformat (i, "bvi"))
4537 else if (unformat (i, "enable"))
4539 else if (unformat (i, "disable"))
4545 if (rx_sw_if_index_set == 0)
4547 errmsg ("missing rx interface name or sw_if_index\n");
4551 if (enable && (bd_id_set == 0))
4553 errmsg ("missing bridge domain\n");
4557 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4559 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4560 mp->bd_id = ntohl (bd_id);
4563 mp->enable = enable;
4572 api_bridge_domain_dump (vat_main_t * vam)
4574 unformat_input_t *i = vam->input;
4575 vl_api_bridge_domain_dump_t *mp;
4579 /* Parse args required to build the message */
4580 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4582 if (unformat (i, "bd_id %d", &bd_id))
4588 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4589 mp->bd_id = ntohl (bd_id);
4592 /* Use a control ping for synchronization */
4594 vl_api_control_ping_t *mp;
4595 M (CONTROL_PING, control_ping);
4605 api_bridge_domain_add_del (vat_main_t * vam)
4607 unformat_input_t *i = vam->input;
4608 vl_api_bridge_domain_add_del_t *mp;
4612 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4614 /* Parse args required to build the message */
4615 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4617 if (unformat (i, "bd_id %d", &bd_id))
4619 else if (unformat (i, "flood %d", &flood))
4621 else if (unformat (i, "uu-flood %d", &uu_flood))
4623 else if (unformat (i, "forward %d", &forward))
4625 else if (unformat (i, "learn %d", &learn))
4627 else if (unformat (i, "arp-term %d", &arp_term))
4629 else if (unformat (i, "del"))
4632 flood = uu_flood = forward = learn = 0;
4640 errmsg ("missing bridge domain\n");
4644 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4646 mp->bd_id = ntohl (bd_id);
4648 mp->uu_flood = uu_flood;
4649 mp->forward = forward;
4651 mp->arp_term = arp_term;
4652 mp->is_add = is_add;
4661 api_l2fib_add_del (vat_main_t * vam)
4663 unformat_input_t *i = vam->input;
4664 vl_api_l2fib_add_del_t *mp;
4671 u8 sw_if_index_set = 0;
4680 /* Parse args required to build the message */
4681 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4683 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4685 else if (unformat (i, "bd_id %d", &bd_id))
4687 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4688 sw_if_index_set = 1;
4689 else if (unformat (i, "sw_if"))
4691 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4693 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4694 sw_if_index_set = 1;
4699 else if (unformat (i, "static"))
4701 else if (unformat (i, "filter"))
4706 else if (unformat (i, "bvi"))
4711 else if (unformat (i, "del"))
4713 else if (unformat (i, "count %d", &count))
4721 errmsg ("missing mac address\n");
4727 errmsg ("missing bridge domain\n");
4731 if (is_add && (sw_if_index_set == 0))
4733 errmsg ("missing interface name or sw_if_index\n");
4739 /* Turn on async mode */
4740 vam->async_mode = 1;
4741 vam->async_errors = 0;
4742 before = vat_time_now (vam);
4745 for (j = 0; j < count; j++)
4747 M (L2FIB_ADD_DEL, l2fib_add_del);
4750 mp->bd_id = ntohl (bd_id);
4751 mp->is_add = is_add;
4755 mp->sw_if_index = ntohl (sw_if_index);
4756 mp->static_mac = static_mac;
4757 mp->filter_mac = filter_mac;
4758 mp->bvi_mac = bvi_mac;
4760 increment_mac_address (&mac);
4767 vl_api_control_ping_t *mp;
4770 /* Shut off async mode */
4771 vam->async_mode = 0;
4773 M (CONTROL_PING, control_ping);
4776 timeout = vat_time_now (vam) + 1.0;
4777 while (vat_time_now (vam) < timeout)
4778 if (vam->result_ready == 1)
4783 if (vam->retval == -99)
4784 errmsg ("timeout\n");
4786 if (vam->async_errors > 0)
4788 errmsg ("%d asynchronous errors\n", vam->async_errors);
4791 vam->async_errors = 0;
4792 after = vat_time_now (vam);
4794 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4795 count, after - before, count / (after - before));
4799 /* Wait for a reply... */
4802 /* Return the good/bad news */
4803 return (vam->retval);
4807 api_l2_flags (vat_main_t * vam)
4809 unformat_input_t *i = vam->input;
4810 vl_api_l2_flags_t *mp;
4813 u32 feature_bitmap = 0;
4814 u8 sw_if_index_set = 0;
4816 /* Parse args required to build the message */
4817 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4819 if (unformat (i, "sw_if_index %d", &sw_if_index))
4820 sw_if_index_set = 1;
4821 else if (unformat (i, "sw_if"))
4823 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4825 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4826 sw_if_index_set = 1;
4831 else if (unformat (i, "learn"))
4832 feature_bitmap |= L2INPUT_FEAT_LEARN;
4833 else if (unformat (i, "forward"))
4834 feature_bitmap |= L2INPUT_FEAT_FWD;
4835 else if (unformat (i, "flood"))
4836 feature_bitmap |= L2INPUT_FEAT_FLOOD;
4837 else if (unformat (i, "uu-flood"))
4838 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
4843 if (sw_if_index_set == 0)
4845 errmsg ("missing interface name or sw_if_index\n");
4849 M (L2_FLAGS, l2_flags);
4851 mp->sw_if_index = ntohl (sw_if_index);
4852 mp->feature_bitmap = ntohl (feature_bitmap);
4861 api_bridge_flags (vat_main_t * vam)
4863 unformat_input_t *i = vam->input;
4864 vl_api_bridge_flags_t *mp;
4871 /* Parse args required to build the message */
4872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4874 if (unformat (i, "bd_id %d", &bd_id))
4876 else if (unformat (i, "learn"))
4878 else if (unformat (i, "forward"))
4880 else if (unformat (i, "flood"))
4882 else if (unformat (i, "uu-flood"))
4883 flags |= L2_UU_FLOOD;
4884 else if (unformat (i, "arp-term"))
4885 flags |= L2_ARP_TERM;
4886 else if (unformat (i, "off"))
4888 else if (unformat (i, "disable"))
4896 errmsg ("missing bridge domain\n");
4900 M (BRIDGE_FLAGS, bridge_flags);
4902 mp->bd_id = ntohl (bd_id);
4903 mp->feature_bitmap = ntohl (flags);
4904 mp->is_set = is_set;
4913 api_bd_ip_mac_add_del (vat_main_t * vam)
4915 unformat_input_t *i = vam->input;
4916 vl_api_bd_ip_mac_add_del_t *mp;
4924 ip4_address_t v4addr;
4925 ip6_address_t v6addr;
4929 /* Parse args required to build the message */
4930 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4932 if (unformat (i, "bd_id %d", &bd_id))
4936 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
4940 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
4945 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
4949 else if (unformat (i, "del"))
4957 errmsg ("missing bridge domain\n");
4960 else if (ip_set == 0)
4962 errmsg ("missing IP address\n");
4965 else if (mac_set == 0)
4967 errmsg ("missing MAC address\n");
4971 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
4973 mp->bd_id = ntohl (bd_id);
4974 mp->is_ipv6 = is_ipv6;
4975 mp->is_add = is_add;
4977 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
4979 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
4980 clib_memcpy (mp->mac_address, macaddr, 6);
4988 api_tap_connect (vat_main_t * vam)
4990 unformat_input_t *i = vam->input;
4991 vl_api_tap_connect_t *mp;
4998 memset (mac_address, 0, sizeof (mac_address));
5000 /* Parse args required to build the message */
5001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5003 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5007 else if (unformat (i, "random-mac"))
5009 else if (unformat (i, "tapname %s", &tap_name))
5017 errmsg ("missing tap name\n");
5020 if (vec_len (tap_name) > 63)
5022 errmsg ("tap name too long\n");
5024 vec_add1 (tap_name, 0);
5026 /* Construct the API message */
5027 M (TAP_CONNECT, tap_connect);
5029 mp->use_random_mac = random_mac;
5030 clib_memcpy (mp->mac_address, mac_address, 6);
5031 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5032 vec_free (tap_name);
5037 /* Wait for a reply... */
5042 api_tap_modify (vat_main_t * vam)
5044 unformat_input_t *i = vam->input;
5045 vl_api_tap_modify_t *mp;
5051 u32 sw_if_index = ~0;
5052 u8 sw_if_index_set = 0;
5054 memset (mac_address, 0, sizeof (mac_address));
5056 /* Parse args required to build the message */
5057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5059 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5060 sw_if_index_set = 1;
5061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5062 sw_if_index_set = 1;
5063 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5067 else if (unformat (i, "random-mac"))
5069 else if (unformat (i, "tapname %s", &tap_name))
5075 if (sw_if_index_set == 0)
5077 errmsg ("missing vpp interface name");
5082 errmsg ("missing tap name\n");
5085 if (vec_len (tap_name) > 63)
5087 errmsg ("tap name too long\n");
5089 vec_add1 (tap_name, 0);
5091 /* Construct the API message */
5092 M (TAP_MODIFY, tap_modify);
5094 mp->use_random_mac = random_mac;
5095 mp->sw_if_index = ntohl (sw_if_index);
5096 clib_memcpy (mp->mac_address, mac_address, 6);
5097 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5098 vec_free (tap_name);
5103 /* Wait for a reply... */
5108 api_tap_delete (vat_main_t * vam)
5110 unformat_input_t *i = vam->input;
5111 vl_api_tap_delete_t *mp;
5113 u32 sw_if_index = ~0;
5114 u8 sw_if_index_set = 0;
5116 /* Parse args required to build the message */
5117 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5119 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5120 sw_if_index_set = 1;
5121 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5122 sw_if_index_set = 1;
5127 if (sw_if_index_set == 0)
5129 errmsg ("missing vpp interface name");
5133 /* Construct the API message */
5134 M (TAP_DELETE, tap_delete);
5136 mp->sw_if_index = ntohl (sw_if_index);
5141 /* Wait for a reply... */
5146 api_ip_add_del_route (vat_main_t * vam)
5148 unformat_input_t *i = vam->input;
5149 vl_api_ip_add_del_route_t *mp;
5151 u32 sw_if_index = ~0, vrf_id = 0;
5152 u8 sw_if_index_set = 0;
5154 u8 is_local = 0, is_drop = 0;
5155 u8 create_vrf_if_needed = 0;
5157 u8 next_hop_weight = 1;
5159 u8 is_multipath = 0;
5161 u8 address_length_set = 0;
5162 u32 lookup_in_vrf = 0;
5163 u32 resolve_attempts = 0;
5164 u32 dst_address_length = 0;
5165 u8 next_hop_set = 0;
5166 ip4_address_t v4_dst_address, v4_next_hop_address;
5167 ip6_address_t v6_dst_address, v6_next_hop_address;
5171 u32 random_add_del = 0;
5172 u32 *random_vector = 0;
5174 u32 random_seed = 0xdeaddabe;
5175 u32 classify_table_index = ~0;
5178 /* Parse args required to build the message */
5179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5181 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5182 sw_if_index_set = 1;
5183 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5184 sw_if_index_set = 1;
5185 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5190 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5195 else if (unformat (i, "/%d", &dst_address_length))
5197 address_length_set = 1;
5200 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5201 &v4_next_hop_address))
5205 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5206 &v6_next_hop_address))
5210 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5212 else if (unformat (i, "weight %d", &next_hop_weight))
5214 else if (unformat (i, "drop"))
5218 else if (unformat (i, "local"))
5222 else if (unformat (i, "classify %d", &classify_table_index))
5226 else if (unformat (i, "del"))
5228 else if (unformat (i, "add"))
5230 else if (unformat (i, "not-last"))
5232 else if (unformat (i, "multipath"))
5234 else if (unformat (i, "vrf %d", &vrf_id))
5236 else if (unformat (i, "create-vrf"))
5237 create_vrf_if_needed = 1;
5238 else if (unformat (i, "count %d", &count))
5240 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5242 else if (unformat (i, "random"))
5244 else if (unformat (i, "seed %d", &random_seed))
5248 clib_warning ("parse error '%U'", format_unformat_error, i);
5253 if (resolve_attempts > 0 && sw_if_index_set == 0)
5255 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5259 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5261 errmsg ("next hop / local / drop / classify not set\n");
5265 if (address_set == 0)
5267 errmsg ("missing addresses\n");
5271 if (address_length_set == 0)
5273 errmsg ("missing address length\n");
5277 /* Generate a pile of unique, random routes */
5280 u32 this_random_address;
5281 random_hash = hash_create (count, sizeof (uword));
5283 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5284 for (j = 0; j <= count; j++)
5288 this_random_address = random_u32 (&random_seed);
5289 this_random_address =
5290 clib_host_to_net_u32 (this_random_address);
5292 while (hash_get (random_hash, this_random_address));
5293 vec_add1 (random_vector, this_random_address);
5294 hash_set (random_hash, this_random_address, 1);
5296 hash_free (random_hash);
5297 v4_dst_address.as_u32 = random_vector[0];
5302 /* Turn on async mode */
5303 vam->async_mode = 1;
5304 vam->async_errors = 0;
5305 before = vat_time_now (vam);
5308 for (j = 0; j < count; j++)
5310 /* Construct the API message */
5311 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5313 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5314 mp->vrf_id = ntohl (vrf_id);
5315 if (resolve_attempts > 0)
5317 mp->resolve_attempts = ntohl (resolve_attempts);
5318 mp->resolve_if_needed = 1;
5320 mp->create_vrf_if_needed = create_vrf_if_needed;
5322 mp->is_add = is_add;
5323 mp->is_drop = is_drop;
5324 mp->is_ipv6 = is_ipv6;
5325 mp->is_local = is_local;
5326 mp->is_classify = is_classify;
5327 mp->is_multipath = is_multipath;
5328 mp->not_last = not_last;
5329 mp->next_hop_weight = next_hop_weight;
5330 mp->dst_address_length = dst_address_length;
5331 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5332 mp->classify_table_index = ntohl (classify_table_index);
5336 clib_memcpy (mp->dst_address, &v6_dst_address,
5337 sizeof (v6_dst_address));
5339 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5340 sizeof (v6_next_hop_address));
5341 increment_v6_address (&v6_dst_address);
5345 clib_memcpy (mp->dst_address, &v4_dst_address,
5346 sizeof (v4_dst_address));
5348 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5349 sizeof (v4_next_hop_address));
5351 v4_dst_address.as_u32 = random_vector[j + 1];
5353 increment_v4_address (&v4_dst_address);
5359 /* When testing multiple add/del ops, use a control-ping to sync */
5362 vl_api_control_ping_t *mp;
5365 /* Shut off async mode */
5366 vam->async_mode = 0;
5368 M (CONTROL_PING, control_ping);
5371 timeout = vat_time_now (vam) + 1.0;
5372 while (vat_time_now (vam) < timeout)
5373 if (vam->result_ready == 1)
5378 if (vam->retval == -99)
5379 errmsg ("timeout\n");
5381 if (vam->async_errors > 0)
5383 errmsg ("%d asynchronous errors\n", vam->async_errors);
5386 vam->async_errors = 0;
5387 after = vat_time_now (vam);
5389 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5390 count, after - before, count / (after - before));
5394 /* Wait for a reply... */
5398 /* Return the good/bad news */
5399 return (vam->retval);
5403 api_proxy_arp_add_del (vat_main_t * vam)
5405 unformat_input_t *i = vam->input;
5406 vl_api_proxy_arp_add_del_t *mp;
5410 ip4_address_t lo, hi;
5413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5415 if (unformat (i, "vrf %d", &vrf_id))
5417 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5418 unformat_ip4_address, &hi))
5420 else if (unformat (i, "del"))
5424 clib_warning ("parse error '%U'", format_unformat_error, i);
5431 errmsg ("address range not set\n");
5435 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5437 mp->vrf_id = ntohl (vrf_id);
5438 mp->is_add = is_add;
5439 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5440 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5449 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5451 unformat_input_t *i = vam->input;
5452 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5456 u8 sw_if_index_set = 0;
5458 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5460 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5461 sw_if_index_set = 1;
5462 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5463 sw_if_index_set = 1;
5464 else if (unformat (i, "enable"))
5466 else if (unformat (i, "disable"))
5470 clib_warning ("parse error '%U'", format_unformat_error, i);
5475 if (sw_if_index_set == 0)
5477 errmsg ("missing interface name or sw_if_index\n");
5481 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5483 mp->sw_if_index = ntohl (sw_if_index);
5484 mp->enable_disable = enable;
5493 api_mpls_add_del_decap (vat_main_t * vam)
5495 unformat_input_t *i = vam->input;
5496 vl_api_mpls_add_del_decap_t *mp;
5505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5507 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5509 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5511 else if (unformat (i, "label %d", &label))
5513 else if (unformat (i, "next-index %d", &next_index))
5515 else if (unformat (i, "del"))
5517 else if (unformat (i, "s-bit-clear"))
5521 clib_warning ("parse error '%U'", format_unformat_error, i);
5526 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5528 mp->rx_vrf_id = ntohl (rx_vrf_id);
5529 mp->tx_vrf_id = ntohl (tx_vrf_id);
5530 mp->label = ntohl (label);
5531 mp->next_index = ntohl (next_index);
5533 mp->is_add = is_add;
5542 api_mpls_add_del_encap (vat_main_t * vam)
5544 unformat_input_t *i = vam->input;
5545 vl_api_mpls_add_del_encap_t *mp;
5550 ip4_address_t dst_address;
5553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5555 if (unformat (i, "vrf %d", &vrf_id))
5557 else if (unformat (i, "label %d", &label))
5558 vec_add1 (labels, ntohl (label));
5559 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5561 else if (unformat (i, "del"))
5565 clib_warning ("parse error '%U'", format_unformat_error, i);
5570 if (vec_len (labels) == 0)
5572 errmsg ("missing encap label stack\n");
5576 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5577 sizeof (u32) * vec_len (labels));
5579 mp->vrf_id = ntohl (vrf_id);
5580 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5581 mp->is_add = is_add;
5582 mp->nlabels = vec_len (labels);
5583 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5594 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5596 unformat_input_t *i = vam->input;
5597 vl_api_mpls_gre_add_del_tunnel_t *mp;
5599 u32 inner_vrf_id = 0;
5600 u32 outer_vrf_id = 0;
5601 ip4_address_t src_address;
5602 ip4_address_t dst_address;
5603 ip4_address_t intfc_address;
5605 u8 intfc_address_length = 0;
5609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5611 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5613 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5615 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5617 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5619 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5620 &intfc_address, &tmp))
5621 intfc_address_length = tmp;
5622 else if (unformat (i, "l2-only"))
5624 else if (unformat (i, "del"))
5628 clib_warning ("parse error '%U'", format_unformat_error, i);
5633 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5635 mp->inner_vrf_id = ntohl (inner_vrf_id);
5636 mp->outer_vrf_id = ntohl (outer_vrf_id);
5637 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5638 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5639 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5640 mp->intfc_address_length = intfc_address_length;
5641 mp->l2_only = l2_only;
5642 mp->is_add = is_add;
5651 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5653 unformat_input_t *i = vam->input;
5654 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5656 u32 inner_vrf_id = 0;
5657 ip4_address_t intfc_address;
5658 u8 dst_mac_address[6];
5661 u8 intfc_address_length = 0;
5665 int tx_sw_if_index_set = 0;
5667 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5669 if (unformat (i, "vrf %d", &inner_vrf_id))
5671 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5672 &intfc_address, &tmp))
5673 intfc_address_length = tmp;
5674 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5675 tx_sw_if_index_set = 1;
5676 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5677 tx_sw_if_index_set = 1;
5678 else if (unformat (i, "dst %U", unformat_ethernet_address,
5681 else if (unformat (i, "l2-only"))
5683 else if (unformat (i, "del"))
5687 clib_warning ("parse error '%U'", format_unformat_error, i);
5694 errmsg ("dst (mac address) not set\n");
5697 if (!tx_sw_if_index_set)
5699 errmsg ("tx-intfc not set\n");
5703 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5705 mp->vrf_id = ntohl (inner_vrf_id);
5706 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5707 mp->adj_address_length = intfc_address_length;
5708 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5709 sizeof (dst_mac_address));
5710 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5711 mp->l2_only = l2_only;
5712 mp->is_add = is_add;
5721 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5723 unformat_input_t *i = vam->input;
5724 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5726 u32 inner_vrf_id = 0;
5727 u32 outer_vrf_id = 0;
5728 ip4_address_t adj_address;
5729 int adj_address_set = 0;
5730 ip4_address_t next_hop_address;
5731 int next_hop_address_set = 0;
5733 u8 adj_address_length = 0;
5736 u32 resolve_attempts = 5;
5737 u8 resolve_if_needed = 1;
5739 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5741 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5743 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5745 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5746 &adj_address, &tmp))
5748 adj_address_length = tmp;
5749 adj_address_set = 1;
5751 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5753 next_hop_address_set = 1;
5754 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5756 else if (unformat (i, "resolve-if-needed %d", &tmp))
5757 resolve_if_needed = tmp;
5758 else if (unformat (i, "l2-only"))
5760 else if (unformat (i, "del"))
5764 clib_warning ("parse error '%U'", format_unformat_error, i);
5769 if (!adj_address_set)
5771 errmsg ("adjacency address/mask not set\n");
5774 if (!next_hop_address_set)
5776 errmsg ("ip4 next hop address (in outer fib) not set\n");
5780 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5782 mp->inner_vrf_id = ntohl (inner_vrf_id);
5783 mp->outer_vrf_id = ntohl (outer_vrf_id);
5784 mp->resolve_attempts = ntohl (resolve_attempts);
5785 mp->resolve_if_needed = resolve_if_needed;
5786 mp->is_add = is_add;
5787 mp->l2_only = l2_only;
5788 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5789 mp->adj_address_length = adj_address_length;
5790 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5791 sizeof (next_hop_address));
5800 api_sw_interface_set_unnumbered (vat_main_t * vam)
5802 unformat_input_t *i = vam->input;
5803 vl_api_sw_interface_set_unnumbered_t *mp;
5806 u32 unnum_sw_index = ~0;
5808 u8 sw_if_index_set = 0;
5810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5812 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5813 sw_if_index_set = 1;
5814 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5815 sw_if_index_set = 1;
5816 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
5818 else if (unformat (i, "del"))
5822 clib_warning ("parse error '%U'", format_unformat_error, i);
5827 if (sw_if_index_set == 0)
5829 errmsg ("missing interface name or sw_if_index\n");
5833 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
5835 mp->sw_if_index = ntohl (sw_if_index);
5836 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
5837 mp->is_add = is_add;
5846 api_ip_neighbor_add_del (vat_main_t * vam)
5848 unformat_input_t *i = vam->input;
5849 vl_api_ip_neighbor_add_del_t *mp;
5852 u8 sw_if_index_set = 0;
5858 u8 v4_address_set = 0;
5859 u8 v6_address_set = 0;
5860 ip4_address_t v4address;
5861 ip6_address_t v6address;
5863 memset (mac_address, 0, sizeof (mac_address));
5865 /* Parse args required to build the message */
5866 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5868 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5872 else if (unformat (i, "del"))
5874 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5875 sw_if_index_set = 1;
5876 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5877 sw_if_index_set = 1;
5878 else if (unformat (i, "is_static"))
5880 else if (unformat (i, "vrf %d", &vrf_id))
5882 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
5884 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
5888 clib_warning ("parse error '%U'", format_unformat_error, i);
5893 if (sw_if_index_set == 0)
5895 errmsg ("missing interface name or sw_if_index\n");
5898 if (v4_address_set && v6_address_set)
5900 errmsg ("both v4 and v6 addresses set\n");
5903 if (!v4_address_set && !v6_address_set)
5905 errmsg ("no address set\n");
5909 /* Construct the API message */
5910 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
5912 mp->sw_if_index = ntohl (sw_if_index);
5913 mp->is_add = is_add;
5914 mp->vrf_id = ntohl (vrf_id);
5915 mp->is_static = is_static;
5917 clib_memcpy (mp->mac_address, mac_address, 6);
5921 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
5925 /* mp->is_ipv6 = 0; via memset in M macro above */
5926 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
5932 /* Wait for a reply, return good/bad news */
5940 api_reset_vrf (vat_main_t * vam)
5942 unformat_input_t *i = vam->input;
5943 vl_api_reset_vrf_t *mp;
5949 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5951 if (unformat (i, "vrf %d", &vrf_id))
5953 else if (unformat (i, "ipv6"))
5957 clib_warning ("parse error '%U'", format_unformat_error, i);
5962 if (vrf_id_set == 0)
5964 errmsg ("missing vrf id\n");
5968 M (RESET_VRF, reset_vrf);
5970 mp->vrf_id = ntohl (vrf_id);
5971 mp->is_ipv6 = is_ipv6;
5980 api_create_vlan_subif (vat_main_t * vam)
5982 unformat_input_t *i = vam->input;
5983 vl_api_create_vlan_subif_t *mp;
5986 u8 sw_if_index_set = 0;
5990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5992 if (unformat (i, "sw_if_index %d", &sw_if_index))
5993 sw_if_index_set = 1;
5994 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5995 sw_if_index_set = 1;
5996 else if (unformat (i, "vlan %d", &vlan_id))
6000 clib_warning ("parse error '%U'", format_unformat_error, i);
6005 if (sw_if_index_set == 0)
6007 errmsg ("missing interface name or sw_if_index\n");
6011 if (vlan_id_set == 0)
6013 errmsg ("missing vlan_id\n");
6016 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6018 mp->sw_if_index = ntohl (sw_if_index);
6019 mp->vlan_id = ntohl (vlan_id);
6027 #define foreach_create_subif_bit \
6034 _(outer_vlan_id_any) \
6035 _(inner_vlan_id_any)
6038 api_create_subif (vat_main_t * vam)
6040 unformat_input_t *i = vam->input;
6041 vl_api_create_subif_t *mp;
6044 u8 sw_if_index_set = 0;
6051 u32 exact_match = 0;
6052 u32 default_sub = 0;
6053 u32 outer_vlan_id_any = 0;
6054 u32 inner_vlan_id_any = 0;
6056 u16 outer_vlan_id = 0;
6057 u16 inner_vlan_id = 0;
6059 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6061 if (unformat (i, "sw_if_index %d", &sw_if_index))
6062 sw_if_index_set = 1;
6063 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6064 sw_if_index_set = 1;
6065 else if (unformat (i, "sub_id %d", &sub_id))
6067 else if (unformat (i, "outer_vlan_id %d", &tmp))
6068 outer_vlan_id = tmp;
6069 else if (unformat (i, "inner_vlan_id %d", &tmp))
6070 inner_vlan_id = tmp;
6072 #define _(a) else if (unformat (i, #a)) a = 1 ;
6073 foreach_create_subif_bit
6077 clib_warning ("parse error '%U'", format_unformat_error, i);
6082 if (sw_if_index_set == 0)
6084 errmsg ("missing interface name or sw_if_index\n");
6088 if (sub_id_set == 0)
6090 errmsg ("missing sub_id\n");
6093 M (CREATE_SUBIF, create_subif);
6095 mp->sw_if_index = ntohl (sw_if_index);
6096 mp->sub_id = ntohl (sub_id);
6098 #define _(a) mp->a = a;
6099 foreach_create_subif_bit;
6102 mp->outer_vlan_id = ntohs (outer_vlan_id);
6103 mp->inner_vlan_id = ntohs (inner_vlan_id);
6112 api_oam_add_del (vat_main_t * vam)
6114 unformat_input_t *i = vam->input;
6115 vl_api_oam_add_del_t *mp;
6119 ip4_address_t src, dst;
6123 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6125 if (unformat (i, "vrf %d", &vrf_id))
6127 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6129 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6131 else if (unformat (i, "del"))
6135 clib_warning ("parse error '%U'", format_unformat_error, i);
6142 errmsg ("missing src addr\n");
6148 errmsg ("missing dst addr\n");
6152 M (OAM_ADD_DEL, oam_add_del);
6154 mp->vrf_id = ntohl (vrf_id);
6155 mp->is_add = is_add;
6156 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6157 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6166 api_reset_fib (vat_main_t * vam)
6168 unformat_input_t *i = vam->input;
6169 vl_api_reset_fib_t *mp;
6175 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6177 if (unformat (i, "vrf %d", &vrf_id))
6179 else if (unformat (i, "ipv6"))
6183 clib_warning ("parse error '%U'", format_unformat_error, i);
6188 if (vrf_id_set == 0)
6190 errmsg ("missing vrf id\n");
6194 M (RESET_FIB, reset_fib);
6196 mp->vrf_id = ntohl (vrf_id);
6197 mp->is_ipv6 = is_ipv6;
6206 api_dhcp_proxy_config (vat_main_t * vam)
6208 unformat_input_t *i = vam->input;
6209 vl_api_dhcp_proxy_config_t *mp;
6214 u8 v4_address_set = 0;
6215 u8 v6_address_set = 0;
6216 ip4_address_t v4address;
6217 ip6_address_t v6address;
6218 u8 v4_src_address_set = 0;
6219 u8 v6_src_address_set = 0;
6220 ip4_address_t v4srcaddress;
6221 ip6_address_t v6srcaddress;
6223 /* Parse args required to build the message */
6224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6226 if (unformat (i, "del"))
6228 else if (unformat (i, "vrf %d", &vrf_id))
6230 else if (unformat (i, "insert-cid %d", &insert_cid))
6232 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6234 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6236 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6237 v4_src_address_set = 1;
6238 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6239 v6_src_address_set = 1;
6244 if (v4_address_set && v6_address_set)
6246 errmsg ("both v4 and v6 server addresses set\n");
6249 if (!v4_address_set && !v6_address_set)
6251 errmsg ("no server addresses set\n");
6255 if (v4_src_address_set && v6_src_address_set)
6257 errmsg ("both v4 and v6 src addresses set\n");
6260 if (!v4_src_address_set && !v6_src_address_set)
6262 errmsg ("no src addresses set\n");
6266 if (!(v4_src_address_set && v4_address_set) &&
6267 !(v6_src_address_set && v6_address_set))
6269 errmsg ("no matching server and src addresses set\n");
6273 /* Construct the API message */
6274 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6276 mp->insert_circuit_id = insert_cid;
6277 mp->is_add = is_add;
6278 mp->vrf_id = ntohl (vrf_id);
6282 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6283 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6287 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6288 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6294 /* Wait for a reply, return good/bad news */
6301 api_dhcp_proxy_config_2 (vat_main_t * vam)
6303 unformat_input_t *i = vam->input;
6304 vl_api_dhcp_proxy_config_2_t *mp;
6307 u32 server_vrf_id = 0;
6310 u8 v4_address_set = 0;
6311 u8 v6_address_set = 0;
6312 ip4_address_t v4address;
6313 ip6_address_t v6address;
6314 u8 v4_src_address_set = 0;
6315 u8 v6_src_address_set = 0;
6316 ip4_address_t v4srcaddress;
6317 ip6_address_t v6srcaddress;
6319 /* Parse args required to build the message */
6320 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6322 if (unformat (i, "del"))
6324 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6326 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6328 else if (unformat (i, "insert-cid %d", &insert_cid))
6330 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6332 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6334 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6335 v4_src_address_set = 1;
6336 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6337 v6_src_address_set = 1;
6342 if (v4_address_set && v6_address_set)
6344 errmsg ("both v4 and v6 server addresses set\n");
6347 if (!v4_address_set && !v6_address_set)
6349 errmsg ("no server addresses set\n");
6353 if (v4_src_address_set && v6_src_address_set)
6355 errmsg ("both v4 and v6 src addresses set\n");
6358 if (!v4_src_address_set && !v6_src_address_set)
6360 errmsg ("no src addresses set\n");
6364 if (!(v4_src_address_set && v4_address_set) &&
6365 !(v6_src_address_set && v6_address_set))
6367 errmsg ("no matching server and src addresses set\n");
6371 /* Construct the API message */
6372 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6374 mp->insert_circuit_id = insert_cid;
6375 mp->is_add = is_add;
6376 mp->rx_vrf_id = ntohl (rx_vrf_id);
6377 mp->server_vrf_id = ntohl (server_vrf_id);
6381 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6382 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6386 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6387 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6393 /* Wait for a reply, return good/bad news */
6400 api_dhcp_proxy_set_vss (vat_main_t * vam)
6402 unformat_input_t *i = vam->input;
6403 vl_api_dhcp_proxy_set_vss_t *mp;
6414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6416 if (unformat (i, "tbl_id %d", &tbl_id))
6418 if (unformat (i, "fib_id %d", &fib_id))
6420 if (unformat (i, "oui %d", &oui))
6422 else if (unformat (i, "ipv6"))
6424 else if (unformat (i, "del"))
6428 clib_warning ("parse error '%U'", format_unformat_error, i);
6433 if (tbl_id_set == 0)
6435 errmsg ("missing tbl id\n");
6439 if (fib_id_set == 0)
6441 errmsg ("missing fib id\n");
6446 errmsg ("missing oui\n");
6450 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6451 mp->tbl_id = ntohl (tbl_id);
6452 mp->fib_id = ntohl (fib_id);
6453 mp->oui = ntohl (oui);
6454 mp->is_ipv6 = is_ipv6;
6455 mp->is_add = is_add;
6464 api_dhcp_client_config (vat_main_t * vam)
6466 unformat_input_t *i = vam->input;
6467 vl_api_dhcp_client_config_t *mp;
6470 u8 sw_if_index_set = 0;
6473 u8 disable_event = 0;
6475 /* Parse args required to build the message */
6476 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6478 if (unformat (i, "del"))
6480 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6481 sw_if_index_set = 1;
6482 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6483 sw_if_index_set = 1;
6484 else if (unformat (i, "hostname %s", &hostname))
6486 else if (unformat (i, "disable_event"))
6492 if (sw_if_index_set == 0)
6494 errmsg ("missing interface name or sw_if_index\n");
6498 if (vec_len (hostname) > 63)
6500 errmsg ("hostname too long\n");
6502 vec_add1 (hostname, 0);
6504 /* Construct the API message */
6505 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6507 mp->sw_if_index = ntohl (sw_if_index);
6508 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6509 vec_free (hostname);
6510 mp->is_add = is_add;
6511 mp->want_dhcp_event = disable_event ? 0 : 1;
6512 mp->pid = getpid ();
6517 /* Wait for a reply, return good/bad news */
6524 api_set_ip_flow_hash (vat_main_t * vam)
6526 unformat_input_t *i = vam->input;
6527 vl_api_set_ip_flow_hash_t *mp;
6539 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6541 if (unformat (i, "vrf %d", &vrf_id))
6543 else if (unformat (i, "ipv6"))
6545 else if (unformat (i, "src"))
6547 else if (unformat (i, "dst"))
6549 else if (unformat (i, "sport"))
6551 else if (unformat (i, "dport"))
6553 else if (unformat (i, "proto"))
6555 else if (unformat (i, "reverse"))
6560 clib_warning ("parse error '%U'", format_unformat_error, i);
6565 if (vrf_id_set == 0)
6567 errmsg ("missing vrf id\n");
6571 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6577 mp->reverse = reverse;
6578 mp->vrf_id = ntohl (vrf_id);
6579 mp->is_ipv6 = is_ipv6;
6588 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6590 unformat_input_t *i = vam->input;
6591 vl_api_sw_interface_ip6_enable_disable_t *mp;
6594 u8 sw_if_index_set = 0;
6597 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6599 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6600 sw_if_index_set = 1;
6601 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6602 sw_if_index_set = 1;
6603 else if (unformat (i, "enable"))
6605 else if (unformat (i, "disable"))
6609 clib_warning ("parse error '%U'", format_unformat_error, i);
6614 if (sw_if_index_set == 0)
6616 errmsg ("missing interface name or sw_if_index\n");
6620 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6622 mp->sw_if_index = ntohl (sw_if_index);
6623 mp->enable = enable;
6632 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6634 unformat_input_t *i = vam->input;
6635 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6638 u8 sw_if_index_set = 0;
6639 u32 address_length = 0;
6640 u8 v6_address_set = 0;
6641 ip6_address_t v6address;
6643 /* Parse args required to build the message */
6644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6646 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6647 sw_if_index_set = 1;
6648 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6649 sw_if_index_set = 1;
6650 else if (unformat (i, "%U/%d",
6651 unformat_ip6_address, &v6address, &address_length))
6657 if (sw_if_index_set == 0)
6659 errmsg ("missing interface name or sw_if_index\n");
6662 if (!v6_address_set)
6664 errmsg ("no address set\n");
6668 /* Construct the API message */
6669 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6670 sw_interface_ip6_set_link_local_address);
6672 mp->sw_if_index = ntohl (sw_if_index);
6673 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6674 mp->address_length = address_length;
6679 /* Wait for a reply, return good/bad news */
6688 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6690 unformat_input_t *i = vam->input;
6691 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6694 u8 sw_if_index_set = 0;
6695 u32 address_length = 0;
6696 u8 v6_address_set = 0;
6697 ip6_address_t v6address;
6699 u8 no_advertise = 0;
6701 u8 no_autoconfig = 0;
6704 u32 val_lifetime = 0;
6705 u32 pref_lifetime = 0;
6707 /* Parse args required to build the message */
6708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6710 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6711 sw_if_index_set = 1;
6712 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6713 sw_if_index_set = 1;
6714 else if (unformat (i, "%U/%d",
6715 unformat_ip6_address, &v6address, &address_length))
6717 else if (unformat (i, "val_life %d", &val_lifetime))
6719 else if (unformat (i, "pref_life %d", &pref_lifetime))
6721 else if (unformat (i, "def"))
6723 else if (unformat (i, "noadv"))
6725 else if (unformat (i, "offl"))
6727 else if (unformat (i, "noauto"))
6729 else if (unformat (i, "nolink"))
6731 else if (unformat (i, "isno"))
6735 clib_warning ("parse error '%U'", format_unformat_error, i);
6740 if (sw_if_index_set == 0)
6742 errmsg ("missing interface name or sw_if_index\n");
6745 if (!v6_address_set)
6747 errmsg ("no address set\n");
6751 /* Construct the API message */
6752 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6754 mp->sw_if_index = ntohl (sw_if_index);
6755 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6756 mp->address_length = address_length;
6757 mp->use_default = use_default;
6758 mp->no_advertise = no_advertise;
6759 mp->off_link = off_link;
6760 mp->no_autoconfig = no_autoconfig;
6761 mp->no_onlink = no_onlink;
6763 mp->val_lifetime = ntohl (val_lifetime);
6764 mp->pref_lifetime = ntohl (pref_lifetime);
6769 /* Wait for a reply, return good/bad news */
6777 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6779 unformat_input_t *i = vam->input;
6780 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6783 u8 sw_if_index_set = 0;
6788 u8 send_unicast = 0;
6791 u8 default_router = 0;
6792 u32 max_interval = 0;
6793 u32 min_interval = 0;
6795 u32 initial_count = 0;
6796 u32 initial_interval = 0;
6799 /* Parse args required to build the message */
6800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6802 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6803 sw_if_index_set = 1;
6804 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6805 sw_if_index_set = 1;
6806 else if (unformat (i, "maxint %d", &max_interval))
6808 else if (unformat (i, "minint %d", &min_interval))
6810 else if (unformat (i, "life %d", &lifetime))
6812 else if (unformat (i, "count %d", &initial_count))
6814 else if (unformat (i, "interval %d", &initial_interval))
6816 else if (unformat (i, "suppress") || unformat (i, "surpress"))
6818 else if (unformat (i, "managed"))
6820 else if (unformat (i, "other"))
6822 else if (unformat (i, "ll"))
6824 else if (unformat (i, "send"))
6826 else if (unformat (i, "cease"))
6828 else if (unformat (i, "isno"))
6830 else if (unformat (i, "def"))
6834 clib_warning ("parse error '%U'", format_unformat_error, i);
6839 if (sw_if_index_set == 0)
6841 errmsg ("missing interface name or sw_if_index\n");
6845 /* Construct the API message */
6846 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
6848 mp->sw_if_index = ntohl (sw_if_index);
6849 mp->max_interval = ntohl (max_interval);
6850 mp->min_interval = ntohl (min_interval);
6851 mp->lifetime = ntohl (lifetime);
6852 mp->initial_count = ntohl (initial_count);
6853 mp->initial_interval = ntohl (initial_interval);
6854 mp->suppress = suppress;
6855 mp->managed = managed;
6857 mp->ll_option = ll_option;
6858 mp->send_unicast = send_unicast;
6861 mp->default_router = default_router;
6866 /* Wait for a reply, return good/bad news */
6874 api_set_arp_neighbor_limit (vat_main_t * vam)
6876 unformat_input_t *i = vam->input;
6877 vl_api_set_arp_neighbor_limit_t *mp;
6883 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6885 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
6887 else if (unformat (i, "ipv6"))
6891 clib_warning ("parse error '%U'", format_unformat_error, i);
6898 errmsg ("missing limit value\n");
6902 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
6904 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
6905 mp->is_ipv6 = is_ipv6;
6914 api_l2_patch_add_del (vat_main_t * vam)
6916 unformat_input_t *i = vam->input;
6917 vl_api_l2_patch_add_del_t *mp;
6920 u8 rx_sw_if_index_set = 0;
6922 u8 tx_sw_if_index_set = 0;
6925 /* Parse args required to build the message */
6926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6928 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6929 rx_sw_if_index_set = 1;
6930 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6931 tx_sw_if_index_set = 1;
6932 else if (unformat (i, "rx"))
6934 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6936 if (unformat (i, "%U", unformat_sw_if_index, vam,
6938 rx_sw_if_index_set = 1;
6943 else if (unformat (i, "tx"))
6945 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6947 if (unformat (i, "%U", unformat_sw_if_index, vam,
6949 tx_sw_if_index_set = 1;
6954 else if (unformat (i, "del"))
6960 if (rx_sw_if_index_set == 0)
6962 errmsg ("missing rx interface name or rx_sw_if_index\n");
6966 if (tx_sw_if_index_set == 0)
6968 errmsg ("missing tx interface name or tx_sw_if_index\n");
6972 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
6974 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6975 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6976 mp->is_add = is_add;
6985 api_trace_profile_add (vat_main_t * vam)
6987 unformat_input_t *input = vam->input;
6988 vl_api_trace_profile_add_t *mp;
6991 u32 trace_option_elts = 0;
6992 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
6993 int has_pow_option = 0;
6994 int has_ppc_option = 0;
6996 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6998 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
6999 "trace-tsp %d node-id 0x%x app-data 0x%x",
7000 &id, &trace_type, &trace_option_elts, &trace_tsp,
7001 &node_id, &app_data))
7003 else if (unformat (input, "pow"))
7005 else if (unformat (input, "ppc encap"))
7006 has_ppc_option = PPC_ENCAP;
7007 else if (unformat (input, "ppc decap"))
7008 has_ppc_option = PPC_DECAP;
7009 else if (unformat (input, "ppc none"))
7010 has_ppc_option = PPC_NONE;
7014 M (TRACE_PROFILE_ADD, trace_profile_add);
7015 mp->id = htons (id);
7016 mp->trace_type = trace_type;
7017 mp->trace_num_elt = trace_option_elts;
7018 mp->trace_ppc = has_ppc_option;
7019 mp->trace_app_data = htonl (app_data);
7020 mp->pow_enable = has_pow_option;
7021 mp->trace_tsp = trace_tsp;
7022 mp->node_id = htonl (node_id);
7032 api_trace_profile_apply (vat_main_t * vam)
7034 unformat_input_t *input = vam->input;
7035 vl_api_trace_profile_apply_t *mp;
7038 u32 mask_width = ~0;
7045 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7047 if (unformat (input, "%U/%d", unformat_ip6_address, &addr, &mask_width))
7049 else if (unformat (input, "id %d", &id))
7051 else if (unformat (input, "vrf-id %d", &vrf_id))
7053 else if (unformat (input, "add"))
7055 else if (unformat (input, "pop"))
7057 else if (unformat (input, "none"))
7063 if ((is_add + is_pop + is_none) != 1)
7065 errmsg ("One of (add, pop, none) required");
7068 if (mask_width == ~0)
7070 errmsg ("<address>/<mask-width> required");
7073 M (TRACE_PROFILE_APPLY, trace_profile_apply);
7074 clib_memcpy (mp->dest_ipv6, &addr, sizeof (mp->dest_ipv6));
7075 mp->id = htons (id);
7076 mp->prefix_length = htonl (mask_width);
7077 mp->vrf_id = htonl (vrf_id);
7079 mp->trace_op = IOAM_HBYH_ADD;
7081 mp->trace_op = IOAM_HBYH_POP;
7083 mp->trace_op = IOAM_HBYH_MOD;
7097 api_trace_profile_del (vat_main_t * vam)
7099 vl_api_trace_profile_del_t *mp;
7102 M (TRACE_PROFILE_DEL, trace_profile_del);
7109 api_sr_tunnel_add_del (vat_main_t * vam)
7111 unformat_input_t *i = vam->input;
7112 vl_api_sr_tunnel_add_del_t *mp;
7116 ip6_address_t src_address;
7117 int src_address_set = 0;
7118 ip6_address_t dst_address;
7120 int dst_address_set = 0;
7122 u32 rx_table_id = 0;
7123 u32 tx_table_id = 0;
7124 ip6_address_t *segments = 0;
7125 ip6_address_t *this_seg;
7126 ip6_address_t *tags = 0;
7127 ip6_address_t *this_tag;
7128 ip6_address_t next_address, tag;
7130 u8 *policy_name = 0;
7132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7134 if (unformat (i, "del"))
7136 else if (unformat (i, "name %s", &name))
7138 else if (unformat (i, "policy %s", &policy_name))
7140 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7142 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7144 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7145 src_address_set = 1;
7146 else if (unformat (i, "dst %U/%d",
7147 unformat_ip6_address, &dst_address, &dst_mask_width))
7148 dst_address_set = 1;
7149 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7151 vec_add2 (segments, this_seg, 1);
7152 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7153 sizeof (*this_seg));
7155 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7157 vec_add2 (tags, this_tag, 1);
7158 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7160 else if (unformat (i, "clean"))
7161 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7162 else if (unformat (i, "protected"))
7163 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7164 else if (unformat (i, "InPE %d", &pl_index))
7166 if (pl_index <= 0 || pl_index > 4)
7168 pl_index_range_error:
7169 errmsg ("pl index %d out of range\n", pl_index);
7173 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7175 else if (unformat (i, "EgPE %d", &pl_index))
7177 if (pl_index <= 0 || pl_index > 4)
7178 goto pl_index_range_error;
7180 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7182 else if (unformat (i, "OrgSrc %d", &pl_index))
7184 if (pl_index <= 0 || pl_index > 4)
7185 goto pl_index_range_error;
7187 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7193 if (!src_address_set)
7195 errmsg ("src address required\n");
7199 if (!dst_address_set)
7201 errmsg ("dst address required\n");
7207 errmsg ("at least one sr segment required\n");
7211 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7212 vec_len (segments) * sizeof (ip6_address_t)
7213 + vec_len (tags) * sizeof (ip6_address_t));
7215 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7216 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7217 mp->dst_mask_width = dst_mask_width;
7218 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7219 mp->n_segments = vec_len (segments);
7220 mp->n_tags = vec_len (tags);
7221 mp->is_add = is_del == 0;
7222 clib_memcpy (mp->segs_and_tags, segments,
7223 vec_len (segments) * sizeof (ip6_address_t));
7224 clib_memcpy (mp->segs_and_tags +
7225 vec_len (segments) * sizeof (ip6_address_t), tags,
7226 vec_len (tags) * sizeof (ip6_address_t));
7228 mp->outer_vrf_id = ntohl (rx_table_id);
7229 mp->inner_vrf_id = ntohl (tx_table_id);
7230 memcpy (mp->name, name, vec_len (name));
7231 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7233 vec_free (segments);
7242 api_sr_policy_add_del (vat_main_t * vam)
7244 unformat_input_t *input = vam->input;
7245 vl_api_sr_policy_add_del_t *mp;
7249 u8 *tunnel_name = 0;
7250 u8 **tunnel_names = 0;
7255 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7256 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7258 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7260 if (unformat (input, "del"))
7262 else if (unformat (input, "name %s", &name))
7264 else if (unformat (input, "tunnel %s", &tunnel_name))
7268 vec_add1 (tunnel_names, tunnel_name);
7270 - length = #bytes to store in serial vector
7271 - +1 = byte to store that length
7273 tunnel_names_length += (vec_len (tunnel_name) + 1);
7284 errmsg ("policy name required\n");
7288 if ((!tunnel_set) && (!is_del))
7290 errmsg ("tunnel name required\n");
7294 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7298 mp->is_add = !is_del;
7300 memcpy (mp->name, name, vec_len (name));
7301 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7302 u8 *serial_orig = 0;
7303 vec_validate (serial_orig, tunnel_names_length);
7304 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7305 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7307 for (j = 0; j < vec_len (tunnel_names); j++)
7309 tun_name_len = vec_len (tunnel_names[j]);
7310 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7311 serial_orig += 1; // Move along one byte to store the actual tunnel name
7312 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7313 serial_orig += tun_name_len; // Advance past the copy
7315 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7317 vec_free (tunnel_names);
7318 vec_free (tunnel_name);
7326 api_sr_multicast_map_add_del (vat_main_t * vam)
7328 unformat_input_t *input = vam->input;
7329 vl_api_sr_multicast_map_add_del_t *mp;
7332 ip6_address_t multicast_address;
7333 u8 *policy_name = 0;
7334 int multicast_address_set = 0;
7336 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7338 if (unformat (input, "del"))
7342 (input, "address %U", unformat_ip6_address, &multicast_address))
7343 multicast_address_set = 1;
7344 else if (unformat (input, "sr-policy %s", &policy_name))
7350 if (!is_del && !policy_name)
7352 errmsg ("sr-policy name required\n");
7357 if (!multicast_address_set)
7359 errmsg ("address required\n");
7363 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7365 mp->is_add = !is_del;
7366 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7367 clib_memcpy (mp->multicast_address, &multicast_address,
7368 sizeof (mp->multicast_address));
7371 vec_free (policy_name);
7379 #define foreach_ip4_proto_field \
7390 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7392 u8 **maskp = va_arg (*args, u8 **);
7394 u8 found_something = 0;
7397 #define _(a) u8 a=0;
7398 foreach_ip4_proto_field;
7404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7406 if (unformat (input, "version"))
7408 else if (unformat (input, "hdr_length"))
7410 else if (unformat (input, "src"))
7412 else if (unformat (input, "dst"))
7414 else if (unformat (input, "proto"))
7417 #define _(a) else if (unformat (input, #a)) a=1;
7418 foreach_ip4_proto_field
7424 #define _(a) found_something += a;
7425 foreach_ip4_proto_field;
7428 if (found_something == 0)
7431 vec_validate (mask, sizeof (*ip) - 1);
7433 ip = (ip4_header_t *) mask;
7435 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7436 foreach_ip4_proto_field;
7439 ip->ip_version_and_header_length = 0;
7442 ip->ip_version_and_header_length |= 0xF0;
7445 ip->ip_version_and_header_length |= 0x0F;
7451 #define foreach_ip6_proto_field \
7459 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7461 u8 **maskp = va_arg (*args, u8 **);
7463 u8 found_something = 0;
7465 u32 ip_version_traffic_class_and_flow_label;
7467 #define _(a) u8 a=0;
7468 foreach_ip6_proto_field;
7471 u8 traffic_class = 0;
7474 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7476 if (unformat (input, "version"))
7478 else if (unformat (input, "traffic-class"))
7480 else if (unformat (input, "flow-label"))
7482 else if (unformat (input, "src"))
7484 else if (unformat (input, "dst"))
7486 else if (unformat (input, "proto"))
7489 #define _(a) else if (unformat (input, #a)) a=1;
7490 foreach_ip6_proto_field
7496 #define _(a) found_something += a;
7497 foreach_ip6_proto_field;
7500 if (found_something == 0)
7503 vec_validate (mask, sizeof (*ip) - 1);
7505 ip = (ip6_header_t *) mask;
7507 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7508 foreach_ip6_proto_field;
7511 ip_version_traffic_class_and_flow_label = 0;
7514 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7517 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7520 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7522 ip->ip_version_traffic_class_and_flow_label =
7523 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7530 unformat_l3_mask (unformat_input_t * input, va_list * args)
7532 u8 **maskp = va_arg (*args, u8 **);
7534 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7536 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7538 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7547 unformat_l2_mask (unformat_input_t * input, va_list * args)
7549 u8 **maskp = va_arg (*args, u8 **);
7564 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7566 if (unformat (input, "src"))
7568 else if (unformat (input, "dst"))
7570 else if (unformat (input, "proto"))
7572 else if (unformat (input, "tag1"))
7574 else if (unformat (input, "tag2"))
7576 else if (unformat (input, "ignore-tag1"))
7578 else if (unformat (input, "ignore-tag2"))
7580 else if (unformat (input, "cos1"))
7582 else if (unformat (input, "cos2"))
7584 else if (unformat (input, "dot1q"))
7586 else if (unformat (input, "dot1ad"))
7591 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7592 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7595 if (tag1 || ignore_tag1 || cos1 || dot1q)
7597 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7600 vec_validate (mask, len - 1);
7603 memset (mask, 0xff, 6);
7606 memset (mask + 6, 0xff, 6);
7610 /* inner vlan tag */
7619 mask[21] = mask[20] = 0xff;
7640 mask[16] = mask[17] = 0xff;
7650 mask[12] = mask[13] = 0xff;
7657 unformat_classify_mask (unformat_input_t * input, va_list * args)
7659 u8 **maskp = va_arg (*args, u8 **);
7660 u32 *skipp = va_arg (*args, u32 *);
7661 u32 *matchp = va_arg (*args, u32 *);
7668 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7670 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7672 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7674 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7680 if (mask || l2 || l3)
7684 /* "With a free Ethernet header in every package" */
7686 vec_validate (l2, 13);
7690 vec_append (mask, l3);
7695 /* Scan forward looking for the first significant mask octet */
7696 for (i = 0; i < vec_len (mask); i++)
7700 /* compute (skip, match) params */
7701 *skipp = i / sizeof (u32x4);
7702 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7704 /* Pad mask to an even multiple of the vector size */
7705 while (vec_len (mask) % sizeof (u32x4))
7708 match = vec_len (mask) / sizeof (u32x4);
7710 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7712 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7713 if (*tmp || *(tmp + 1))
7718 clib_warning ("BUG: match 0");
7720 _vec_len (mask) = match * sizeof (u32x4);
7731 #define foreach_l2_next \
7733 _(ethernet, ETHERNET_INPUT) \
7738 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7740 u32 *miss_next_indexp = va_arg (*args, u32 *);
7745 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
7749 if (unformat (input, "%d", &tmp))
7758 *miss_next_indexp = next_index;
7762 #define foreach_ip_next \
7769 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7771 u32 *miss_next_indexp = va_arg (*args, u32 *);
7776 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7780 if (unformat (input, "%d", &tmp))
7789 *miss_next_indexp = next_index;
7793 #define foreach_acl_next \
7797 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7799 u32 *miss_next_indexp = va_arg (*args, u32 *);
7804 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7808 if (unformat (input, "permit"))
7813 else if (unformat (input, "%d", &tmp))
7822 *miss_next_indexp = next_index;
7827 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7829 u32 *r = va_arg (*args, u32 *);
7831 if (unformat (input, "conform-color"))
7832 *r = POLICE_CONFORM;
7833 else if (unformat (input, "exceed-color"))
7842 api_classify_add_del_table (vat_main_t * vam)
7844 unformat_input_t *i = vam->input;
7845 vl_api_classify_add_del_table_t *mp;
7851 u32 table_index = ~0;
7852 u32 next_table_index = ~0;
7853 u32 miss_next_index = ~0;
7854 u32 memory_size = 32 << 20;
7858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7860 if (unformat (i, "del"))
7862 else if (unformat (i, "buckets %d", &nbuckets))
7864 else if (unformat (i, "memory_size %d", &memory_size))
7866 else if (unformat (i, "skip %d", &skip))
7868 else if (unformat (i, "match %d", &match))
7870 else if (unformat (i, "table %d", &table_index))
7872 else if (unformat (i, "mask %U", unformat_classify_mask,
7873 &mask, &skip, &match))
7875 else if (unformat (i, "next-table %d", &next_table_index))
7877 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
7880 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
7883 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
7890 if (is_add && mask == 0)
7892 errmsg ("Mask required\n");
7896 if (is_add && skip == ~0)
7898 errmsg ("skip count required\n");
7902 if (is_add && match == ~0)
7904 errmsg ("match count required\n");
7908 if (!is_add && table_index == ~0)
7910 errmsg ("table index required for delete\n");
7914 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
7916 mp->is_add = is_add;
7917 mp->table_index = ntohl (table_index);
7918 mp->nbuckets = ntohl (nbuckets);
7919 mp->memory_size = ntohl (memory_size);
7920 mp->skip_n_vectors = ntohl (skip);
7921 mp->match_n_vectors = ntohl (match);
7922 mp->next_table_index = ntohl (next_table_index);
7923 mp->miss_next_index = ntohl (miss_next_index);
7924 clib_memcpy (mp->mask, mask, vec_len (mask));
7934 unformat_ip4_match (unformat_input_t * input, va_list * args)
7936 u8 **matchp = va_arg (*args, u8 **);
7943 int src = 0, dst = 0;
7944 ip4_address_t src_val, dst_val;
7951 int fragment_id = 0;
7952 u32 fragment_id_val;
7958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7960 if (unformat (input, "version %d", &version_val))
7962 else if (unformat (input, "hdr_length %d", &hdr_length_val))
7964 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
7966 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
7968 else if (unformat (input, "proto %d", &proto_val))
7970 else if (unformat (input, "tos %d", &tos_val))
7972 else if (unformat (input, "length %d", &length_val))
7974 else if (unformat (input, "fragment_id %d", &fragment_id_val))
7976 else if (unformat (input, "ttl %d", &ttl_val))
7978 else if (unformat (input, "checksum %d", &checksum_val))
7984 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
7985 + ttl + checksum == 0)
7989 * Aligned because we use the real comparison functions
7991 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
7993 ip = (ip4_header_t *) match;
7995 /* These are realistically matched in practice */
7997 ip->src_address.as_u32 = src_val.as_u32;
8000 ip->dst_address.as_u32 = dst_val.as_u32;
8003 ip->protocol = proto_val;
8006 /* These are not, but they're included for completeness */
8008 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8011 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8017 ip->length = length_val;
8023 ip->checksum = checksum_val;
8030 unformat_ip6_match (unformat_input_t * input, va_list * args)
8032 u8 **matchp = va_arg (*args, u8 **);
8037 u8 traffic_class = 0;
8038 u32 traffic_class_val = 0;
8041 int src = 0, dst = 0;
8042 ip6_address_t src_val, dst_val;
8045 int payload_length = 0;
8046 u32 payload_length_val;
8049 u32 ip_version_traffic_class_and_flow_label;
8051 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8053 if (unformat (input, "version %d", &version_val))
8055 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8057 else if (unformat (input, "flow_label %d", &flow_label_val))
8059 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8061 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8063 else if (unformat (input, "proto %d", &proto_val))
8065 else if (unformat (input, "payload_length %d", &payload_length_val))
8067 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8073 if (version + traffic_class + flow_label + src + dst + proto +
8074 payload_length + hop_limit == 0)
8078 * Aligned because we use the real comparison functions
8080 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8082 ip = (ip6_header_t *) match;
8085 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8088 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8091 ip->protocol = proto_val;
8093 ip_version_traffic_class_and_flow_label = 0;
8096 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8099 ip_version_traffic_class_and_flow_label |=
8100 (traffic_class_val & 0xFF) << 20;
8103 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8105 ip->ip_version_traffic_class_and_flow_label =
8106 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8109 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8112 ip->hop_limit = hop_limit_val;
8119 unformat_l3_match (unformat_input_t * input, va_list * args)
8121 u8 **matchp = va_arg (*args, u8 **);
8123 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8125 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8127 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8136 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8138 u8 *tagp = va_arg (*args, u8 *);
8141 if (unformat (input, "%d", &tag))
8143 tagp[0] = (tag >> 8) & 0x0F;
8144 tagp[1] = tag & 0xFF;
8152 unformat_l2_match (unformat_input_t * input, va_list * args)
8154 u8 **matchp = va_arg (*args, u8 **);
8174 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8176 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8179 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8181 else if (unformat (input, "proto %U",
8182 unformat_ethernet_type_host_byte_order, &proto_val))
8184 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8186 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8188 else if (unformat (input, "ignore-tag1"))
8190 else if (unformat (input, "ignore-tag2"))
8192 else if (unformat (input, "cos1 %d", &cos1_val))
8194 else if (unformat (input, "cos2 %d", &cos2_val))
8199 if ((src + dst + proto + tag1 + tag2 +
8200 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8203 if (tag1 || ignore_tag1 || cos1)
8205 if (tag2 || ignore_tag2 || cos2)
8208 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8211 clib_memcpy (match, dst_val, 6);
8214 clib_memcpy (match + 6, src_val, 6);
8218 /* inner vlan tag */
8219 match[19] = tag2_val[1];
8220 match[18] = tag2_val[0];
8222 match[18] |= (cos2_val & 0x7) << 5;
8225 match[21] = proto_val & 0xff;
8226 match[20] = proto_val >> 8;
8230 match[15] = tag1_val[1];
8231 match[14] = tag1_val[0];
8234 match[14] |= (cos1_val & 0x7) << 5;
8240 match[15] = tag1_val[1];
8241 match[14] = tag1_val[0];
8244 match[17] = proto_val & 0xff;
8245 match[16] = proto_val >> 8;
8248 match[14] |= (cos1_val & 0x7) << 5;
8254 match[18] |= (cos2_val & 0x7) << 5;
8256 match[14] |= (cos1_val & 0x7) << 5;
8259 match[13] = proto_val & 0xff;
8260 match[12] = proto_val >> 8;
8269 unformat_classify_match (unformat_input_t * input, va_list * args)
8271 u8 **matchp = va_arg (*args, u8 **);
8272 u32 skip_n_vectors = va_arg (*args, u32);
8273 u32 match_n_vectors = va_arg (*args, u32);
8279 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8281 if (unformat (input, "hex %U", unformat_hex_string, &match))
8283 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8285 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8291 if (match || l2 || l3)
8295 /* "Win a free Ethernet header in every packet" */
8297 vec_validate_aligned (l2, 13, sizeof (u32x4));
8301 vec_append_aligned (match, l3, sizeof (u32x4));
8306 /* Make sure the vector is big enough even if key is all 0's */
8307 vec_validate_aligned
8308 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8311 /* Set size, include skipped vectors */
8312 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8323 api_classify_add_del_session (vat_main_t * vam)
8325 unformat_input_t *i = vam->input;
8326 vl_api_classify_add_del_session_t *mp;
8328 u32 table_index = ~0;
8329 u32 hit_next_index = ~0;
8330 u32 opaque_index = ~0;
8334 u32 skip_n_vectors = 0;
8335 u32 match_n_vectors = 0;
8338 * Warning: you have to supply skip_n and match_n
8339 * because the API client cant simply look at the classify
8343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8345 if (unformat (i, "del"))
8347 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8350 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8353 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8356 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8358 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8360 else if (unformat (i, "opaque-index %d", &opaque_index))
8362 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8364 else if (unformat (i, "match_n %d", &match_n_vectors))
8366 else if (unformat (i, "match %U", unformat_classify_match,
8367 &match, skip_n_vectors, match_n_vectors))
8369 else if (unformat (i, "advance %d", &advance))
8371 else if (unformat (i, "table-index %d", &table_index))
8377 if (table_index == ~0)
8379 errmsg ("Table index required\n");
8383 if (is_add && match == 0)
8385 errmsg ("Match value required\n");
8389 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8391 mp->is_add = is_add;
8392 mp->table_index = ntohl (table_index);
8393 mp->hit_next_index = ntohl (hit_next_index);
8394 mp->opaque_index = ntohl (opaque_index);
8395 mp->advance = ntohl (advance);
8396 clib_memcpy (mp->match, match, vec_len (match));
8405 api_classify_set_interface_ip_table (vat_main_t * vam)
8407 unformat_input_t *i = vam->input;
8408 vl_api_classify_set_interface_ip_table_t *mp;
8411 int sw_if_index_set;
8412 u32 table_index = ~0;
8415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8417 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8418 sw_if_index_set = 1;
8419 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8420 sw_if_index_set = 1;
8421 else if (unformat (i, "table %d", &table_index))
8425 clib_warning ("parse error '%U'", format_unformat_error, i);
8430 if (sw_if_index_set == 0)
8432 errmsg ("missing interface name or sw_if_index\n");
8437 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8439 mp->sw_if_index = ntohl (sw_if_index);
8440 mp->table_index = ntohl (table_index);
8441 mp->is_ipv6 = is_ipv6;
8450 api_classify_set_interface_l2_tables (vat_main_t * vam)
8452 unformat_input_t *i = vam->input;
8453 vl_api_classify_set_interface_l2_tables_t *mp;
8456 int sw_if_index_set;
8457 u32 ip4_table_index = ~0;
8458 u32 ip6_table_index = ~0;
8459 u32 other_table_index = ~0;
8461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8463 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8464 sw_if_index_set = 1;
8465 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8466 sw_if_index_set = 1;
8467 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8469 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8471 else if (unformat (i, "other-table %d", &other_table_index))
8475 clib_warning ("parse error '%U'", format_unformat_error, i);
8480 if (sw_if_index_set == 0)
8482 errmsg ("missing interface name or sw_if_index\n");
8487 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8489 mp->sw_if_index = ntohl (sw_if_index);
8490 mp->ip4_table_index = ntohl (ip4_table_index);
8491 mp->ip6_table_index = ntohl (ip6_table_index);
8492 mp->other_table_index = ntohl (other_table_index);
8502 api_ipfix_enable (vat_main_t * vam)
8504 unformat_input_t *i = vam->input;
8505 vl_api_ipfix_enable_t *mp;
8506 ip4_address_t collector_address;
8507 u8 collector_address_set = 0;
8508 u32 collector_port = ~0;
8509 ip4_address_t src_address;
8510 u8 src_address_set = 0;
8513 u32 template_interval = ~0;
8516 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8518 if (unformat (i, "collector_address %U", unformat_ip4_address,
8519 &collector_address))
8520 collector_address_set = 1;
8521 else if (unformat (i, "collector_port %d", &collector_port))
8523 else if (unformat (i, "src_address %U", unformat_ip4_address,
8525 src_address_set = 1;
8526 else if (unformat (i, "vrf_id %d", &vrf_id))
8528 else if (unformat (i, "path_mtu %d", &path_mtu))
8530 else if (unformat (i, "template_interval %d", &template_interval))
8536 if (collector_address_set == 0)
8538 errmsg ("collector_address required\n");
8542 if (src_address_set == 0)
8544 errmsg ("src_address required\n");
8548 M (IPFIX_ENABLE, ipfix_enable);
8550 memcpy (mp->collector_address, collector_address.data,
8551 sizeof (collector_address.data));
8552 mp->collector_port = htons ((u16) collector_port);
8553 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8554 mp->vrf_id = htonl (vrf_id);
8555 mp->path_mtu = htonl (path_mtu);
8556 mp->template_interval = htonl (template_interval);
8564 api_get_node_index (vat_main_t * vam)
8566 unformat_input_t *i = vam->input;
8567 vl_api_get_node_index_t *mp;
8571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8573 if (unformat (i, "node %s", &name))
8580 errmsg ("node name required\n");
8583 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8585 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8589 M (GET_NODE_INDEX, get_node_index);
8590 clib_memcpy (mp->node_name, name, vec_len (name));
8600 api_get_next_index (vat_main_t * vam)
8602 unformat_input_t *i = vam->input;
8603 vl_api_get_next_index_t *mp;
8605 u8 *node_name = 0, *next_node_name = 0;
8607 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8609 if (unformat (i, "node-name %s", &node_name))
8611 else if (unformat (i, "next-node-name %s", &next_node_name))
8617 errmsg ("node name required\n");
8620 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8622 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8626 if (next_node_name == 0)
8628 errmsg ("next node name required\n");
8631 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8633 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8637 M (GET_NEXT_INDEX, get_next_index);
8638 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8639 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8640 vec_free (node_name);
8641 vec_free (next_node_name);
8650 api_add_node_next (vat_main_t * vam)
8652 unformat_input_t *i = vam->input;
8653 vl_api_add_node_next_t *mp;
8658 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8660 if (unformat (i, "node %s", &name))
8662 else if (unformat (i, "next %s", &next))
8669 errmsg ("node name required\n");
8672 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8674 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8679 errmsg ("next node required\n");
8682 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8684 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8688 M (ADD_NODE_NEXT, add_node_next);
8689 clib_memcpy (mp->node_name, name, vec_len (name));
8690 clib_memcpy (mp->next_name, next, vec_len (next));
8701 api_l2tpv3_create_tunnel (vat_main_t * vam)
8703 unformat_input_t *i = vam->input;
8704 ip6_address_t client_address, our_address;
8705 int client_address_set = 0;
8706 int our_address_set = 0;
8707 u32 local_session_id = 0;
8708 u32 remote_session_id = 0;
8709 u64 local_cookie = 0;
8710 u64 remote_cookie = 0;
8711 u8 l2_sublayer_present = 0;
8712 vl_api_l2tpv3_create_tunnel_t *mp;
8715 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8717 if (unformat (i, "client_address %U", unformat_ip6_address,
8719 client_address_set = 1;
8720 else if (unformat (i, "our_address %U", unformat_ip6_address,
8722 our_address_set = 1;
8723 else if (unformat (i, "local_session_id %d", &local_session_id))
8725 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8727 else if (unformat (i, "local_cookie %lld", &local_cookie))
8729 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8731 else if (unformat (i, "l2-sublayer-present"))
8732 l2_sublayer_present = 1;
8737 if (client_address_set == 0)
8739 errmsg ("client_address required\n");
8743 if (our_address_set == 0)
8745 errmsg ("our_address required\n");
8749 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8751 clib_memcpy (mp->client_address, client_address.as_u8,
8752 sizeof (mp->client_address));
8754 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8756 mp->local_session_id = ntohl (local_session_id);
8757 mp->remote_session_id = ntohl (remote_session_id);
8758 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8759 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8760 mp->l2_sublayer_present = l2_sublayer_present;
8770 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8772 unformat_input_t *i = vam->input;
8774 u8 sw_if_index_set = 0;
8775 u64 new_local_cookie = 0;
8776 u64 new_remote_cookie = 0;
8777 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
8780 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8782 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8783 sw_if_index_set = 1;
8784 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8785 sw_if_index_set = 1;
8786 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
8788 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
8794 if (sw_if_index_set == 0)
8796 errmsg ("missing interface name or sw_if_index\n");
8800 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
8802 mp->sw_if_index = ntohl (sw_if_index);
8803 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
8804 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
8813 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
8815 unformat_input_t *i = vam->input;
8816 vl_api_l2tpv3_interface_enable_disable_t *mp;
8819 u8 sw_if_index_set = 0;
8820 u8 enable_disable = 1;
8822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8824 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8825 sw_if_index_set = 1;
8826 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8827 sw_if_index_set = 1;
8828 else if (unformat (i, "enable"))
8830 else if (unformat (i, "disable"))
8836 if (sw_if_index_set == 0)
8838 errmsg ("missing interface name or sw_if_index\n");
8842 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
8844 mp->sw_if_index = ntohl (sw_if_index);
8845 mp->enable_disable = enable_disable;
8854 api_l2tpv3_set_lookup_key (vat_main_t * vam)
8856 unformat_input_t *i = vam->input;
8857 vl_api_l2tpv3_set_lookup_key_t *mp;
8861 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8863 if (unformat (i, "lookup_v6_src"))
8864 key = L2T_LOOKUP_SRC_ADDRESS;
8865 else if (unformat (i, "lookup_v6_dst"))
8866 key = L2T_LOOKUP_DST_ADDRESS;
8867 else if (unformat (i, "lookup_session_id"))
8868 key = L2T_LOOKUP_SESSION_ID;
8873 if (key == (u8) ~ 0)
8875 errmsg ("l2tp session lookup key unset\n");
8879 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
8889 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
8890 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8892 vat_main_t *vam = &vat_main;
8894 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
8895 format_ip6_address, mp->our_address,
8896 format_ip6_address, mp->client_address,
8897 clib_net_to_host_u32 (mp->sw_if_index));
8900 " local cookies %016llx %016llx remote cookie %016llx\n",
8901 clib_net_to_host_u64 (mp->local_cookie[0]),
8902 clib_net_to_host_u64 (mp->local_cookie[1]),
8903 clib_net_to_host_u64 (mp->remote_cookie));
8905 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
8906 clib_net_to_host_u32 (mp->local_session_id),
8907 clib_net_to_host_u32 (mp->remote_session_id));
8909 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
8910 mp->l2_sublayer_present ? "preset" : "absent");
8914 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
8915 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8917 vat_main_t *vam = &vat_main;
8918 vat_json_node_t *node = NULL;
8919 struct in6_addr addr;
8921 if (VAT_JSON_ARRAY != vam->json_tree.type)
8923 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8924 vat_json_init_array (&vam->json_tree);
8926 node = vat_json_array_add (&vam->json_tree);
8928 vat_json_init_object (node);
8930 clib_memcpy (&addr, mp->our_address, sizeof (addr));
8931 vat_json_object_add_ip6 (node, "our_address", addr);
8932 clib_memcpy (&addr, mp->client_address, sizeof (addr));
8933 vat_json_object_add_ip6 (node, "client_address", addr);
8935 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
8936 vat_json_init_array (lc);
8937 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
8938 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
8939 vat_json_object_add_uint (node, "remote_cookie",
8940 clib_net_to_host_u64 (mp->remote_cookie));
8942 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
8943 vat_json_object_add_uint (node, "local_session_id",
8944 clib_net_to_host_u32 (mp->local_session_id));
8945 vat_json_object_add_uint (node, "remote_session_id",
8946 clib_net_to_host_u32 (mp->remote_session_id));
8947 vat_json_object_add_string_copy (node, "l2_sublayer",
8948 mp->l2_sublayer_present ? (u8 *) "present"
8953 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
8955 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
8958 /* Get list of l2tpv3-tunnel interfaces */
8959 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
8962 /* Use a control ping for synchronization */
8964 vl_api_control_ping_t *mp;
8965 M (CONTROL_PING, control_ping);
8972 static void vl_api_sw_interface_tap_details_t_handler
8973 (vl_api_sw_interface_tap_details_t * mp)
8975 vat_main_t *vam = &vat_main;
8977 fformat (vam->ofp, "%-16s %d\n",
8978 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
8981 static void vl_api_sw_interface_tap_details_t_handler_json
8982 (vl_api_sw_interface_tap_details_t * mp)
8984 vat_main_t *vam = &vat_main;
8985 vat_json_node_t *node = NULL;
8987 if (VAT_JSON_ARRAY != vam->json_tree.type)
8989 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8990 vat_json_init_array (&vam->json_tree);
8992 node = vat_json_array_add (&vam->json_tree);
8994 vat_json_init_object (node);
8995 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8996 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9000 api_sw_interface_tap_dump (vat_main_t * vam)
9002 vl_api_sw_interface_tap_dump_t *mp;
9005 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9006 /* Get list of tap interfaces */
9007 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9010 /* Use a control ping for synchronization */
9012 vl_api_control_ping_t *mp;
9013 M (CONTROL_PING, control_ping);
9019 static uword unformat_vxlan_decap_next
9020 (unformat_input_t * input, va_list * args)
9022 u32 *result = va_arg (*args, u32 *);
9025 if (unformat (input, "drop"))
9026 *result = VXLAN_INPUT_NEXT_DROP;
9027 else if (unformat (input, "ip4"))
9028 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9029 else if (unformat (input, "ip6"))
9030 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9031 else if (unformat (input, "l2"))
9032 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9033 else if (unformat (input, "%d", &tmp))
9041 api_vxlan_add_del_tunnel (vat_main_t * vam)
9043 unformat_input_t *line_input = vam->input;
9044 vl_api_vxlan_add_del_tunnel_t *mp;
9046 ip4_address_t src4, dst4;
9047 ip6_address_t src6, dst6;
9049 u8 ipv4_set = 0, ipv6_set = 0;
9052 u32 encap_vrf_id = 0;
9053 u32 decap_next_index = ~0;
9056 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9058 if (unformat (line_input, "del"))
9060 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9065 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9070 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9075 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9080 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9082 else if (unformat (line_input, "decap-next %U",
9083 unformat_vxlan_decap_next, &decap_next_index))
9085 else if (unformat (line_input, "vni %d", &vni))
9089 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9096 errmsg ("tunnel src address not specified\n");
9101 errmsg ("tunnel dst address not specified\n");
9105 if (ipv4_set && ipv6_set)
9107 errmsg ("both IPv4 and IPv6 addresses specified");
9111 if ((vni == 0) || (vni >> 24))
9113 errmsg ("vni not specified or out of range\n");
9117 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9121 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9122 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9126 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9127 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9129 mp->encap_vrf_id = ntohl (encap_vrf_id);
9130 mp->decap_next_index = ntohl (decap_next_index);
9131 mp->vni = ntohl (vni);
9132 mp->is_add = is_add;
9133 mp->is_ipv6 = ipv6_set;
9141 static void vl_api_vxlan_tunnel_details_t_handler
9142 (vl_api_vxlan_tunnel_details_t * mp)
9144 vat_main_t *vam = &vat_main;
9146 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9147 ntohl (mp->sw_if_index),
9148 format_ip46_address, &(mp->src_address[0]),
9150 format_ip46_address, &(mp->dst_address[0]),
9152 ntohl (mp->encap_vrf_id),
9153 ntohl (mp->decap_next_index), ntohl (mp->vni));
9156 static void vl_api_vxlan_tunnel_details_t_handler_json
9157 (vl_api_vxlan_tunnel_details_t * mp)
9159 vat_main_t *vam = &vat_main;
9160 vat_json_node_t *node = NULL;
9162 struct in6_addr ip6;
9164 if (VAT_JSON_ARRAY != vam->json_tree.type)
9166 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9167 vat_json_init_array (&vam->json_tree);
9169 node = vat_json_array_add (&vam->json_tree);
9171 vat_json_init_object (node);
9172 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9175 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9176 vat_json_object_add_ip6 (node, "src_address", ip6);
9177 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9178 vat_json_object_add_ip6 (node, "dst_address", ip6);
9182 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9183 vat_json_object_add_ip4 (node, "src_address", ip4);
9184 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9185 vat_json_object_add_ip4 (node, "dst_address", ip4);
9187 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9188 vat_json_object_add_uint (node, "decap_next_index",
9189 ntohl (mp->decap_next_index));
9190 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9191 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9195 api_vxlan_tunnel_dump (vat_main_t * vam)
9197 unformat_input_t *i = vam->input;
9198 vl_api_vxlan_tunnel_dump_t *mp;
9201 u8 sw_if_index_set = 0;
9203 /* Parse args required to build the message */
9204 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9206 if (unformat (i, "sw_if_index %d", &sw_if_index))
9207 sw_if_index_set = 1;
9212 if (sw_if_index_set == 0)
9217 if (!vam->json_output)
9219 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9220 "sw_if_index", "src_address", "dst_address",
9221 "encap_vrf_id", "decap_next_index", "vni");
9224 /* Get list of vxlan-tunnel interfaces */
9225 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9227 mp->sw_if_index = htonl (sw_if_index);
9231 /* Use a control ping for synchronization */
9233 vl_api_control_ping_t *mp;
9234 M (CONTROL_PING, control_ping);
9241 api_gre_add_del_tunnel (vat_main_t * vam)
9243 unformat_input_t *line_input = vam->input;
9244 vl_api_gre_add_del_tunnel_t *mp;
9246 ip4_address_t src4, dst4;
9250 u32 outer_fib_id = 0;
9252 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9254 if (unformat (line_input, "del"))
9256 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9258 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9260 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9264 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9271 errmsg ("tunnel src address not specified\n");
9276 errmsg ("tunnel dst address not specified\n");
9281 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9283 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9284 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9285 mp->outer_fib_id = ntohl (outer_fib_id);
9286 mp->is_add = is_add;
9294 static void vl_api_gre_tunnel_details_t_handler
9295 (vl_api_gre_tunnel_details_t * mp)
9297 vat_main_t *vam = &vat_main;
9299 fformat (vam->ofp, "%11d%15U%15U%14d\n",
9300 ntohl (mp->sw_if_index),
9301 format_ip4_address, &mp->src_address,
9302 format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id));
9305 static void vl_api_gre_tunnel_details_t_handler_json
9306 (vl_api_gre_tunnel_details_t * mp)
9308 vat_main_t *vam = &vat_main;
9309 vat_json_node_t *node = NULL;
9312 if (VAT_JSON_ARRAY != vam->json_tree.type)
9314 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9315 vat_json_init_array (&vam->json_tree);
9317 node = vat_json_array_add (&vam->json_tree);
9319 vat_json_init_object (node);
9320 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9321 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9322 vat_json_object_add_ip4 (node, "src_address", ip4);
9323 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9324 vat_json_object_add_ip4 (node, "dst_address", ip4);
9325 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9329 api_gre_tunnel_dump (vat_main_t * vam)
9331 unformat_input_t *i = vam->input;
9332 vl_api_gre_tunnel_dump_t *mp;
9335 u8 sw_if_index_set = 0;
9337 /* Parse args required to build the message */
9338 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9340 if (unformat (i, "sw_if_index %d", &sw_if_index))
9341 sw_if_index_set = 1;
9346 if (sw_if_index_set == 0)
9351 if (!vam->json_output)
9353 fformat (vam->ofp, "%11s%15s%15s%14s\n",
9354 "sw_if_index", "src_address", "dst_address", "outer_fib_id");
9357 /* Get list of gre-tunnel interfaces */
9358 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9360 mp->sw_if_index = htonl (sw_if_index);
9364 /* Use a control ping for synchronization */
9366 vl_api_control_ping_t *mp;
9367 M (CONTROL_PING, control_ping);
9374 api_l2_fib_clear_table (vat_main_t * vam)
9376 // unformat_input_t * i = vam->input;
9377 vl_api_l2_fib_clear_table_t *mp;
9380 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9389 api_l2_interface_efp_filter (vat_main_t * vam)
9391 unformat_input_t *i = vam->input;
9392 vl_api_l2_interface_efp_filter_t *mp;
9396 u8 sw_if_index_set = 0;
9398 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9400 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9401 sw_if_index_set = 1;
9402 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9403 sw_if_index_set = 1;
9404 else if (unformat (i, "enable"))
9406 else if (unformat (i, "disable"))
9410 clib_warning ("parse error '%U'", format_unformat_error, i);
9415 if (sw_if_index_set == 0)
9417 errmsg ("missing sw_if_index\n");
9421 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9423 mp->sw_if_index = ntohl (sw_if_index);
9424 mp->enable_disable = enable;
9432 #define foreach_vtr_op \
9433 _("disable", L2_VTR_DISABLED) \
9434 _("push-1", L2_VTR_PUSH_1) \
9435 _("push-2", L2_VTR_PUSH_2) \
9436 _("pop-1", L2_VTR_POP_1) \
9437 _("pop-2", L2_VTR_POP_2) \
9438 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9439 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9440 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9441 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9444 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9446 unformat_input_t *i = vam->input;
9447 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9450 u8 sw_if_index_set = 0;
9457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9459 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9460 sw_if_index_set = 1;
9461 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9462 sw_if_index_set = 1;
9463 else if (unformat (i, "vtr_op %d", &vtr_op))
9465 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9468 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9470 else if (unformat (i, "tag1 %d", &tag1))
9472 else if (unformat (i, "tag2 %d", &tag2))
9476 clib_warning ("parse error '%U'", format_unformat_error, i);
9481 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9483 errmsg ("missing vtr operation or sw_if_index\n");
9487 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9488 mp->sw_if_index = ntohl (sw_if_index);
9489 mp->vtr_op = ntohl (vtr_op);
9490 mp->push_dot1q = ntohl (push_dot1q);
9491 mp->tag1 = ntohl (tag1);
9492 mp->tag2 = ntohl (tag2);
9501 api_create_vhost_user_if (vat_main_t * vam)
9503 unformat_input_t *i = vam->input;
9504 vl_api_create_vhost_user_if_t *mp;
9508 u8 file_name_set = 0;
9509 u32 custom_dev_instance = ~0;
9511 u8 use_custom_mac = 0;
9513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9515 if (unformat (i, "socket %s", &file_name))
9519 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9521 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9523 else if (unformat (i, "server"))
9529 if (file_name_set == 0)
9531 errmsg ("missing socket file name\n");
9535 if (vec_len (file_name) > 255)
9537 errmsg ("socket file name too long\n");
9540 vec_add1 (file_name, 0);
9542 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9544 mp->is_server = is_server;
9545 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9546 vec_free (file_name);
9547 if (custom_dev_instance != ~0)
9550 mp->custom_dev_instance = ntohl (custom_dev_instance);
9552 mp->use_custom_mac = use_custom_mac;
9553 clib_memcpy (mp->mac_address, hwaddr, 6);
9562 api_modify_vhost_user_if (vat_main_t * vam)
9564 unformat_input_t *i = vam->input;
9565 vl_api_modify_vhost_user_if_t *mp;
9569 u8 file_name_set = 0;
9570 u32 custom_dev_instance = ~0;
9571 u8 sw_if_index_set = 0;
9572 u32 sw_if_index = (u32) ~ 0;
9574 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9576 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9577 sw_if_index_set = 1;
9578 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9579 sw_if_index_set = 1;
9580 else if (unformat (i, "socket %s", &file_name))
9584 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9586 else if (unformat (i, "server"))
9592 if (sw_if_index_set == 0)
9594 errmsg ("missing sw_if_index or interface name\n");
9598 if (file_name_set == 0)
9600 errmsg ("missing socket file name\n");
9604 if (vec_len (file_name) > 255)
9606 errmsg ("socket file name too long\n");
9609 vec_add1 (file_name, 0);
9611 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9613 mp->sw_if_index = ntohl (sw_if_index);
9614 mp->is_server = is_server;
9615 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9616 vec_free (file_name);
9617 if (custom_dev_instance != ~0)
9620 mp->custom_dev_instance = ntohl (custom_dev_instance);
9630 api_delete_vhost_user_if (vat_main_t * vam)
9632 unformat_input_t *i = vam->input;
9633 vl_api_delete_vhost_user_if_t *mp;
9635 u32 sw_if_index = ~0;
9636 u8 sw_if_index_set = 0;
9638 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9640 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9641 sw_if_index_set = 1;
9642 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9643 sw_if_index_set = 1;
9648 if (sw_if_index_set == 0)
9650 errmsg ("missing sw_if_index or interface name\n");
9655 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9657 mp->sw_if_index = ntohl (sw_if_index);
9665 static void vl_api_sw_interface_vhost_user_details_t_handler
9666 (vl_api_sw_interface_vhost_user_details_t * mp)
9668 vat_main_t *vam = &vat_main;
9670 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9671 (char *) mp->interface_name,
9672 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9673 clib_net_to_host_u64 (mp->features), mp->is_server,
9674 ntohl (mp->num_regions), (char *) mp->sock_filename);
9675 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9678 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9679 (vl_api_sw_interface_vhost_user_details_t * mp)
9681 vat_main_t *vam = &vat_main;
9682 vat_json_node_t *node = NULL;
9684 if (VAT_JSON_ARRAY != vam->json_tree.type)
9686 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9687 vat_json_init_array (&vam->json_tree);
9689 node = vat_json_array_add (&vam->json_tree);
9691 vat_json_init_object (node);
9692 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9693 vat_json_object_add_string_copy (node, "interface_name",
9694 mp->interface_name);
9695 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9696 ntohl (mp->virtio_net_hdr_sz));
9697 vat_json_object_add_uint (node, "features",
9698 clib_net_to_host_u64 (mp->features));
9699 vat_json_object_add_uint (node, "is_server", mp->is_server);
9700 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9701 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9702 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9706 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9708 vl_api_sw_interface_vhost_user_dump_t *mp;
9711 "Interface name idx hdr_sz features server regions filename\n");
9713 /* Get list of vhost-user interfaces */
9714 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9717 /* Use a control ping for synchronization */
9719 vl_api_control_ping_t *mp;
9720 M (CONTROL_PING, control_ping);
9727 api_show_version (vat_main_t * vam)
9729 vl_api_show_version_t *mp;
9732 M (SHOW_VERSION, show_version);
9742 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9744 unformat_input_t *line_input = vam->input;
9745 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9747 ip4_address_t local4, remote4;
9748 ip6_address_t local6, remote6;
9750 u8 ipv4_set = 0, ipv6_set = 0;
9753 u32 encap_vrf_id = 0;
9754 u32 decap_vrf_id = 0;
9759 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9761 if (unformat (line_input, "del"))
9763 else if (unformat (line_input, "local %U",
9764 unformat_ip4_address, &local4))
9769 else if (unformat (line_input, "remote %U",
9770 unformat_ip4_address, &remote4))
9775 else if (unformat (line_input, "local %U",
9776 unformat_ip6_address, &local6))
9781 else if (unformat (line_input, "remote %U",
9782 unformat_ip6_address, &remote6))
9787 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9789 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
9791 else if (unformat (line_input, "vni %d", &vni))
9793 else if (unformat (line_input, "next-ip4"))
9795 else if (unformat (line_input, "next-ip6"))
9797 else if (unformat (line_input, "next-ethernet"))
9799 else if (unformat (line_input, "next-nsh"))
9803 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9810 errmsg ("tunnel local address not specified\n");
9813 if (remote_set == 0)
9815 errmsg ("tunnel remote address not specified\n");
9818 if (ipv4_set && ipv6_set)
9820 errmsg ("both IPv4 and IPv6 addresses specified");
9826 errmsg ("vni not specified\n");
9830 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
9835 clib_memcpy (&mp->local, &local6, sizeof (local6));
9836 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
9840 clib_memcpy (&mp->local, &local4, sizeof (local4));
9841 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
9844 mp->encap_vrf_id = ntohl (encap_vrf_id);
9845 mp->decap_vrf_id = ntohl (decap_vrf_id);
9846 mp->protocol = ntohl (protocol);
9847 mp->vni = ntohl (vni);
9848 mp->is_add = is_add;
9849 mp->is_ipv6 = ipv6_set;
9857 static void vl_api_vxlan_gpe_tunnel_details_t_handler
9858 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9860 vat_main_t *vam = &vat_main;
9862 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
9863 ntohl (mp->sw_if_index),
9864 format_ip46_address, &(mp->local[0]),
9865 format_ip46_address, &(mp->remote[0]),
9867 ntohl (mp->protocol),
9868 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
9871 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
9872 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9874 vat_main_t *vam = &vat_main;
9875 vat_json_node_t *node = NULL;
9877 struct in6_addr ip6;
9879 if (VAT_JSON_ARRAY != vam->json_tree.type)
9881 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9882 vat_json_init_array (&vam->json_tree);
9884 node = vat_json_array_add (&vam->json_tree);
9886 vat_json_init_object (node);
9887 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9890 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
9891 vat_json_object_add_ip6 (node, "local", ip6);
9892 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
9893 vat_json_object_add_ip6 (node, "remote", ip6);
9897 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
9898 vat_json_object_add_ip4 (node, "local", ip4);
9899 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
9900 vat_json_object_add_ip4 (node, "remote", ip4);
9902 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9903 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
9904 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9905 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
9906 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9910 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
9912 unformat_input_t *i = vam->input;
9913 vl_api_vxlan_gpe_tunnel_dump_t *mp;
9916 u8 sw_if_index_set = 0;
9918 /* Parse args required to build the message */
9919 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9921 if (unformat (i, "sw_if_index %d", &sw_if_index))
9922 sw_if_index_set = 1;
9927 if (sw_if_index_set == 0)
9932 if (!vam->json_output)
9934 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
9935 "sw_if_index", "local", "remote", "vni",
9936 "protocol", "encap_vrf_id", "decap_vrf_id");
9939 /* Get list of vxlan-tunnel interfaces */
9940 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
9942 mp->sw_if_index = htonl (sw_if_index);
9946 /* Use a control ping for synchronization */
9948 vl_api_control_ping_t *mp;
9949 M (CONTROL_PING, control_ping);
9956 format_l2_fib_mac_address (u8 * s, va_list * args)
9958 u8 *a = va_arg (*args, u8 *);
9960 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
9961 a[2], a[3], a[4], a[5], a[6], a[7]);
9964 static void vl_api_l2_fib_table_entry_t_handler
9965 (vl_api_l2_fib_table_entry_t * mp)
9967 vat_main_t *vam = &vat_main;
9969 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
9971 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
9972 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
9976 static void vl_api_l2_fib_table_entry_t_handler_json
9977 (vl_api_l2_fib_table_entry_t * mp)
9979 vat_main_t *vam = &vat_main;
9980 vat_json_node_t *node = NULL;
9982 if (VAT_JSON_ARRAY != vam->json_tree.type)
9984 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9985 vat_json_init_array (&vam->json_tree);
9987 node = vat_json_array_add (&vam->json_tree);
9989 vat_json_init_object (node);
9990 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
9991 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
9992 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9993 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
9994 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
9995 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
9999 api_l2_fib_table_dump (vat_main_t * vam)
10001 unformat_input_t *i = vam->input;
10002 vl_api_l2_fib_table_dump_t *mp;
10007 /* Parse args required to build the message */
10008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10010 if (unformat (i, "bd_id %d", &bd_id))
10016 if (bd_id_set == 0)
10018 errmsg ("missing bridge domain\n");
10023 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10025 /* Get list of l2 fib entries */
10026 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10028 mp->bd_id = ntohl (bd_id);
10031 /* Use a control ping for synchronization */
10033 vl_api_control_ping_t *mp;
10034 M (CONTROL_PING, control_ping);
10042 api_interface_name_renumber (vat_main_t * vam)
10044 unformat_input_t *line_input = vam->input;
10045 vl_api_interface_name_renumber_t *mp;
10046 u32 sw_if_index = ~0;
10048 u32 new_show_dev_instance = ~0;
10050 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10052 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10055 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10057 else if (unformat (line_input, "new_show_dev_instance %d",
10058 &new_show_dev_instance))
10064 if (sw_if_index == ~0)
10066 errmsg ("missing interface name or sw_if_index\n");
10070 if (new_show_dev_instance == ~0)
10072 errmsg ("missing new_show_dev_instance\n");
10076 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10078 mp->sw_if_index = ntohl (sw_if_index);
10079 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10086 api_want_ip4_arp_events (vat_main_t * vam)
10088 unformat_input_t *line_input = vam->input;
10089 vl_api_want_ip4_arp_events_t *mp;
10091 ip4_address_t address;
10092 int address_set = 0;
10093 u32 enable_disable = 1;
10095 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10097 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10099 else if (unformat (line_input, "del"))
10100 enable_disable = 0;
10105 if (address_set == 0)
10107 errmsg ("missing addresses\n");
10111 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10112 mp->enable_disable = enable_disable;
10113 mp->pid = getpid ();
10114 mp->address = address.as_u32;
10121 api_input_acl_set_interface (vat_main_t * vam)
10123 unformat_input_t *i = vam->input;
10124 vl_api_input_acl_set_interface_t *mp;
10127 int sw_if_index_set;
10128 u32 ip4_table_index = ~0;
10129 u32 ip6_table_index = ~0;
10130 u32 l2_table_index = ~0;
10133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10135 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10136 sw_if_index_set = 1;
10137 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10138 sw_if_index_set = 1;
10139 else if (unformat (i, "del"))
10141 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10143 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10145 else if (unformat (i, "l2-table %d", &l2_table_index))
10149 clib_warning ("parse error '%U'", format_unformat_error, i);
10154 if (sw_if_index_set == 0)
10156 errmsg ("missing interface name or sw_if_index\n");
10160 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10162 mp->sw_if_index = ntohl (sw_if_index);
10163 mp->ip4_table_index = ntohl (ip4_table_index);
10164 mp->ip6_table_index = ntohl (ip6_table_index);
10165 mp->l2_table_index = ntohl (l2_table_index);
10166 mp->is_add = is_add;
10175 api_ip_address_dump (vat_main_t * vam)
10177 unformat_input_t *i = vam->input;
10178 vl_api_ip_address_dump_t *mp;
10179 u32 sw_if_index = ~0;
10180 u8 sw_if_index_set = 0;
10185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10187 if (unformat (i, "sw_if_index %d", &sw_if_index))
10188 sw_if_index_set = 1;
10189 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10190 sw_if_index_set = 1;
10191 else if (unformat (i, "ipv4"))
10193 else if (unformat (i, "ipv6"))
10199 if (ipv4_set && ipv6_set)
10201 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10205 if ((!ipv4_set) && (!ipv6_set))
10207 errmsg ("no ipv4 nor ipv6 flag set\n");
10211 if (sw_if_index_set == 0)
10213 errmsg ("missing interface name or sw_if_index\n");
10217 vam->current_sw_if_index = sw_if_index;
10218 vam->is_ipv6 = ipv6_set;
10220 M (IP_ADDRESS_DUMP, ip_address_dump);
10221 mp->sw_if_index = ntohl (sw_if_index);
10222 mp->is_ipv6 = ipv6_set;
10225 /* Use a control ping for synchronization */
10227 vl_api_control_ping_t *mp;
10228 M (CONTROL_PING, control_ping);
10235 api_ip_dump (vat_main_t * vam)
10237 vl_api_ip_dump_t *mp;
10238 unformat_input_t *in = vam->input;
10245 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10247 if (unformat (in, "ipv4"))
10249 else if (unformat (in, "ipv6"))
10255 if (ipv4_set && ipv6_set)
10257 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10261 if ((!ipv4_set) && (!ipv6_set))
10263 errmsg ("no ipv4 nor ipv6 flag set\n");
10267 is_ipv6 = ipv6_set;
10268 vam->is_ipv6 = is_ipv6;
10270 /* free old data */
10271 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10273 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10275 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10277 M (IP_DUMP, ip_dump);
10278 mp->is_ipv6 = ipv6_set;
10281 /* Use a control ping for synchronization */
10283 vl_api_control_ping_t *mp;
10284 M (CONTROL_PING, control_ping);
10291 api_ipsec_spd_add_del (vat_main_t * vam)
10294 unformat_input_t *i = vam->input;
10295 vl_api_ipsec_spd_add_del_t *mp;
10300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10302 if (unformat (i, "spd_id %d", &spd_id))
10304 else if (unformat (i, "del"))
10308 clib_warning ("parse error '%U'", format_unformat_error, i);
10314 errmsg ("spd_id must be set\n");
10318 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10320 mp->spd_id = ntohl (spd_id);
10321 mp->is_add = is_add;
10328 clib_warning ("unsupported (no dpdk)");
10334 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10337 unformat_input_t *i = vam->input;
10338 vl_api_ipsec_interface_add_del_spd_t *mp;
10341 u8 sw_if_index_set = 0;
10342 u32 spd_id = (u32) ~ 0;
10345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10347 if (unformat (i, "del"))
10349 else if (unformat (i, "spd_id %d", &spd_id))
10351 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10352 sw_if_index_set = 1;
10353 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10354 sw_if_index_set = 1;
10357 clib_warning ("parse error '%U'", format_unformat_error, i);
10363 if (spd_id == (u32) ~ 0)
10365 errmsg ("spd_id must be set\n");
10369 if (sw_if_index_set == 0)
10371 errmsg ("missing interface name or sw_if_index\n");
10375 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10377 mp->spd_id = ntohl (spd_id);
10378 mp->sw_if_index = ntohl (sw_if_index);
10379 mp->is_add = is_add;
10386 clib_warning ("unsupported (no dpdk)");
10392 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10395 unformat_input_t *i = vam->input;
10396 vl_api_ipsec_spd_add_del_entry_t *mp;
10398 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10399 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10401 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10402 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10403 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10404 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10406 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10407 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10408 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10409 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10410 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10411 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10413 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10415 if (unformat (i, "del"))
10417 if (unformat (i, "outbound"))
10419 if (unformat (i, "inbound"))
10421 else if (unformat (i, "spd_id %d", &spd_id))
10423 else if (unformat (i, "sa_id %d", &sa_id))
10425 else if (unformat (i, "priority %d", &priority))
10427 else if (unformat (i, "protocol %d", &protocol))
10429 else if (unformat (i, "lport_start %d", &lport_start))
10431 else if (unformat (i, "lport_stop %d", &lport_stop))
10433 else if (unformat (i, "rport_start %d", &rport_start))
10435 else if (unformat (i, "rport_stop %d", &rport_stop))
10439 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10445 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10452 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10458 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10465 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10471 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10478 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10484 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10490 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10492 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10494 clib_warning ("unsupported action: 'resolve'");
10500 clib_warning ("parse error '%U'", format_unformat_error, i);
10506 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10508 mp->spd_id = ntohl (spd_id);
10509 mp->priority = ntohl (priority);
10510 mp->is_outbound = is_outbound;
10512 mp->is_ipv6 = is_ipv6;
10513 if (is_ipv6 || is_ip_any)
10515 clib_memcpy (mp->remote_address_start, &raddr6_start,
10516 sizeof (ip6_address_t));
10517 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10518 sizeof (ip6_address_t));
10519 clib_memcpy (mp->local_address_start, &laddr6_start,
10520 sizeof (ip6_address_t));
10521 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10522 sizeof (ip6_address_t));
10526 clib_memcpy (mp->remote_address_start, &raddr4_start,
10527 sizeof (ip4_address_t));
10528 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10529 sizeof (ip4_address_t));
10530 clib_memcpy (mp->local_address_start, &laddr4_start,
10531 sizeof (ip4_address_t));
10532 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10533 sizeof (ip4_address_t));
10535 mp->protocol = (u8) protocol;
10536 mp->local_port_start = ntohs ((u16) lport_start);
10537 mp->local_port_stop = ntohs ((u16) lport_stop);
10538 mp->remote_port_start = ntohs ((u16) rport_start);
10539 mp->remote_port_stop = ntohs ((u16) rport_stop);
10540 mp->policy = (u8) policy;
10541 mp->sa_id = ntohl (sa_id);
10542 mp->is_add = is_add;
10543 mp->is_ip_any = is_ip_any;
10549 clib_warning ("unsupported (no dpdk)");
10555 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10558 unformat_input_t *i = vam->input;
10559 vl_api_ipsec_sad_add_del_entry_t *mp;
10561 u32 sad_id = 0, spi = 0;
10562 u8 *ck = 0, *ik = 0;
10565 u8 protocol = IPSEC_PROTOCOL_AH;
10566 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10567 u32 crypto_alg = 0, integ_alg = 0;
10568 ip4_address_t tun_src4;
10569 ip4_address_t tun_dst4;
10570 ip6_address_t tun_src6;
10571 ip6_address_t tun_dst6;
10573 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10575 if (unformat (i, "del"))
10577 else if (unformat (i, "sad_id %d", &sad_id))
10579 else if (unformat (i, "spi %d", &spi))
10581 else if (unformat (i, "esp"))
10582 protocol = IPSEC_PROTOCOL_ESP;
10583 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10586 is_tunnel_ipv6 = 0;
10588 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10591 is_tunnel_ipv6 = 0;
10593 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10596 is_tunnel_ipv6 = 1;
10598 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10601 is_tunnel_ipv6 = 1;
10605 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10607 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10608 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10610 clib_warning ("unsupported crypto-alg: '%U'",
10611 format_ipsec_crypto_alg, crypto_alg);
10615 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10619 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10621 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10622 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10624 clib_warning ("unsupported integ-alg: '%U'",
10625 format_ipsec_integ_alg, integ_alg);
10629 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10633 clib_warning ("parse error '%U'", format_unformat_error, i);
10639 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10641 mp->sad_id = ntohl (sad_id);
10642 mp->is_add = is_add;
10643 mp->protocol = protocol;
10644 mp->spi = ntohl (spi);
10645 mp->is_tunnel = is_tunnel;
10646 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10647 mp->crypto_algorithm = crypto_alg;
10648 mp->integrity_algorithm = integ_alg;
10649 mp->crypto_key_length = vec_len (ck);
10650 mp->integrity_key_length = vec_len (ik);
10652 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10653 mp->crypto_key_length = sizeof (mp->crypto_key);
10655 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10656 mp->integrity_key_length = sizeof (mp->integrity_key);
10659 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10661 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10665 if (is_tunnel_ipv6)
10667 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10668 sizeof (ip6_address_t));
10669 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10670 sizeof (ip6_address_t));
10674 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10675 sizeof (ip4_address_t));
10676 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10677 sizeof (ip4_address_t));
10686 clib_warning ("unsupported (no dpdk)");
10692 api_ipsec_sa_set_key (vat_main_t * vam)
10695 unformat_input_t *i = vam->input;
10696 vl_api_ipsec_sa_set_key_t *mp;
10699 u8 *ck = 0, *ik = 0;
10701 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10703 if (unformat (i, "sa_id %d", &sa_id))
10705 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10707 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10711 clib_warning ("parse error '%U'", format_unformat_error, i);
10716 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10718 mp->sa_id = ntohl (sa_id);
10719 mp->crypto_key_length = vec_len (ck);
10720 mp->integrity_key_length = vec_len (ik);
10722 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10723 mp->crypto_key_length = sizeof (mp->crypto_key);
10725 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10726 mp->integrity_key_length = sizeof (mp->integrity_key);
10729 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10731 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10738 clib_warning ("unsupported (no dpdk)");
10744 api_ikev2_profile_add_del (vat_main_t * vam)
10747 unformat_input_t *i = vam->input;
10748 vl_api_ikev2_profile_add_del_t *mp;
10753 const char *valid_chars = "a-zA-Z0-9_";
10755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10757 if (unformat (i, "del"))
10759 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10760 vec_add1 (name, 0);
10763 errmsg ("parse error '%U'", format_unformat_error, i);
10768 if (!vec_len (name))
10770 errmsg ("profile name must be specified");
10774 if (vec_len (name) > 64)
10776 errmsg ("profile name too long");
10780 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
10782 clib_memcpy (mp->name, name, vec_len (name));
10783 mp->is_add = is_add;
10791 clib_warning ("unsupported (no dpdk)");
10797 api_ikev2_profile_set_auth (vat_main_t * vam)
10800 unformat_input_t *i = vam->input;
10801 vl_api_ikev2_profile_set_auth_t *mp;
10805 u32 auth_method = 0;
10808 const char *valid_chars = "a-zA-Z0-9_";
10810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10812 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10813 vec_add1 (name, 0);
10814 else if (unformat (i, "auth_method %U",
10815 unformat_ikev2_auth_method, &auth_method))
10817 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
10819 else if (unformat (i, "auth_data %v", &data))
10823 errmsg ("parse error '%U'", format_unformat_error, i);
10828 if (!vec_len (name))
10830 errmsg ("profile name must be specified");
10834 if (vec_len (name) > 64)
10836 errmsg ("profile name too long");
10840 if (!vec_len (data))
10842 errmsg ("auth_data must be specified");
10848 errmsg ("auth_method must be specified");
10852 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
10854 mp->is_hex = is_hex;
10855 mp->auth_method = (u8) auth_method;
10856 mp->data_len = vec_len (data);
10857 clib_memcpy (mp->name, name, vec_len (name));
10858 clib_memcpy (mp->data, data, vec_len (data));
10867 clib_warning ("unsupported (no dpdk)");
10873 api_ikev2_profile_set_id (vat_main_t * vam)
10876 unformat_input_t *i = vam->input;
10877 vl_api_ikev2_profile_set_id_t *mp;
10885 const char *valid_chars = "a-zA-Z0-9_";
10887 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10889 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10890 vec_add1 (name, 0);
10891 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
10893 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
10895 data = vec_new (u8, 4);
10896 clib_memcpy (data, ip4.as_u8, 4);
10898 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
10900 else if (unformat (i, "id_data %v", &data))
10902 else if (unformat (i, "local"))
10904 else if (unformat (i, "remote"))
10908 errmsg ("parse error '%U'", format_unformat_error, i);
10913 if (!vec_len (name))
10915 errmsg ("profile name must be specified");
10919 if (vec_len (name) > 64)
10921 errmsg ("profile name too long");
10925 if (!vec_len (data))
10927 errmsg ("id_data must be specified");
10933 errmsg ("id_type must be specified");
10937 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
10939 mp->is_local = is_local;
10940 mp->id_type = (u8) id_type;
10941 mp->data_len = vec_len (data);
10942 clib_memcpy (mp->name, name, vec_len (name));
10943 clib_memcpy (mp->data, data, vec_len (data));
10952 clib_warning ("unsupported (no dpdk)");
10958 api_ikev2_profile_set_ts (vat_main_t * vam)
10961 unformat_input_t *i = vam->input;
10962 vl_api_ikev2_profile_set_ts_t *mp;
10966 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
10967 ip4_address_t start_addr, end_addr;
10969 const char *valid_chars = "a-zA-Z0-9_";
10971 start_addr.as_u32 = 0;
10972 end_addr.as_u32 = (u32) ~ 0;
10974 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10976 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10977 vec_add1 (name, 0);
10978 else if (unformat (i, "protocol %d", &proto))
10980 else if (unformat (i, "start_port %d", &start_port))
10982 else if (unformat (i, "end_port %d", &end_port))
10985 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
10987 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
10989 else if (unformat (i, "local"))
10991 else if (unformat (i, "remote"))
10995 errmsg ("parse error '%U'", format_unformat_error, i);
11000 if (!vec_len (name))
11002 errmsg ("profile name must be specified");
11006 if (vec_len (name) > 64)
11008 errmsg ("profile name too long");
11012 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11014 mp->is_local = is_local;
11015 mp->proto = (u8) proto;
11016 mp->start_port = (u16) start_port;
11017 mp->end_port = (u16) end_port;
11018 mp->start_addr = start_addr.as_u32;
11019 mp->end_addr = end_addr.as_u32;
11020 clib_memcpy (mp->name, name, vec_len (name));
11028 clib_warning ("unsupported (no dpdk)");
11034 api_ikev2_set_local_key (vat_main_t * vam)
11037 unformat_input_t *i = vam->input;
11038 vl_api_ikev2_set_local_key_t *mp;
11042 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11044 if (unformat (i, "file %v", &file))
11045 vec_add1 (file, 0);
11048 errmsg ("parse error '%U'", format_unformat_error, i);
11053 if (!vec_len (file))
11055 errmsg ("RSA key file must be specified");
11059 if (vec_len (file) > 256)
11061 errmsg ("file name too long");
11065 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11067 clib_memcpy (mp->key_file, file, vec_len (file));
11075 clib_warning ("unsupported (no dpdk)");
11084 api_map_add_domain (vat_main_t * vam)
11086 unformat_input_t *i = vam->input;
11087 vl_api_map_add_domain_t *mp;
11090 ip4_address_t ip4_prefix;
11091 ip6_address_t ip6_prefix;
11092 ip6_address_t ip6_src;
11093 u32 num_m_args = 0;
11094 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11095 0, psid_length = 0;
11096 u8 is_translation = 0;
11098 u8 ip6_src_len = 128;
11100 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11102 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11103 &ip4_prefix, &ip4_prefix_len))
11105 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11106 &ip6_prefix, &ip6_prefix_len))
11110 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11113 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11115 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11117 else if (unformat (i, "psid-offset %d", &psid_offset))
11119 else if (unformat (i, "psid-len %d", &psid_length))
11121 else if (unformat (i, "mtu %d", &mtu))
11123 else if (unformat (i, "map-t"))
11124 is_translation = 1;
11127 clib_warning ("parse error '%U'", format_unformat_error, i);
11132 if (num_m_args != 6)
11134 errmsg ("mandatory argument(s) missing\n");
11138 /* Construct the API message */
11139 M (MAP_ADD_DOMAIN, map_add_domain);
11141 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11142 mp->ip4_prefix_len = ip4_prefix_len;
11144 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11145 mp->ip6_prefix_len = ip6_prefix_len;
11147 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11148 mp->ip6_src_prefix_len = ip6_src_len;
11150 mp->ea_bits_len = ea_bits_len;
11151 mp->psid_offset = psid_offset;
11152 mp->psid_length = psid_length;
11153 mp->is_translation = is_translation;
11154 mp->mtu = htons (mtu);
11159 /* Wait for a reply, return good/bad news */
11164 api_map_del_domain (vat_main_t * vam)
11166 unformat_input_t *i = vam->input;
11167 vl_api_map_del_domain_t *mp;
11170 u32 num_m_args = 0;
11173 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11175 if (unformat (i, "index %d", &index))
11179 clib_warning ("parse error '%U'", format_unformat_error, i);
11184 if (num_m_args != 1)
11186 errmsg ("mandatory argument(s) missing\n");
11190 /* Construct the API message */
11191 M (MAP_DEL_DOMAIN, map_del_domain);
11193 mp->index = ntohl (index);
11198 /* Wait for a reply, return good/bad news */
11203 api_map_add_del_rule (vat_main_t * vam)
11205 unformat_input_t *i = vam->input;
11206 vl_api_map_add_del_rule_t *mp;
11209 ip6_address_t ip6_dst;
11210 u32 num_m_args = 0, index, psid = 0;
11212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11214 if (unformat (i, "index %d", &index))
11216 else if (unformat (i, "psid %d", &psid))
11218 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11220 else if (unformat (i, "del"))
11226 clib_warning ("parse error '%U'", format_unformat_error, i);
11231 /* Construct the API message */
11232 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11234 mp->index = ntohl (index);
11235 mp->is_add = is_add;
11236 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11237 mp->psid = ntohs (psid);
11242 /* Wait for a reply, return good/bad news */
11247 api_map_domain_dump (vat_main_t * vam)
11249 vl_api_map_domain_dump_t *mp;
11252 /* Construct the API message */
11253 M (MAP_DOMAIN_DUMP, map_domain_dump);
11258 /* Use a control ping for synchronization */
11260 vl_api_control_ping_t *mp;
11261 M (CONTROL_PING, control_ping);
11268 api_map_rule_dump (vat_main_t * vam)
11270 unformat_input_t *i = vam->input;
11271 vl_api_map_rule_dump_t *mp;
11273 u32 domain_index = ~0;
11275 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11277 if (unformat (i, "index %u", &domain_index))
11283 if (domain_index == ~0)
11285 clib_warning ("parse error: domain index expected");
11289 /* Construct the API message */
11290 M (MAP_RULE_DUMP, map_rule_dump);
11292 mp->domain_index = htonl (domain_index);
11297 /* Use a control ping for synchronization */
11299 vl_api_control_ping_t *mp;
11300 M (CONTROL_PING, control_ping);
11306 static void vl_api_map_add_domain_reply_t_handler
11307 (vl_api_map_add_domain_reply_t * mp)
11309 vat_main_t *vam = &vat_main;
11310 i32 retval = ntohl (mp->retval);
11312 if (vam->async_mode)
11314 vam->async_errors += (retval < 0);
11318 vam->retval = retval;
11319 vam->result_ready = 1;
11323 static void vl_api_map_add_domain_reply_t_handler_json
11324 (vl_api_map_add_domain_reply_t * mp)
11326 vat_main_t *vam = &vat_main;
11327 vat_json_node_t node;
11329 vat_json_init_object (&node);
11330 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11331 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11333 vat_json_print (vam->ofp, &node);
11334 vat_json_free (&node);
11336 vam->retval = ntohl (mp->retval);
11337 vam->result_ready = 1;
11341 api_get_first_msg_id (vat_main_t * vam)
11343 vl_api_get_first_msg_id_t *mp;
11345 unformat_input_t *i = vam->input;
11349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11351 if (unformat (i, "client %s", &name))
11359 errmsg ("missing client name\n");
11362 vec_add1 (name, 0);
11364 if (vec_len (name) > 63)
11366 errmsg ("client name too long\n");
11370 M (GET_FIRST_MSG_ID, get_first_msg_id);
11371 clib_memcpy (mp->name, name, vec_len (name));
11379 api_cop_interface_enable_disable (vat_main_t * vam)
11381 unformat_input_t *line_input = vam->input;
11382 vl_api_cop_interface_enable_disable_t *mp;
11384 u32 sw_if_index = ~0;
11385 u8 enable_disable = 1;
11387 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11389 if (unformat (line_input, "disable"))
11390 enable_disable = 0;
11391 if (unformat (line_input, "enable"))
11392 enable_disable = 1;
11393 else if (unformat (line_input, "%U", unformat_sw_if_index,
11394 vam, &sw_if_index))
11396 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11402 if (sw_if_index == ~0)
11404 errmsg ("missing interface name or sw_if_index\n");
11408 /* Construct the API message */
11409 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11410 mp->sw_if_index = ntohl (sw_if_index);
11411 mp->enable_disable = enable_disable;
11415 /* Wait for the reply */
11420 api_cop_whitelist_enable_disable (vat_main_t * vam)
11422 unformat_input_t *line_input = vam->input;
11423 vl_api_cop_whitelist_enable_disable_t *mp;
11425 u32 sw_if_index = ~0;
11426 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11429 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11431 if (unformat (line_input, "ip4"))
11433 else if (unformat (line_input, "ip6"))
11435 else if (unformat (line_input, "default"))
11437 else if (unformat (line_input, "%U", unformat_sw_if_index,
11438 vam, &sw_if_index))
11440 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11442 else if (unformat (line_input, "fib-id %d", &fib_id))
11448 if (sw_if_index == ~0)
11450 errmsg ("missing interface name or sw_if_index\n");
11454 /* Construct the API message */
11455 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11456 mp->sw_if_index = ntohl (sw_if_index);
11457 mp->fib_id = ntohl (fib_id);
11460 mp->default_cop = default_cop;
11464 /* Wait for the reply */
11469 api_get_node_graph (vat_main_t * vam)
11471 vl_api_get_node_graph_t *mp;
11474 M (GET_NODE_GRAPH, get_node_graph);
11478 /* Wait for the reply */
11483 /** Used for parsing LISP eids */
11484 typedef CLIB_PACKED(struct{
11485 u8 addr[16]; /**< eid address */
11486 u32 len; /**< prefix length if IP */
11487 u8 type; /**< type of eid */
11492 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11494 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11496 memset (a, 0, sizeof (a[0]));
11498 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11500 a->type = 0; /* ipv4 type */
11502 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11504 a->type = 1; /* ipv6 type */
11506 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11508 a->type = 2; /* mac type */
11515 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11524 lisp_eid_size_vat (u8 type)
11539 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11541 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11545 /** Used for transferring locators via VPP API */
11546 typedef CLIB_PACKED(struct
11548 u32 sw_if_index; /**< locator sw_if_index */
11549 u8 priority; /**< locator priority */
11550 u8 weight; /**< locator weight */
11555 api_lisp_add_del_locator_set (vat_main_t * vam)
11557 unformat_input_t *input = vam->input;
11558 vl_api_lisp_add_del_locator_set_t *mp;
11561 u8 *locator_set_name = NULL;
11562 u8 locator_set_name_set = 0;
11563 ls_locator_t locator, *locators = 0;
11564 u32 sw_if_index, priority, weight;
11566 /* Parse args required to build the message */
11567 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11569 if (unformat (input, "del"))
11573 else if (unformat (input, "locator-set %s", &locator_set_name))
11575 locator_set_name_set = 1;
11577 else if (unformat (input, "sw_if_index %u p %u w %u",
11578 &sw_if_index, &priority, &weight))
11580 locator.sw_if_index = htonl (sw_if_index);
11581 locator.priority = priority;
11582 locator.weight = weight;
11583 vec_add1 (locators, locator);
11585 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11586 vam, &sw_if_index, &priority, &weight))
11588 locator.sw_if_index = htonl (sw_if_index);
11589 locator.priority = priority;
11590 locator.weight = weight;
11591 vec_add1 (locators, locator);
11597 if (locator_set_name_set == 0)
11599 errmsg ("missing locator-set name");
11600 vec_free (locators);
11604 if (vec_len (locator_set_name) > 64)
11606 errmsg ("locator-set name too long\n");
11607 vec_free (locator_set_name);
11608 vec_free (locators);
11611 vec_add1 (locator_set_name, 0);
11613 /* Construct the API message */
11614 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11616 mp->is_add = is_add;
11617 clib_memcpy (mp->locator_set_name, locator_set_name,
11618 vec_len (locator_set_name));
11619 vec_free (locator_set_name);
11621 mp->locator_num = vec_len (locators);
11623 clib_memcpy (mp->locators, locators,
11624 (sizeof (ls_locator_t) * vec_len (locators)));
11625 vec_free (locators);
11630 /* Wait for a reply... */
11638 api_lisp_add_del_locator (vat_main_t * vam)
11640 unformat_input_t *input = vam->input;
11641 vl_api_lisp_add_del_locator_t *mp;
11643 u32 tmp_if_index = ~0;
11644 u32 sw_if_index = ~0;
11645 u8 sw_if_index_set = 0;
11646 u8 sw_if_index_if_name_set = 0;
11648 u8 priority_set = 0;
11652 u8 *locator_set_name = NULL;
11653 u8 locator_set_name_set = 0;
11655 /* Parse args required to build the message */
11656 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11658 if (unformat (input, "del"))
11662 else if (unformat (input, "locator-set %s", &locator_set_name))
11664 locator_set_name_set = 1;
11666 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11669 sw_if_index_if_name_set = 1;
11670 sw_if_index = tmp_if_index;
11672 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11674 sw_if_index_set = 1;
11675 sw_if_index = tmp_if_index;
11677 else if (unformat (input, "p %d", &priority))
11681 else if (unformat (input, "w %d", &weight))
11689 if (locator_set_name_set == 0)
11691 errmsg ("missing locator-set name");
11695 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11697 errmsg ("missing sw_if_index");
11698 vec_free (locator_set_name);
11702 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11704 errmsg ("cannot use both params interface name and sw_if_index");
11705 vec_free (locator_set_name);
11709 if (priority_set == 0)
11711 errmsg ("missing locator-set priority\n");
11712 vec_free (locator_set_name);
11716 if (weight_set == 0)
11718 errmsg ("missing locator-set weight\n");
11719 vec_free (locator_set_name);
11723 if (vec_len (locator_set_name) > 64)
11725 errmsg ("locator-set name too long\n");
11726 vec_free (locator_set_name);
11729 vec_add1 (locator_set_name, 0);
11731 /* Construct the API message */
11732 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11734 mp->is_add = is_add;
11735 mp->sw_if_index = ntohl (sw_if_index);
11736 mp->priority = priority;
11737 mp->weight = weight;
11738 clib_memcpy (mp->locator_set_name, locator_set_name,
11739 vec_len (locator_set_name));
11740 vec_free (locator_set_name);
11745 /* Wait for a reply... */
11753 api_lisp_add_del_local_eid (vat_main_t * vam)
11755 unformat_input_t *input = vam->input;
11756 vl_api_lisp_add_del_local_eid_t *mp;
11760 lisp_eid_vat_t _eid, *eid = &_eid;
11761 u8 *locator_set_name = 0;
11762 u8 locator_set_name_set = 0;
11765 /* Parse args required to build the message */
11766 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11768 if (unformat (input, "del"))
11772 else if (unformat (input, "vni %d", &vni))
11776 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
11780 else if (unformat (input, "locator-set %s", &locator_set_name))
11782 locator_set_name_set = 1;
11788 if (locator_set_name_set == 0)
11790 errmsg ("missing locator-set name\n");
11796 errmsg ("EID address not set!");
11797 vec_free (locator_set_name);
11801 if (vec_len (locator_set_name) > 64)
11803 errmsg ("locator-set name too long\n");
11804 vec_free (locator_set_name);
11807 vec_add1 (locator_set_name, 0);
11809 /* Construct the API message */
11810 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
11812 mp->is_add = is_add;
11813 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
11814 mp->eid_type = eid->type;
11815 mp->prefix_len = eid->len;
11816 mp->vni = clib_host_to_net_u32 (vni);
11817 clib_memcpy (mp->locator_set_name, locator_set_name,
11818 vec_len (locator_set_name));
11820 vec_free (locator_set_name);
11825 /* Wait for a reply... */
11833 /** Used for transferring locators via VPP API */
11834 typedef CLIB_PACKED(struct
11836 u8 is_ip4; /**< is locator an IPv4 address? */
11837 u8 priority; /**< locator priority */
11838 u8 weight; /**< locator weight */
11839 u8 addr[16]; /**< IPv4/IPv6 address */
11844 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
11846 unformat_input_t *input = vam->input;
11847 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
11850 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
11851 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
11852 u8 rmt_eid_set = 0, lcl_eid_set = 0;
11853 u32 action = ~0, p, w;
11854 ip4_address_t rmt_rloc4, lcl_rloc4;
11855 ip6_address_t rmt_rloc6, lcl_rloc6;
11856 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
11858 memset (&rloc, 0, sizeof (rloc));
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, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
11871 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
11875 else if (unformat (input, "p %d w %d", &p, &w))
11879 errmsg ("No RLOC configured for setting priority/weight!");
11882 curr_rloc->priority = p;
11883 curr_rloc->weight = w;
11885 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
11886 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
11890 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
11891 rloc.priority = rloc.weight = 0;
11892 vec_add1 (lcl_locs, rloc);
11894 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
11895 vec_add1 (rmt_locs, rloc);
11896 /* priority and weight saved in rmt loc */
11897 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11899 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
11900 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
11903 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
11904 rloc.priority = rloc.weight = 0;
11905 vec_add1 (lcl_locs, rloc);
11907 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
11908 vec_add1 (rmt_locs, rloc);
11909 /* priority and weight saved in rmt loc */
11910 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11912 else if (unformat (input, "action %d", &action))
11918 clib_warning ("parse error '%U'", format_unformat_error, input);
11925 errmsg ("remote eid addresses not set\n");
11929 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
11931 errmsg ("eid types don't match\n");
11935 if (0 == rmt_locs && (u32) ~ 0 == action)
11937 errmsg ("action not set for negative mapping\n");
11941 /* Construct the API message */
11942 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
11944 mp->is_add = is_add;
11945 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
11946 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
11947 mp->eid_type = rmt_eid->type;
11948 mp->rmt_len = rmt_eid->len;
11949 mp->lcl_len = lcl_eid->len;
11950 mp->action = action;
11952 if (0 != rmt_locs && 0 != lcl_locs)
11954 mp->loc_num = vec_len (rmt_locs);
11955 clib_memcpy (mp->lcl_locs, lcl_locs,
11956 (sizeof (rloc_t) * vec_len (lcl_locs)));
11957 clib_memcpy (mp->rmt_locs, rmt_locs,
11958 (sizeof (rloc_t) * vec_len (rmt_locs)));
11960 vec_free (lcl_locs);
11961 vec_free (rmt_locs);
11966 /* Wait for a reply... */
11974 api_lisp_add_del_map_resolver (vat_main_t * vam)
11976 unformat_input_t *input = vam->input;
11977 vl_api_lisp_add_del_map_resolver_t *mp;
11982 ip4_address_t ipv4;
11983 ip6_address_t ipv6;
11985 /* Parse args required to build the message */
11986 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11988 if (unformat (input, "del"))
11992 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
11996 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12004 if (ipv4_set && ipv6_set)
12006 errmsg ("both eid v4 and v6 addresses set\n");
12010 if (!ipv4_set && !ipv6_set)
12012 errmsg ("eid addresses not set\n");
12016 /* Construct the API message */
12017 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12019 mp->is_add = is_add;
12023 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12028 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12034 /* Wait for a reply... */
12042 api_lisp_gpe_enable_disable (vat_main_t * vam)
12044 unformat_input_t *input = vam->input;
12045 vl_api_lisp_gpe_enable_disable_t *mp;
12050 /* Parse args required to build the message */
12051 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12053 if (unformat (input, "enable"))
12058 else if (unformat (input, "disable"))
12069 errmsg ("Value not set\n");
12073 /* Construct the API message */
12074 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12081 /* Wait for a reply... */
12089 api_lisp_enable_disable (vat_main_t * vam)
12091 unformat_input_t *input = vam->input;
12092 vl_api_lisp_enable_disable_t *mp;
12097 /* Parse args required to build the message */
12098 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12100 if (unformat (input, "enable"))
12105 else if (unformat (input, "disable"))
12115 errmsg ("Value not set\n");
12119 /* Construct the API message */
12120 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12127 /* Wait for a reply... */
12135 * Enable/disable LISP proxy ITR.
12137 * @param vam vpp API test context
12138 * @return return code
12141 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12144 u8 ls_name_set = 0;
12145 unformat_input_t *input = vam->input;
12146 vl_api_lisp_pitr_set_locator_set_t *mp;
12150 /* Parse args required to build the message */
12151 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12153 if (unformat (input, "del"))
12155 else if (unformat (input, "locator-set %s", &ls_name))
12159 errmsg ("parse error '%U'", format_unformat_error, input);
12166 errmsg ("locator-set name not set!");
12170 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12172 mp->is_add = is_add;
12173 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12174 vec_free (ls_name);
12179 /* wait for reply */
12187 api_show_lisp_pitr (vat_main_t * vam)
12189 vl_api_show_lisp_pitr_t *mp;
12192 if (!vam->json_output)
12194 fformat (vam->ofp, "%=20s\n", "lisp status:");
12197 M (SHOW_LISP_PITR, show_lisp_pitr);
12201 /* Wait for a reply... */
12209 * Add/delete mapping between vni and vrf
12212 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12215 unformat_input_t *input = vam->input;
12216 vl_api_lisp_eid_table_add_del_map_t *mp;
12217 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12218 u32 vni, vrf, bd_index;
12220 /* Parse args required to build the message */
12221 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12223 if (unformat (input, "del"))
12225 else if (unformat (input, "vrf %d", &vrf))
12227 else if (unformat (input, "bd_index %d", &bd_index))
12229 else if (unformat (input, "vni %d", &vni))
12235 if (!vni_set || (!vrf_set && !bd_index_set))
12237 errmsg ("missing arguments!");
12241 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12243 mp->is_add = is_add;
12244 mp->vni = htonl (vni);
12245 mp->dp_table = htonl (vrf);
12246 mp->is_l2 = bd_index_set;
12251 /* wait for reply */
12259 * Add/del remote mapping to/from LISP control plane
12261 * @param vam vpp API test context
12262 * @return return code
12265 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12267 unformat_input_t *input = vam->input;
12268 vl_api_lisp_add_del_remote_mapping_t *mp;
12271 //TODO: seid need remove
12272 lisp_eid_vat_t _eid, *eid = &_eid;
12273 lisp_eid_vat_t _seid, *seid = &_seid;
12274 u8 is_add = 1, del_all = 0, eid_set = 0;
12275 u32 action = ~0, p, w;
12276 ip4_address_t rloc4;
12277 ip6_address_t rloc6;
12278 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12280 memset (&rloc, 0, sizeof (rloc));
12282 /* Parse args required to build the message */
12283 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12285 if (unformat (input, "del-all"))
12289 else if (unformat (input, "del"))
12293 else if (unformat (input, "add"))
12297 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12301 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12303 //TODO: Need remove, but first must be remove from CSIT test
12305 else if (unformat (input, "vni %d", &vni))
12309 else if (unformat (input, "p %d w %d", &p, &w))
12313 errmsg ("No RLOC configured for setting priority/weight!");
12316 curr_rloc->priority = p;
12317 curr_rloc->weight = w;
12319 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12322 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12323 vec_add1 (rlocs, rloc);
12324 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12326 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12329 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12330 vec_add1 (rlocs, rloc);
12331 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12333 else if (unformat (input, "action %d", &action))
12339 clib_warning ("parse error '%U'", format_unformat_error, input);
12346 errmsg ("missing params!");
12350 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12352 errmsg ("no action set for negative map-reply!");
12356 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12357 mp->is_add = is_add;
12358 mp->vni = htonl (vni);
12359 mp->action = (u8) action;
12360 mp->eid_len = eid->len;
12361 mp->del_all = del_all;
12362 mp->eid_type = eid->type;
12363 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12365 mp->rloc_num = vec_len (rlocs);
12366 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12372 /* Wait for a reply... */
12380 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12381 * forwarding entries in data-plane accordingly.
12383 * @param vam vpp API test context
12384 * @return return code
12387 api_lisp_add_del_adjacency (vat_main_t * vam)
12389 unformat_input_t *input = vam->input;
12390 vl_api_lisp_add_del_adjacency_t *mp;
12393 ip4_address_t seid4, deid4;
12394 ip6_address_t seid6, deid6;
12395 u8 deid_mac[6] = { 0 };
12396 u8 seid_mac[6] = { 0 };
12397 u8 deid_type, seid_type;
12398 u32 seid_len = 0, deid_len = 0, len;
12401 seid_type = deid_type = (u8) ~ 0;
12403 /* Parse args required to build the message */
12404 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12406 if (unformat (input, "del"))
12410 else if (unformat (input, "add"))
12414 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12417 deid_type = 0; /* ipv4 */
12420 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12423 deid_type = 1; /* ipv6 */
12426 else if (unformat (input, "deid %U", unformat_ethernet_address,
12429 deid_type = 2; /* mac */
12431 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12434 seid_type = 0; /* ipv4 */
12437 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12440 seid_type = 1; /* ipv6 */
12443 else if (unformat (input, "seid %U", unformat_ethernet_address,
12446 seid_type = 2; /* mac */
12448 else if (unformat (input, "vni %d", &vni))
12454 errmsg ("parse error '%U'", format_unformat_error, input);
12459 if ((u8) ~ 0 == deid_type)
12461 errmsg ("missing params!");
12465 if (seid_type != deid_type)
12467 errmsg ("source and destination EIDs are of different types!");
12471 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12472 mp->is_add = is_add;
12473 mp->vni = htonl (vni);
12474 mp->seid_len = seid_len;
12475 mp->deid_len = deid_len;
12476 mp->eid_type = deid_type;
12478 switch (mp->eid_type)
12481 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12482 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12485 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12486 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12489 clib_memcpy (mp->seid, seid_mac, 6);
12490 clib_memcpy (mp->deid, deid_mac, 6);
12493 errmsg ("unknown EID type %d!", mp->eid_type);
12500 /* Wait for a reply... */
12508 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12510 unformat_input_t *input = vam->input;
12511 vl_api_lisp_gpe_add_del_iface_t *mp;
12513 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12514 u32 dp_table = 0, vni = 0;
12516 /* Parse args required to build the message */
12517 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12519 if (unformat (input, "up"))
12524 else if (unformat (input, "down"))
12529 else if (unformat (input, "table_id %d", &dp_table))
12533 else if (unformat (input, "bd_id %d", &dp_table))
12538 else if (unformat (input, "vni %d", &vni))
12546 if (action_set == 0)
12548 errmsg ("Action not set\n");
12551 if (dp_table_set == 0 || vni_set == 0)
12553 errmsg ("vni and dp_table must be set\n");
12557 /* Construct the API message */
12558 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12560 mp->is_add = is_add;
12561 mp->dp_table = dp_table;
12568 /* Wait for a reply... */
12576 * Add/del map request itr rlocs from LISP control plane and updates
12578 * @param vam vpp API test context
12579 * @return return code
12582 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12584 unformat_input_t *input = vam->input;
12585 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12587 u8 *locator_set_name = 0;
12588 u8 locator_set_name_set = 0;
12591 /* Parse args required to build the message */
12592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12594 if (unformat (input, "del"))
12598 else if (unformat (input, "%_%v%_", &locator_set_name))
12600 locator_set_name_set = 1;
12604 clib_warning ("parse error '%U'", format_unformat_error, input);
12609 if (is_add && !locator_set_name_set)
12611 errmsg ("itr-rloc is not set!");
12615 if (is_add && vec_len (locator_set_name) > 64)
12617 errmsg ("itr-rloc locator-set name too long\n");
12618 vec_free (locator_set_name);
12622 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12623 mp->is_add = is_add;
12626 clib_memcpy (mp->locator_set_name, locator_set_name,
12627 vec_len (locator_set_name));
12631 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12633 vec_free (locator_set_name);
12638 /* Wait for a reply... */
12646 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12649 vl_api_lisp_locator_dump_t *mp;
12652 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12654 mp->locator_set_index = htonl (locator_set_index);
12655 mp->filter = filter;
12660 /* Use a control ping for synchronization */
12662 vl_api_noprint_control_ping_t *mp;
12663 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12666 /* Wait for a reply... */
12671 clean_locator_set_message (vat_main_t * vam)
12673 locator_set_msg_t *ls = 0;
12675 vec_foreach (ls, vam->locator_set_msg)
12677 vec_free (ls->locator_set_name);
12680 vec_free (vam->locator_set_msg);
12684 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12686 locator_set_msg_t *ls;
12687 locator_msg_t *loc;
12689 int i = 0, ret = 0;
12691 vec_foreach (ls, vam->locator_set_msg)
12693 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12696 vec_free (vam->locator_msg);
12697 clean_locator_set_message (vam);
12701 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12702 ls->locator_set_index,
12703 vec_len (vam->locator_msg) ? "" : "\n");
12705 vec_foreach (loc, vam->locator_msg)
12709 tmp_str = format (tmp_str, "%=37s", " ");
12713 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12714 loc->sw_if_index, loc->priority, loc->weight);
12718 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12719 loc->is_ipv6 ? format_ip6_address :
12720 format_ip4_address,
12721 loc->ip_address, loc->priority, loc->weight);
12726 fformat (vam->ofp, "%s", tmp_str);
12727 vec_free (tmp_str);
12728 vec_free (vam->locator_msg);
12731 clean_locator_set_message (vam);
12737 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
12739 locator_set_msg_t *ls;
12740 locator_msg_t *loc;
12741 vat_json_node_t *node = NULL;
12742 vat_json_node_t *locator_array;
12743 vat_json_node_t *locator;
12744 struct in6_addr ip6;
12745 struct in_addr ip4;
12748 if (!vec_len (vam->locator_set_msg))
12750 /* just print [] */
12751 vat_json_init_array (&vam->json_tree);
12752 vat_json_print (vam->ofp, &vam->json_tree);
12753 vam->json_tree.type = VAT_JSON_NONE;
12757 if (VAT_JSON_ARRAY != vam->json_tree.type)
12759 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12760 vat_json_init_array (&vam->json_tree);
12763 vec_foreach (ls, vam->locator_set_msg)
12765 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12768 vec_free (ls->locator_set_name);
12769 vec_free (vam->locator_msg);
12770 vec_free (vam->locator_set_msg);
12771 vat_json_free (&vam->json_tree);
12772 vam->json_tree.type = VAT_JSON_NONE;
12776 node = vat_json_array_add (&vam->json_tree);
12777 vat_json_init_object (node);
12779 vat_json_object_add_uint (node, "locator-set-index",
12780 ls->locator_set_index);
12781 vat_json_object_add_string_copy (node, "locator-set",
12782 ls->locator_set_name);
12783 locator_array = vat_json_object_add_list (node, "locator");
12784 vec_foreach (loc, vam->locator_msg)
12786 locator = vat_json_array_add (locator_array);
12787 vat_json_init_object (locator);
12790 vat_json_object_add_uint (locator, "locator-index",
12797 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
12798 vat_json_object_add_ip6 (locator, "locator", ip6);
12802 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
12803 vat_json_object_add_ip4 (locator, "locator", ip4);
12806 vat_json_object_add_uint (locator, "priority", loc->priority);
12807 vat_json_object_add_uint (locator, "weight", loc->weight);
12810 vec_free (ls->locator_set_name);
12811 vec_free (vam->locator_msg);
12814 vat_json_print (vam->ofp, &vam->json_tree);
12815 vat_json_free (&vam->json_tree);
12816 vam->json_tree.type = VAT_JSON_NONE;
12818 vec_free (vam->locator_set_msg);
12824 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
12825 u32 * locator_set_index)
12827 locator_set_msg_t *ls;
12830 *locator_set_index = ~0;
12832 if (!vec_len (vam->locator_set_msg))
12837 vec_foreach (ls, vam->locator_set_msg)
12839 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
12841 *locator_set_index = ls->locator_set_index;
12842 vec_free (vam->locator_set_msg);
12847 vec_free (vam->locator_set_msg);
12853 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
12854 u32 * locator_set_index)
12856 vl_api_lisp_locator_set_dump_t *mp;
12859 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12863 /* Use a control ping for synchronization */
12865 vl_api_noprint_control_ping_t *mp;
12866 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12870 vam->noprint_msg = 1;
12871 /* Wait for a reply... */
12875 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
12876 vam->noprint_msg = 0;
12885 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
12892 if (!vam->json_output)
12894 fformat (vam->ofp, "%=20s%=16s%=16s\n",
12895 "locator", "priority", "weight");
12900 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
12903 if (!ret && ~0 == locator_set_index)
12908 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
12914 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
12916 vl_api_lisp_locator_set_dump_t *mp;
12919 if (!vam->json_output)
12921 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
12922 "locator-set", "locator-set-index", "locator", "priority",
12926 vam->noprint_msg = 1;
12928 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12930 mp->filter = filter;
12935 /* Use a control ping for synchronization */
12937 vl_api_noprint_control_ping_t *mp;
12938 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12942 /* Wait for a reply... */
12946 if (vam->noprint_msg)
12948 if (!vam->json_output)
12950 print_locator_in_locator_set(vam, filter);
12954 json_locator_in_locator_set(vam, filter);
12957 vam->noprint_msg = 0;
12966 api_lisp_locator_set_dump (vat_main_t * vam)
12968 unformat_input_t *input = vam->input;
12969 vam->noprint_msg = 0;
12970 u32 locator_set_index = ~0;
12971 u8 locator_set_index_set = 0;
12972 u8 *locator_set = 0;
12973 u8 locator_set_set = 0;
12977 /* Parse args required to build the message */
12978 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12980 if (unformat (input, "locator-set-index %u", &locator_set_index))
12982 locator_set_index_set = 1;
12984 else if (unformat (input, "locator-set %s", &locator_set))
12986 locator_set_set = 1;
12988 else if (unformat (input, "local"))
12992 else if (unformat (input, "remote"))
13002 if (locator_set_index_set && locator_set_set)
13004 errmsg ("use only input parameter!\n");
13008 if (locator_set_index_set || locator_set_set)
13010 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
13014 ret = lisp_locator_set_dump (vam, filter);
13017 vec_free (locator_set);
13023 api_lisp_eid_table_map_dump (vat_main_t * vam)
13025 vl_api_lisp_eid_table_map_dump_t *mp;
13028 if (!vam->json_output)
13030 fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
13033 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13038 /* Use a control ping for synchronization */
13040 vl_api_control_ping_t *mp;
13041 M (CONTROL_PING, control_ping);
13044 /* Wait for a reply... */
13052 get_locator_set (vat_main_t * vam)
13054 vl_api_lisp_locator_set_dump_t *mp;
13057 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13061 /* Use a control ping for synchronization */
13063 vl_api_noprint_control_ping_t *mp;
13064 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13068 /* Wait for a reply... */
13076 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13079 u8 *(*format_eid) (u8 *, va_list *) = 0;
13081 ASSERT (vam != NULL);
13082 ASSERT (eid_table != NULL);
13089 switch (eid_table->eid_type)
13093 format_eid = (eid_table->eid_type ? format_ip6_address :
13094 format_ip4_address);
13095 str = format (0, "[%d] %U/%d",
13096 clib_net_to_host_u32 (eid_table->vni),
13097 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13100 str = format (0, "[%d] %U",
13101 clib_net_to_host_u32 (eid_table->vni),
13102 format_ethernet_address, eid_table->eid);
13105 errmsg ("unknown EID type %d!", eid_table->eid_type);
13117 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13118 eid_table_t * eid_table)
13120 locator_set_msg_t *ls = 0;
13122 ASSERT (vam != NULL);
13123 ASSERT (eid_table != NULL);
13125 if (eid_table->is_local)
13127 vec_foreach (ls, vam->locator_set_msg)
13129 if (ls->locator_set_index == eid_table->locator_set_index)
13131 str = format (0, "local(%s)", ls->locator_set_name);
13136 str = format (0, "local(N/A)");
13140 str = format (0, "remote");
13147 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13148 eid_table_t * eid_table)
13150 locator_msg_t *loc = 0;
13151 int first_line = 1;
13153 ASSERT (vam != NULL);
13154 ASSERT (eid_table != NULL);
13156 vec_foreach (loc, vam->locator_msg)
13162 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13166 str = format (str, "%=55s%-U\n", " ",
13167 loc->is_ipv6 ? format_ip6_address :
13168 format_ip4_address, loc->ip_address);
13176 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13177 eid_table->ttl, eid_table->authoritative);
13181 str = format (str, "%-30U%-20u%-u\n",
13182 loc->is_ipv6 ? format_ip6_address :
13183 format_ip4_address,
13184 loc->ip_address, eid_table->ttl,
13185 eid_table->authoritative);
13194 print_lisp_eid_table_dump (vat_main_t * vam)
13196 eid_table_t *eid_table = 0;
13197 u8 *tmp_str = 0, *tmp_str2 = 0;
13200 ASSERT (vam != NULL);
13202 ret = get_locator_set (vam);
13205 vec_free (vam->eid_tables);
13209 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13210 "ttl", "authoritative");
13212 vec_foreach (eid_table, vam->eid_tables)
13214 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13217 vec_free (vam->locator_msg);
13218 clean_locator_set_message (vam);
13219 vec_free (vam->eid_tables);
13223 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13226 vec_free (vam->locator_msg);
13227 clean_locator_set_message (vam);
13228 vec_free (vam->eid_tables);
13232 tmp_str = format (0, "%-35s", tmp_str2);
13233 vec_free (tmp_str2);
13235 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13236 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13237 vec_free (tmp_str2);
13239 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13240 tmp_str = format (tmp_str, "%-s", tmp_str2);
13241 vec_free (tmp_str2);
13243 fformat (vam->ofp, "%s", tmp_str);
13244 vec_free (tmp_str);
13245 vec_free (vam->locator_msg);
13248 clean_locator_set_message (vam);
13249 vec_free (vam->eid_tables);
13255 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13256 eid_table_t * eid_table)
13258 locator_set_msg_t *ls = 0;
13261 ASSERT (vam != NULL);
13262 ASSERT (node != NULL);
13263 ASSERT (eid_table != NULL);
13265 if (eid_table->is_local)
13267 vec_foreach (ls, vam->locator_set_msg)
13269 if (ls->locator_set_index == eid_table->locator_set_index)
13271 vat_json_object_add_string_copy (node, "locator-set",
13272 ls->locator_set_name);
13277 s = format (0, "N/A");
13279 vat_json_object_add_string_copy (node, "locator-set", s);
13284 s = format (0, "remote");
13286 vat_json_object_add_string_copy (node, "locator-set", s);
13292 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13293 eid_table_t * eid_table)
13296 struct in6_addr ip6;
13297 struct in_addr ip4;
13299 ASSERT (vam != NULL);
13300 ASSERT (node != NULL);
13301 ASSERT (eid_table != NULL);
13303 switch (eid_table->eid_type)
13306 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13307 vat_json_object_add_ip4 (node, "eid", ip4);
13308 vat_json_object_add_uint (node, "eid-prefix-len",
13309 eid_table->eid_prefix_len);
13312 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13313 vat_json_object_add_ip6 (node, "eid", ip6);
13314 vat_json_object_add_uint (node, "eid-prefix-len",
13315 eid_table->eid_prefix_len);
13318 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13320 vat_json_object_add_string_copy (node, "eid", s);
13324 errmsg ("unknown EID type %d!", eid_table->eid_type);
13332 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13333 eid_table_t * eid_table)
13335 locator_msg_t *loc = 0;
13336 vat_json_node_t *locator_array = 0;
13337 vat_json_node_t *locator = 0;
13338 struct in6_addr ip6;
13339 struct in_addr ip4;
13341 ASSERT (vam != NULL);
13342 ASSERT (node != NULL);
13343 ASSERT (eid_table != NULL);
13345 locator_array = vat_json_object_add_list (node, "locator");
13346 vec_foreach (loc, vam->locator_msg)
13348 locator = vat_json_array_add (locator_array);
13349 vat_json_init_object (locator);
13352 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13358 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13359 vat_json_object_add_ip6 (locator, "locator", ip6);
13363 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13364 vat_json_object_add_ip4 (locator, "locator", ip4);
13371 json_lisp_eid_table_dump (vat_main_t * vam)
13373 eid_table_t *eid_table;
13374 vat_json_node_t *node = 0;
13377 ASSERT (vam != NULL);
13379 ret = get_locator_set (vam);
13382 vec_free (vam->eid_tables);
13386 if (!vec_len (vam->eid_tables))
13388 /* just print [] */
13389 vat_json_init_array (&vam->json_tree);
13390 vat_json_print (vam->ofp, &vam->json_tree);
13391 vam->json_tree.type = VAT_JSON_NONE;
13395 if (VAT_JSON_ARRAY != vam->json_tree.type)
13397 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13398 vat_json_init_array (&vam->json_tree);
13401 vec_foreach (eid_table, vam->eid_tables)
13403 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13406 vec_free (vam->locator_msg);
13407 vec_free (vam->eid_tables);
13408 clean_locator_set_message (vam);
13409 vat_json_free (&vam->json_tree);
13410 vam->json_tree.type = VAT_JSON_NONE;
13414 node = vat_json_array_add (&vam->json_tree);
13415 vat_json_init_object (node);
13417 vat_json_object_add_uint (node, "vni", eid_table->vni);
13419 json_locator_set_for_eid_table (vam, node, eid_table);
13420 ret = json_eid_for_eid_table (vam, node, eid_table);
13423 vec_free (vam->locator_msg);
13424 vec_free (vam->eid_tables);
13425 clean_locator_set_message (vam);
13426 vat_json_free (&vam->json_tree);
13427 vam->json_tree.type = VAT_JSON_NONE;
13431 json_locator_for_eid_table (vam, node, eid_table);
13433 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13434 vat_json_object_add_uint (node, "authoritative",
13435 eid_table->authoritative);
13437 vec_free (vam->locator_msg);
13440 vat_json_print (vam->ofp, &vam->json_tree);
13441 vat_json_free (&vam->json_tree);
13442 vam->json_tree.type = VAT_JSON_NONE;
13444 clean_locator_set_message (vam);
13445 vec_free (vam->eid_tables);
13451 api_lisp_eid_table_dump (vat_main_t * vam)
13453 unformat_input_t *i = vam->input;
13454 vl_api_lisp_eid_table_dump_t *mp;
13456 struct in_addr ip4;
13457 struct in6_addr ip6;
13459 u8 eid_type = ~0, eid_set = 0;
13460 u32 prefix_length = ~0, t, vni = 0;
13463 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13465 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13471 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13477 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13482 else if (unformat (i, "vni %d", &t))
13486 else if (unformat (i, "local"))
13490 else if (unformat (i, "remote"))
13496 errmsg ("parse error '%U'", format_unformat_error, i);
13501 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13503 mp->filter = filter;
13507 mp->vni = htonl (vni);
13508 mp->eid_type = eid_type;
13512 mp->prefix_length = prefix_length;
13513 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13516 mp->prefix_length = prefix_length;
13517 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13520 clib_memcpy (mp->eid, mac, sizeof (mac));
13523 errmsg ("unknown EID type %d!", eid_type);
13528 vam->noprint_msg = 1;
13533 /* Use a control ping for synchronization */
13535 vl_api_noprint_control_ping_t *mp;
13536 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13540 /* Wait for a reply... */
13544 if (vam->noprint_msg)
13546 if (!vam->json_output)
13548 vam->retval = print_lisp_eid_table_dump(vam);
13552 vam->retval = json_lisp_eid_table_dump(vam);
13555 vam->noprint_msg = 0;
13564 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13566 vl_api_lisp_gpe_tunnel_dump_t *mp;
13569 if (!vam->json_output)
13571 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13572 "%=16s%=16s%=16s%=16s%=16s\n",
13573 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13574 "Decap next", "Lisp version", "Flags", "Next protocol",
13575 "ver_res", "res", "iid");
13578 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13582 /* Use a control ping for synchronization */
13584 vl_api_control_ping_t *mp;
13585 M (CONTROL_PING, control_ping);
13588 /* Wait for a reply... */
13596 api_lisp_map_resolver_dump (vat_main_t * vam)
13598 vl_api_lisp_map_resolver_dump_t *mp;
13601 if (!vam->json_output)
13603 fformat (vam->ofp, "%=20s\n", "Map resolver");
13606 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13610 /* Use a control ping for synchronization */
13612 vl_api_control_ping_t *mp;
13613 M (CONTROL_PING, control_ping);
13616 /* Wait for a reply... */
13624 api_show_lisp_status (vat_main_t * vam)
13626 vl_api_show_lisp_status_t *mp;
13629 if (!vam->json_output)
13631 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13634 M (SHOW_LISP_STATUS, show_lisp_status);
13637 /* Wait for a reply... */
13645 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13647 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13650 if (!vam->json_output)
13652 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13655 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13658 /* Wait for a reply... */
13666 api_af_packet_create (vat_main_t * vam)
13668 unformat_input_t *i = vam->input;
13669 vl_api_af_packet_create_t *mp;
13671 u8 *host_if_name = 0;
13673 u8 random_hw_addr = 1;
13675 memset (hw_addr, 0, sizeof (hw_addr));
13677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13679 if (unformat (i, "name %s", &host_if_name))
13680 vec_add1 (host_if_name, 0);
13681 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13682 random_hw_addr = 0;
13687 if (!vec_len (host_if_name))
13689 errmsg ("host-interface name must be specified");
13693 if (vec_len (host_if_name) > 64)
13695 errmsg ("host-interface name too long");
13699 M (AF_PACKET_CREATE, af_packet_create);
13701 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13702 clib_memcpy (mp->hw_addr, hw_addr, 6);
13703 mp->use_random_hw_addr = random_hw_addr;
13704 vec_free (host_if_name);
13707 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13713 api_af_packet_delete (vat_main_t * vam)
13715 unformat_input_t *i = vam->input;
13716 vl_api_af_packet_delete_t *mp;
13718 u8 *host_if_name = 0;
13720 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13722 if (unformat (i, "name %s", &host_if_name))
13723 vec_add1 (host_if_name, 0);
13728 if (!vec_len (host_if_name))
13730 errmsg ("host-interface name must be specified");
13734 if (vec_len (host_if_name) > 64)
13736 errmsg ("host-interface name too long");
13740 M (AF_PACKET_DELETE, af_packet_delete);
13742 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13743 vec_free (host_if_name);
13752 api_policer_add_del (vat_main_t * vam)
13754 unformat_input_t *i = vam->input;
13755 vl_api_policer_add_del_t *mp;
13766 u8 color_aware = 0;
13767 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13769 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13770 conform_action.dscp = 0;
13771 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13772 exceed_action.dscp = 0;
13773 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13774 violate_action.dscp = 0;
13776 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13778 if (unformat (i, "del"))
13780 else if (unformat (i, "name %s", &name))
13781 vec_add1 (name, 0);
13782 else if (unformat (i, "cir %u", &cir))
13784 else if (unformat (i, "eir %u", &eir))
13786 else if (unformat (i, "cb %u", &cb))
13788 else if (unformat (i, "eb %u", &eb))
13790 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13793 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13796 else if (unformat (i, "type %U", unformat_policer_type, &type))
13798 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13801 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13804 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13807 else if (unformat (i, "color-aware"))
13813 if (!vec_len (name))
13815 errmsg ("policer name must be specified");
13819 if (vec_len (name) > 64)
13821 errmsg ("policer name too long");
13825 M (POLICER_ADD_DEL, policer_add_del);
13827 clib_memcpy (mp->name, name, vec_len (name));
13829 mp->is_add = is_add;
13834 mp->rate_type = rate_type;
13835 mp->round_type = round_type;
13837 mp->conform_action_type = conform_action.action_type;
13838 mp->conform_dscp = conform_action.dscp;
13839 mp->exceed_action_type = exceed_action.action_type;
13840 mp->exceed_dscp = exceed_action.dscp;
13841 mp->violate_action_type = violate_action.action_type;
13842 mp->violate_dscp = violate_action.dscp;
13843 mp->color_aware = color_aware;
13852 api_policer_dump (vat_main_t * vam)
13854 unformat_input_t *i = vam->input;
13855 vl_api_policer_dump_t *mp;
13857 u8 *match_name = 0;
13858 u8 match_name_valid = 0;
13860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13862 if (unformat (i, "name %s", &match_name))
13864 vec_add1 (match_name, 0);
13865 match_name_valid = 1;
13871 M (POLICER_DUMP, policer_dump);
13872 mp->match_name_valid = match_name_valid;
13873 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13874 vec_free (match_name);
13878 /* Use a control ping for synchronization */
13880 vl_api_control_ping_t *mp;
13881 M (CONTROL_PING, control_ping);
13884 /* Wait for a reply... */
13892 api_policer_classify_set_interface (vat_main_t * vam)
13894 unformat_input_t *i = vam->input;
13895 vl_api_policer_classify_set_interface_t *mp;
13898 int sw_if_index_set;
13899 u32 ip4_table_index = ~0;
13900 u32 ip6_table_index = ~0;
13901 u32 l2_table_index = ~0;
13904 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13906 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13907 sw_if_index_set = 1;
13908 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13909 sw_if_index_set = 1;
13910 else if (unformat (i, "del"))
13912 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13914 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13916 else if (unformat (i, "l2-table %d", &l2_table_index))
13920 clib_warning ("parse error '%U'", format_unformat_error, i);
13925 if (sw_if_index_set == 0)
13927 errmsg ("missing interface name or sw_if_index\n");
13931 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13933 mp->sw_if_index = ntohl (sw_if_index);
13934 mp->ip4_table_index = ntohl (ip4_table_index);
13935 mp->ip6_table_index = ntohl (ip6_table_index);
13936 mp->l2_table_index = ntohl (l2_table_index);
13937 mp->is_add = is_add;
13946 api_policer_classify_dump (vat_main_t * vam)
13948 unformat_input_t *i = vam->input;
13949 vl_api_policer_classify_dump_t *mp;
13951 u8 type = POLICER_CLASSIFY_N_TABLES;
13953 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13957 errmsg ("classify table type must be specified\n");
13961 if (!vam->json_output)
13963 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13966 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
13971 /* Use a control ping for synchronization */
13973 vl_api_control_ping_t *mp;
13974 M (CONTROL_PING, control_ping);
13977 /* Wait for a reply... */
13985 api_netmap_create (vat_main_t * vam)
13987 unformat_input_t *i = vam->input;
13988 vl_api_netmap_create_t *mp;
13992 u8 random_hw_addr = 1;
13996 memset (hw_addr, 0, sizeof (hw_addr));
13998 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14000 if (unformat (i, "name %s", &if_name))
14001 vec_add1 (if_name, 0);
14002 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14003 random_hw_addr = 0;
14004 else if (unformat (i, "pipe"))
14006 else if (unformat (i, "master"))
14008 else if (unformat (i, "slave"))
14014 if (!vec_len (if_name))
14016 errmsg ("interface name must be specified");
14020 if (vec_len (if_name) > 64)
14022 errmsg ("interface name too long");
14026 M (NETMAP_CREATE, netmap_create);
14028 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14029 clib_memcpy (mp->hw_addr, hw_addr, 6);
14030 mp->use_random_hw_addr = random_hw_addr;
14031 mp->is_pipe = is_pipe;
14032 mp->is_master = is_master;
14033 vec_free (if_name);
14042 api_netmap_delete (vat_main_t * vam)
14044 unformat_input_t *i = vam->input;
14045 vl_api_netmap_delete_t *mp;
14049 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14051 if (unformat (i, "name %s", &if_name))
14052 vec_add1 (if_name, 0);
14057 if (!vec_len (if_name))
14059 errmsg ("interface name must be specified");
14063 if (vec_len (if_name) > 64)
14065 errmsg ("interface name too long");
14069 M (NETMAP_DELETE, netmap_delete);
14071 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14072 vec_free (if_name);
14080 static void vl_api_mpls_gre_tunnel_details_t_handler
14081 (vl_api_mpls_gre_tunnel_details_t * mp)
14083 vat_main_t *vam = &vat_main;
14085 i32 len = ntohl (mp->nlabels);
14087 if (mp->l2_only == 0)
14089 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14090 ntohl (mp->tunnel_index),
14091 format_ip4_address, &mp->tunnel_src,
14092 format_ip4_address, &mp->tunnel_dst,
14093 format_ip4_address, &mp->intfc_address,
14094 ntohl (mp->mask_width));
14095 for (i = 0; i < len; i++)
14097 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14099 fformat (vam->ofp, "\n");
14100 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14101 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14105 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14106 ntohl (mp->tunnel_index),
14107 format_ip4_address, &mp->tunnel_src,
14108 format_ip4_address, &mp->tunnel_dst,
14109 format_ip4_address, &mp->intfc_address);
14110 for (i = 0; i < len; i++)
14112 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14114 fformat (vam->ofp, "\n");
14115 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14116 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14120 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14121 (vl_api_mpls_gre_tunnel_details_t * mp)
14123 vat_main_t *vam = &vat_main;
14124 vat_json_node_t *node = NULL;
14125 struct in_addr ip4;
14127 i32 len = ntohl (mp->nlabels);
14129 if (VAT_JSON_ARRAY != vam->json_tree.type)
14131 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14132 vat_json_init_array (&vam->json_tree);
14134 node = vat_json_array_add (&vam->json_tree);
14136 vat_json_init_object (node);
14137 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14138 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14139 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14140 vat_json_object_add_uint (node, "inner_fib_index",
14141 ntohl (mp->inner_fib_index));
14142 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14143 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14144 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14145 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14146 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14147 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14148 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14149 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14150 vat_json_object_add_uint (node, "outer_fib_index",
14151 ntohl (mp->outer_fib_index));
14152 vat_json_object_add_uint (node, "label_count", len);
14153 for (i = 0; i < len; i++)
14155 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14160 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14162 vl_api_mpls_gre_tunnel_dump_t *mp;
14166 /* Parse args required to build the message */
14167 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14169 if (!unformat (vam->input, "tunnel_index %d", &index))
14176 fformat (vam->ofp, " tunnel_index %d\n", index);
14178 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14179 mp->tunnel_index = htonl (index);
14182 /* Use a control ping for synchronization */
14184 vl_api_control_ping_t *mp;
14185 M (CONTROL_PING, control_ping);
14191 static void vl_api_mpls_eth_tunnel_details_t_handler
14192 (vl_api_mpls_eth_tunnel_details_t * mp)
14194 vat_main_t *vam = &vat_main;
14196 i32 len = ntohl (mp->nlabels);
14198 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14199 ntohl (mp->tunnel_index),
14200 format_ethernet_address, &mp->tunnel_dst_mac,
14201 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14202 for (i = 0; i < len; i++)
14204 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14206 fformat (vam->ofp, "\n");
14207 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14208 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14211 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14212 (vl_api_mpls_eth_tunnel_details_t * mp)
14214 vat_main_t *vam = &vat_main;
14215 vat_json_node_t *node = NULL;
14216 struct in_addr ip4;
14218 i32 len = ntohl (mp->nlabels);
14220 if (VAT_JSON_ARRAY != vam->json_tree.type)
14222 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14223 vat_json_init_array (&vam->json_tree);
14225 node = vat_json_array_add (&vam->json_tree);
14227 vat_json_init_object (node);
14228 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14229 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14230 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14231 vat_json_object_add_uint (node, "inner_fib_index",
14232 ntohl (mp->inner_fib_index));
14233 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14234 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14235 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14236 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14237 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14238 format (0, "%U", format_ethernet_address,
14239 &mp->tunnel_dst_mac));
14240 vat_json_object_add_uint (node, "tx_sw_if_index",
14241 ntohl (mp->tx_sw_if_index));
14242 vat_json_object_add_uint (node, "label_count", len);
14243 for (i = 0; i < len; i++)
14245 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14250 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14252 vl_api_mpls_eth_tunnel_dump_t *mp;
14256 /* Parse args required to build the message */
14257 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14259 if (!unformat (vam->input, "tunnel_index %d", &index))
14266 fformat (vam->ofp, " tunnel_index %d\n", index);
14268 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14269 mp->tunnel_index = htonl (index);
14272 /* Use a control ping for synchronization */
14274 vl_api_control_ping_t *mp;
14275 M (CONTROL_PING, control_ping);
14281 static void vl_api_mpls_fib_encap_details_t_handler
14282 (vl_api_mpls_fib_encap_details_t * mp)
14284 vat_main_t *vam = &vat_main;
14286 i32 len = ntohl (mp->nlabels);
14288 fformat (vam->ofp, "table %d, dest %U, label ",
14289 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14290 for (i = 0; i < len; i++)
14292 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14294 fformat (vam->ofp, "\n");
14297 static void vl_api_mpls_fib_encap_details_t_handler_json
14298 (vl_api_mpls_fib_encap_details_t * mp)
14300 vat_main_t *vam = &vat_main;
14301 vat_json_node_t *node = NULL;
14303 i32 len = ntohl (mp->nlabels);
14304 struct in_addr ip4;
14306 if (VAT_JSON_ARRAY != vam->json_tree.type)
14308 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14309 vat_json_init_array (&vam->json_tree);
14311 node = vat_json_array_add (&vam->json_tree);
14313 vat_json_init_object (node);
14314 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14315 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14316 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14317 vat_json_object_add_ip4 (node, "dest", ip4);
14318 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14319 vat_json_object_add_uint (node, "label_count", len);
14320 for (i = 0; i < len; i++)
14322 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14327 api_mpls_fib_encap_dump (vat_main_t * vam)
14329 vl_api_mpls_fib_encap_dump_t *mp;
14332 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14335 /* Use a control ping for synchronization */
14337 vl_api_control_ping_t *mp;
14338 M (CONTROL_PING, control_ping);
14344 static void vl_api_mpls_fib_decap_details_t_handler
14345 (vl_api_mpls_fib_decap_details_t * mp)
14347 vat_main_t *vam = &vat_main;
14350 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14351 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14352 ntohl (mp->label), ntohl (mp->s_bit));
14355 static void vl_api_mpls_fib_decap_details_t_handler_json
14356 (vl_api_mpls_fib_decap_details_t * mp)
14358 vat_main_t *vam = &vat_main;
14359 vat_json_node_t *node = NULL;
14360 struct in_addr ip4;
14362 if (VAT_JSON_ARRAY != vam->json_tree.type)
14364 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14365 vat_json_init_array (&vam->json_tree);
14367 node = vat_json_array_add (&vam->json_tree);
14369 vat_json_init_object (node);
14370 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14371 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14372 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14373 vat_json_object_add_ip4 (node, "dest", ip4);
14374 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14375 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14376 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14377 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14378 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14382 api_mpls_fib_decap_dump (vat_main_t * vam)
14384 vl_api_mpls_fib_decap_dump_t *mp;
14387 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14390 /* Use a control ping for synchronization */
14392 vl_api_control_ping_t *mp;
14393 M (CONTROL_PING, control_ping);
14400 api_classify_table_ids (vat_main_t * vam)
14402 vl_api_classify_table_ids_t *mp;
14405 /* Construct the API message */
14406 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14416 api_classify_table_by_interface (vat_main_t * vam)
14418 unformat_input_t *input = vam->input;
14419 vl_api_classify_table_by_interface_t *mp;
14422 u32 sw_if_index = ~0;
14423 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14425 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14427 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14432 if (sw_if_index == ~0)
14434 errmsg ("missing interface name or sw_if_index\n");
14438 /* Construct the API message */
14439 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14441 mp->sw_if_index = ntohl (sw_if_index);
14450 api_classify_table_info (vat_main_t * vam)
14452 unformat_input_t *input = vam->input;
14453 vl_api_classify_table_info_t *mp;
14457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14459 if (unformat (input, "table_id %d", &table_id))
14464 if (table_id == ~0)
14466 errmsg ("missing table id\n");
14470 /* Construct the API message */
14471 M (CLASSIFY_TABLE_INFO, classify_table_info);
14473 mp->table_id = ntohl (table_id);
14482 api_classify_session_dump (vat_main_t * vam)
14484 unformat_input_t *input = vam->input;
14485 vl_api_classify_session_dump_t *mp;
14489 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14491 if (unformat (input, "table_id %d", &table_id))
14496 if (table_id == ~0)
14498 errmsg ("missing table id\n");
14502 /* Construct the API message */
14503 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14505 mp->table_id = ntohl (table_id);
14508 /* Use a control ping for synchronization */
14510 vl_api_control_ping_t *mp;
14511 M (CONTROL_PING, control_ping);
14520 vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
14522 vat_main_t *vam = &vat_main;
14524 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14525 "src_address %U, fib_index %u, path_mtu %u, "
14526 "template_interval %u\n",
14527 format_ip4_address, mp->collector_address,
14528 ntohs (mp->collector_port),
14529 format_ip4_address, mp->src_address,
14530 ntohl (mp->fib_index),
14531 ntohl (mp->path_mtu), ntohl (mp->template_interval));
14534 vam->result_ready = 1;
14538 vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp)
14540 vat_main_t *vam = &vat_main;
14541 vat_json_node_t node;
14542 struct in_addr collector_address;
14543 struct in_addr src_address;
14545 vat_json_init_object (&node);
14546 clib_memcpy (&collector_address, &mp->collector_address,
14547 sizeof (collector_address));
14548 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14549 vat_json_object_add_uint (&node, "collector_port",
14550 ntohs (mp->collector_port));
14551 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14552 vat_json_object_add_ip4 (&node, "src_address", src_address);
14553 vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index));
14554 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14555 vat_json_object_add_uint (&node, "template_interval",
14556 ntohl (mp->template_interval));
14558 vat_json_print (vam->ofp, &node);
14559 vat_json_free (&node);
14561 vam->result_ready = 1;
14565 api_ipfix_dump (vat_main_t * vam)
14567 vl_api_ipfix_dump_t *mp;
14570 /* Construct the API message */
14571 M (IPFIX_DUMP, ipfix_dump);
14581 api_pg_create_interface (vat_main_t * vam)
14583 unformat_input_t *input = vam->input;
14584 vl_api_pg_create_interface_t *mp;
14588 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14590 if (unformat (input, "if_id %d", &if_id))
14597 errmsg ("missing pg interface index\n");
14601 /* Construct the API message */
14602 M (PG_CREATE_INTERFACE, pg_create_interface);
14604 mp->interface_id = ntohl (if_id);
14613 api_pg_capture (vat_main_t * vam)
14615 unformat_input_t *input = vam->input;
14616 vl_api_pg_capture_t *mp;
14622 u8 pcap_file_set = 0;
14624 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14626 if (unformat (input, "if_id %d", &if_id))
14628 else if (unformat (input, "pcap %s", &pcap_file))
14630 else if (unformat (input, "count %d", &count))
14632 else if (unformat (input, "disable"))
14639 errmsg ("missing pg interface index\n");
14642 if (pcap_file_set > 0)
14644 if (vec_len (pcap_file) > 255)
14646 errmsg ("pcap file name is too long\n");
14651 u32 name_len = vec_len (pcap_file);
14652 /* Construct the API message */
14653 M (PG_CAPTURE, pg_capture);
14655 mp->interface_id = ntohl (if_id);
14656 mp->is_enabled = enable;
14657 mp->count = ntohl (count);
14658 mp->pcap_name_length = ntohl (name_len);
14659 if (pcap_file_set != 0)
14661 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14663 vec_free (pcap_file);
14672 api_pg_enable_disable (vat_main_t * vam)
14674 unformat_input_t *input = vam->input;
14675 vl_api_pg_enable_disable_t *mp;
14679 u8 stream_name_set = 0;
14680 u8 *stream_name = 0;
14681 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14683 if (unformat (input, "stream %s", &stream_name))
14684 stream_name_set = 1;
14685 else if (unformat (input, "disable"))
14691 if (stream_name_set > 0)
14693 if (vec_len (stream_name) > 255)
14695 errmsg ("stream name too long\n");
14700 u32 name_len = vec_len (stream_name);
14701 /* Construct the API message */
14702 M (PG_ENABLE_DISABLE, pg_enable_disable);
14704 mp->is_enabled = enable;
14705 if (stream_name_set != 0)
14707 mp->stream_name_length = ntohl (name_len);
14708 clib_memcpy (mp->stream_name, stream_name, name_len);
14710 vec_free (stream_name);
14719 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14721 unformat_input_t *input = vam->input;
14722 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14725 u16 *low_ports = 0;
14726 u16 *high_ports = 0;
14729 ip4_address_t ip4_addr;
14730 ip6_address_t ip6_addr;
14738 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14740 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14746 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14751 else if (unformat (input, "vrf %d", &vrf_id))
14753 else if (unformat (input, "del"))
14755 else if (unformat (input, "port %d", &tmp))
14757 if (tmp == 0 || tmp > 65535)
14759 errmsg ("port %d out of range", tmp);
14763 this_hi = this_low + 1;
14764 vec_add1 (low_ports, this_low);
14765 vec_add1 (high_ports, this_hi);
14767 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14769 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14771 errmsg ("incorrect range parameters\n");
14775 /* Note: in debug CLI +1 is added to high before
14776 passing to real fn that does "the work"
14777 (ip_source_and_port_range_check_add_del).
14778 This fn is a wrapper around the binary API fn a
14779 control plane will call, which expects this increment
14780 to have occurred. Hence letting the binary API control
14781 plane fn do the increment for consistency between VAT
14782 and other control planes.
14785 vec_add1 (low_ports, this_low);
14786 vec_add1 (high_ports, this_hi);
14792 if (prefix_set == 0)
14794 errmsg ("<address>/<mask> not specified\n");
14800 errmsg ("VRF ID required, not specified\n");
14807 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14811 if (vec_len (low_ports) == 0)
14813 errmsg ("At least one port or port range required\n");
14817 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14818 ip_source_and_port_range_check_add_del);
14820 mp->is_add = is_add;
14825 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14830 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14833 mp->mask_length = length;
14834 mp->number_of_ranges = vec_len (low_ports);
14836 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14837 vec_free (low_ports);
14839 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14840 vec_free (high_ports);
14842 mp->vrf_id = ntohl (vrf_id);
14851 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14853 unformat_input_t *input = vam->input;
14854 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14856 u32 sw_if_index = ~0;
14858 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14859 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14862 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14864 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14866 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14868 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14870 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14872 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14874 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14876 else if (unformat (input, "del"))
14882 if (sw_if_index == ~0)
14884 errmsg ("Interface required but not specified\n");
14890 errmsg ("VRF ID required but not specified\n");
14894 if (tcp_out_vrf_id == 0
14895 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14898 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14902 /* Construct the API message */
14903 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14904 ip_source_and_port_range_check_interface_add_del);
14906 mp->sw_if_index = ntohl (sw_if_index);
14907 mp->is_add = is_add;
14908 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14909 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14910 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14911 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14916 /* Wait for a reply... */
14921 q_or_quit (vat_main_t * vam)
14923 longjmp (vam->jump_buf, 1);
14924 return 0; /* not so much */
14928 q (vat_main_t * vam)
14930 return q_or_quit (vam);
14934 quit (vat_main_t * vam)
14936 return q_or_quit (vam);
14940 comment (vat_main_t * vam)
14946 cmd_cmp (void *a1, void *a2)
14951 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
14955 help (vat_main_t * vam)
14960 unformat_input_t *i = vam->input;
14963 if (unformat (i, "%s", &name))
14967 vec_add1 (name, 0);
14969 hs = hash_get_mem (vam->help_by_name, name);
14971 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
14973 fformat (vam->ofp, "No such msg / command '%s'\n", name);
14978 fformat (vam->ofp, "Help is available for the following:\n");
14981 hash_foreach_pair (p, vam->function_by_name,
14983 vec_add1 (cmds, (u8 *)(p->key));
14987 vec_sort_with_function (cmds, cmd_cmp);
14989 for (j = 0; j < vec_len (cmds); j++)
14990 fformat (vam->ofp, "%s\n", cmds[j]);
14997 set (vat_main_t * vam)
14999 u8 *name = 0, *value = 0;
15000 unformat_input_t *i = vam->input;
15002 if (unformat (i, "%s", &name))
15004 /* The input buffer is a vector, not a string. */
15005 value = vec_dup (i->buffer);
15006 vec_delete (value, i->index, 0);
15007 /* Almost certainly has a trailing newline */
15008 if (value[vec_len (value) - 1] == '\n')
15009 value[vec_len (value) - 1] = 0;
15010 /* Make sure it's a proper string, one way or the other */
15011 vec_add1 (value, 0);
15012 (void) clib_macro_set_value (&vam->macro_main,
15013 (char *) name, (char *) value);
15016 errmsg ("usage: set <name> <value>\n");
15024 unset (vat_main_t * vam)
15028 if (unformat (vam->input, "%s", &name))
15029 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15030 errmsg ("unset: %s wasn't set\n", name);
15043 macro_sort_cmp (void *a1, void *a2)
15045 macro_sort_t *s1 = a1;
15046 macro_sort_t *s2 = a2;
15048 return strcmp ((char *) (s1->name), (char *) (s2->name));
15052 dump_macro_table (vat_main_t * vam)
15054 macro_sort_t *sort_me = 0, *sm;
15059 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15061 vec_add2 (sort_me, sm, 1);
15062 sm->name = (u8 *)(p->key);
15063 sm->value = (u8 *) (p->value[0]);
15067 vec_sort_with_function (sort_me, macro_sort_cmp);
15069 if (vec_len (sort_me))
15070 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15072 fformat (vam->ofp, "The macro table is empty...\n");
15074 for (i = 0; i < vec_len (sort_me); i++)
15075 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15080 dump_node_table (vat_main_t * vam)
15083 vlib_node_t *node, *next_node;
15085 if (vec_len (vam->graph_nodes) == 0)
15087 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15091 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15093 node = vam->graph_nodes[i];
15094 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15095 for (j = 0; j < vec_len (node->next_nodes); j++)
15097 if (node->next_nodes[j] != ~0)
15099 next_node = vam->graph_nodes[node->next_nodes[j]];
15100 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15108 search_node_table (vat_main_t * vam)
15110 unformat_input_t *line_input = vam->input;
15113 vlib_node_t *node, *next_node;
15116 if (vam->graph_node_index_by_name == 0)
15118 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15122 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15124 if (unformat (line_input, "%s", &node_to_find))
15126 vec_add1 (node_to_find, 0);
15127 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15130 fformat (vam->ofp, "%s not found...\n", node_to_find);
15133 node = vam->graph_nodes[p[0]];
15134 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15135 for (j = 0; j < vec_len (node->next_nodes); j++)
15137 if (node->next_nodes[j] != ~0)
15139 next_node = vam->graph_nodes[node->next_nodes[j]];
15140 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15147 clib_warning ("parse error '%U'", format_unformat_error,
15153 vec_free (node_to_find);
15162 script (vat_main_t * vam)
15165 char *save_current_file;
15166 unformat_input_t save_input;
15167 jmp_buf save_jump_buf;
15168 u32 save_line_number;
15170 FILE *new_fp, *save_ifp;
15172 if (unformat (vam->input, "%s", &s))
15174 new_fp = fopen ((char *) s, "r");
15177 errmsg ("Couldn't open script file %s\n", s);
15184 errmsg ("Missing script name\n");
15188 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15189 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15190 save_ifp = vam->ifp;
15191 save_line_number = vam->input_line_number;
15192 save_current_file = (char *) vam->current_file;
15194 vam->input_line_number = 0;
15196 vam->current_file = s;
15199 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15200 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15201 vam->ifp = save_ifp;
15202 vam->input_line_number = save_line_number;
15203 vam->current_file = (u8 *) save_current_file;
15210 echo (vat_main_t * vam)
15212 fformat (vam->ofp, "%v", vam->input->buffer);
15216 /* List of API message constructors, CLI names map to api_xxx */
15217 #define foreach_vpe_api_msg \
15218 _(create_loopback,"[mac <mac-addr>]") \
15219 _(sw_interface_dump,"") \
15220 _(sw_interface_set_flags, \
15221 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15222 _(sw_interface_add_del_address, \
15223 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15224 _(sw_interface_set_table, \
15225 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15226 _(sw_interface_set_vpath, \
15227 "<intfc> | sw_if_index <id> enable | disable") \
15228 _(sw_interface_set_l2_xconnect, \
15229 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15230 "enable | disable") \
15231 _(sw_interface_set_l2_bridge, \
15232 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15233 "[shg <split-horizon-group>] [bvi]\n" \
15234 "enable | disable") \
15235 _(bridge_domain_add_del, \
15236 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15237 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15239 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15241 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15243 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15245 "tapname <name> mac <mac-addr> | random-mac") \
15247 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15249 "<vpp-if-name> | sw_if_index <id>") \
15250 _(sw_interface_tap_dump, "") \
15251 _(ip_add_del_route, \
15252 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15253 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15254 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15255 "[multipath] [count <n>]") \
15256 _(proxy_arp_add_del, \
15257 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15258 _(proxy_arp_intfc_enable_disable, \
15259 "<intfc> | sw_if_index <id> enable | disable") \
15260 _(mpls_add_del_encap, \
15261 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15262 _(mpls_add_del_decap, \
15263 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15264 _(mpls_gre_add_del_tunnel, \
15265 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15266 "adj <ip4-address>/<mask-width> [del]") \
15267 _(sw_interface_set_unnumbered, \
15268 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15269 _(ip_neighbor_add_del, \
15270 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15271 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15272 _(reset_vrf, "vrf <id> [ipv6]") \
15273 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15274 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15275 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15276 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15277 "[outer_vlan_id_any][inner_vlan_id_any]") \
15278 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15279 _(reset_fib, "vrf <n> [ipv6]") \
15280 _(dhcp_proxy_config, \
15281 "svr <v46-address> src <v46-address>\n" \
15282 "insert-cid <n> [del]") \
15283 _(dhcp_proxy_config_2, \
15284 "svr <v46-address> src <v46-address>\n" \
15285 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15286 _(dhcp_proxy_set_vss, \
15287 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15288 _(dhcp_client_config, \
15289 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15290 _(set_ip_flow_hash, \
15291 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15292 _(sw_interface_ip6_enable_disable, \
15293 "<intfc> | sw_if_index <id> enable | disable") \
15294 _(sw_interface_ip6_set_link_local_address, \
15295 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15296 _(sw_interface_ip6nd_ra_prefix, \
15297 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15298 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15299 "[nolink] [isno]") \
15300 _(sw_interface_ip6nd_ra_config, \
15301 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15302 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15303 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15304 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15305 _(l2_patch_add_del, \
15306 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15307 "enable | disable") \
15308 _(mpls_ethernet_add_del_tunnel, \
15309 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15310 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15311 _(mpls_ethernet_add_del_tunnel_2, \
15312 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15313 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15314 _(sr_tunnel_add_del, \
15315 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15316 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15317 "[policy <policy_name>]") \
15318 _(sr_policy_add_del, \
15319 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15320 _(sr_multicast_map_add_del, \
15321 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15322 _(classify_add_del_table, \
15323 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15324 "[del] mask <mask-value>\n" \
15325 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15326 _(classify_add_del_session, \
15327 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15328 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15329 " [l3 [ip4|ip6]]") \
15330 _(classify_set_interface_ip_table, \
15331 "<intfc> | sw_if_index <nn> table <nn>") \
15332 _(classify_set_interface_l2_tables, \
15333 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15334 " [other-table <nn>]") \
15335 _(get_node_index, "node <node-name") \
15336 _(add_node_next, "node <node-name> next <next-node-name>") \
15337 _(l2tpv3_create_tunnel, \
15338 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15339 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15340 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15341 _(l2tpv3_set_tunnel_cookies, \
15342 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15343 "[new_remote_cookie <nn>]\n") \
15344 _(l2tpv3_interface_enable_disable, \
15345 "<intfc> | sw_if_index <nn> enable | disable") \
15346 _(l2tpv3_set_lookup_key, \
15347 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15348 _(sw_if_l2tpv3_tunnel_dump, "") \
15349 _(vxlan_add_del_tunnel, \
15350 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15351 " [decap-next l2|ip4|ip6] [del]") \
15352 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15353 _(gre_add_del_tunnel, \
15354 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15355 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15356 _(l2_fib_clear_table, "") \
15357 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15358 _(l2_interface_vlan_tag_rewrite, \
15359 "<intfc> | sw_if_index <nn> \n" \
15360 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15361 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15362 _(create_vhost_user_if, \
15363 "socket <filename> [server] [renumber <dev_instance>] " \
15364 "[mac <mac_address>]") \
15365 _(modify_vhost_user_if, \
15366 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15367 "[server] [renumber <dev_instance>]") \
15368 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15369 _(sw_interface_vhost_user_dump, "") \
15370 _(show_version, "") \
15371 _(vxlan_gpe_add_del_tunnel, \
15372 "local <addr> remote <addr> vni <nn>\n" \
15373 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15374 "[next-ethernet] [next-nsh]\n") \
15375 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15376 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15377 _(interface_name_renumber, \
15378 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15379 _(input_acl_set_interface, \
15380 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15381 " [l2-table <nn>] [del]") \
15382 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15383 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15384 _(ip_dump, "ipv4 | ipv6") \
15385 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15386 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15388 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15389 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15390 " integ_alg <alg> integ_key <hex>") \
15391 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15392 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15393 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15394 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15395 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15396 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15397 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15398 "(auth_data 0x<data> | auth_data <data>)") \
15399 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15400 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15401 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15402 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15403 "(local|remote)") \
15404 _(ikev2_set_local_key, "file <absolute_file_path>") \
15405 _(delete_loopback,"sw_if_index <nn>") \
15406 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15407 _(map_add_domain, \
15408 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15409 "ip6-src <ip6addr> " \
15410 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15411 _(map_del_domain, "index <n>") \
15412 _(map_add_del_rule, \
15413 "index <n> psid <n> dst <ip6addr> [del]") \
15414 _(map_domain_dump, "") \
15415 _(map_rule_dump, "index <map-domain>") \
15416 _(want_interface_events, "enable|disable") \
15417 _(want_stats,"enable|disable") \
15418 _(get_first_msg_id, "client <name>") \
15419 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15420 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15421 "fib-id <nn> [ip4][ip6][default]") \
15422 _(get_node_graph, " ") \
15423 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15424 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
15425 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
15426 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
15427 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
15428 " vrf_id <nn> add | pop | none") \
15429 _(trace_profile_del, "") \
15430 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15431 " sw_if_index <sw_if_index> p <priority> " \
15432 "w <weight>] [del]") \
15433 _(lisp_add_del_locator, "locator-set <locator_name> " \
15434 "iface <intf> | sw_if_index <sw_if_index> " \
15435 "p <priority> w <weight> [del]") \
15436 _(lisp_add_del_local_eid,"vni <vni> eid " \
15437 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15438 "locator-set <locator_name> [del]") \
15439 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15440 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15441 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15442 _(lisp_gpe_enable_disable, "enable|disable") \
15443 _(lisp_enable_disable, "enable|disable") \
15444 _(lisp_gpe_add_del_iface, "up|down") \
15445 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
15446 "rloc <locator> p <prio> " \
15447 "w <weight> [rloc <loc> ... ] " \
15448 "action <action> [del-all]") \
15449 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15450 "<src-eid> rloc <locator> p <prio> w <weight>"\
15451 "[rloc <loc> ... ] action <action>") \
15452 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15453 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15454 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15455 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
15456 "locator-set <loc-set-name>] [local | remote]")\
15457 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15458 "[local] | [remote]") \
15459 _(lisp_eid_table_map_dump, "") \
15460 _(lisp_gpe_tunnel_dump, "") \
15461 _(lisp_map_resolver_dump, "") \
15462 _(show_lisp_status, "") \
15463 _(lisp_get_map_request_itr_rlocs, "") \
15464 _(show_lisp_pitr, "") \
15465 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15466 _(af_packet_delete, "name <host interface name>") \
15467 _(policer_add_del, "name <policer name> <params> [del]") \
15468 _(policer_dump, "[name <policer name>]") \
15469 _(policer_classify_set_interface, \
15470 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15471 " [l2-table <nn>] [del]") \
15472 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15473 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15474 "[master|slave]") \
15475 _(netmap_delete, "name <interface name>") \
15476 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15477 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15478 _(mpls_fib_encap_dump, "") \
15479 _(mpls_fib_decap_dump, "") \
15480 _(classify_table_ids, "") \
15481 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15482 _(classify_table_info, "table_id <nn>") \
15483 _(classify_session_dump, "table_id <nn>") \
15484 _(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
15485 "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
15486 "[template_interval <nn>]") \
15487 _(ipfix_dump, "") \
15488 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15489 _(pg_create_interface, "if_id <nn>") \
15490 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15491 _(pg_enable_disable, "[stream <id>] disable") \
15492 _(ip_source_and_port_range_check_add_del, \
15493 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15494 _(ip_source_and_port_range_check_interface_add_del, \
15495 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15496 "[udp-in-vrf <id>] [udp-out-vrf <id>]")
15498 /* List of command functions, CLI names map directly to functions */
15499 #define foreach_cli_function \
15500 _(comment, "usage: comment <ignore-rest-of-line>") \
15501 _(dump_interface_table, "usage: dump_interface_table") \
15502 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15503 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15504 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15505 _(dump_stats_table, "usage: dump_stats_table") \
15506 _(dump_macro_table, "usage: dump_macro_table ") \
15507 _(dump_node_table, "usage: dump_node_table") \
15508 _(echo, "usage: echo <message>") \
15509 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15510 _(help, "usage: help") \
15511 _(q, "usage: quit") \
15512 _(quit, "usage: quit") \
15513 _(search_node_table, "usage: search_node_table <name>...") \
15514 _(set, "usage: set <variable-name> <value>") \
15515 _(script, "usage: script <file-name>") \
15516 _(unset, "usage: unset <variable-name>")
15519 static void vl_api_##n##_t_handler_uni \
15520 (vl_api_##n##_t * mp) \
15522 vat_main_t * vam = &vat_main; \
15523 if (vam->json_output) { \
15524 vl_api_##n##_t_handler_json(mp); \
15526 vl_api_##n##_t_handler(mp); \
15529 foreach_vpe_api_reply_msg;
15533 vat_api_hookup (vat_main_t * vam)
15536 vl_msg_api_set_handlers(VL_API_##N, #n, \
15537 vl_api_##n##_t_handler_uni, \
15539 vl_api_##n##_t_endian, \
15540 vl_api_##n##_t_print, \
15541 sizeof(vl_api_##n##_t), 1);
15542 foreach_vpe_api_reply_msg;
15545 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15547 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15549 vam->function_by_name = hash_create_string (0, sizeof (uword));
15551 vam->help_by_name = hash_create_string (0, sizeof (uword));
15553 /* API messages we can send */
15554 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15555 foreach_vpe_api_msg;
15559 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15560 foreach_vpe_api_msg;
15563 /* CLI functions */
15564 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15565 foreach_cli_function;
15569 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15570 foreach_cli_function;
15574 #undef vl_api_version
15575 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15576 #include <vpp-api/vpe.api.h>
15577 #undef vl_api_version
15580 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15583 * Send the main API signature in slot 0. This bit of code must
15584 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15586 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15590 * fd.io coding-style-patch-verification: ON
15593 * eval: (c-set-style "gnu")