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));
3192 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3193 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3195 vat_main_t *vam = &vat_main;
3196 i32 retval = ntohl (mp->retval);
3197 if (vam->async_mode)
3199 vam->async_errors += (retval < 0);
3203 vam->retval = retval;
3204 vam->sw_if_index = ntohl (mp->sw_if_index);
3205 vam->result_ready = 1;
3209 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3210 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3212 vat_main_t *vam = &vat_main;
3213 vat_json_node_t node;
3215 vat_json_init_object (&node);
3216 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3217 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3219 vat_json_print (vam->ofp, &node);
3220 vat_json_free (&node);
3222 vam->retval = ntohl (mp->retval);
3223 vam->result_ready = 1;
3226 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3227 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3228 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3229 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3232 * Generate boilerplate reply handlers, which
3233 * dig the return value out of the xxx_reply_t API message,
3234 * stick it into vam->retval, and set vam->result_ready
3236 * Could also do this by pointing N message decode slots at
3237 * a single function, but that could break in subtle ways.
3240 #define foreach_standard_reply_retval_handler \
3241 _(sw_interface_set_flags_reply) \
3242 _(sw_interface_add_del_address_reply) \
3243 _(sw_interface_set_table_reply) \
3244 _(sw_interface_set_vpath_reply) \
3245 _(sw_interface_set_l2_bridge_reply) \
3246 _(bridge_domain_add_del_reply) \
3247 _(sw_interface_set_l2_xconnect_reply) \
3248 _(l2fib_add_del_reply) \
3249 _(ip_add_del_route_reply) \
3250 _(proxy_arp_add_del_reply) \
3251 _(proxy_arp_intfc_enable_disable_reply) \
3252 _(mpls_add_del_encap_reply) \
3253 _(mpls_add_del_decap_reply) \
3254 _(mpls_ethernet_add_del_tunnel_2_reply) \
3255 _(sw_interface_set_unnumbered_reply) \
3256 _(ip_neighbor_add_del_reply) \
3257 _(reset_vrf_reply) \
3258 _(oam_add_del_reply) \
3259 _(reset_fib_reply) \
3260 _(dhcp_proxy_config_reply) \
3261 _(dhcp_proxy_config_2_reply) \
3262 _(dhcp_proxy_set_vss_reply) \
3263 _(dhcp_client_config_reply) \
3264 _(set_ip_flow_hash_reply) \
3265 _(sw_interface_ip6_enable_disable_reply) \
3266 _(sw_interface_ip6_set_link_local_address_reply) \
3267 _(sw_interface_ip6nd_ra_prefix_reply) \
3268 _(sw_interface_ip6nd_ra_config_reply) \
3269 _(set_arp_neighbor_limit_reply) \
3270 _(l2_patch_add_del_reply) \
3271 _(sr_tunnel_add_del_reply) \
3272 _(sr_policy_add_del_reply) \
3273 _(sr_multicast_map_add_del_reply) \
3274 _(classify_add_del_session_reply) \
3275 _(classify_set_interface_ip_table_reply) \
3276 _(classify_set_interface_l2_tables_reply) \
3277 _(l2tpv3_set_tunnel_cookies_reply) \
3278 _(l2tpv3_interface_enable_disable_reply) \
3279 _(l2tpv3_set_lookup_key_reply) \
3280 _(l2_fib_clear_table_reply) \
3281 _(l2_interface_efp_filter_reply) \
3282 _(l2_interface_vlan_tag_rewrite_reply) \
3283 _(modify_vhost_user_if_reply) \
3284 _(delete_vhost_user_if_reply) \
3285 _(want_ip4_arp_events_reply) \
3286 _(input_acl_set_interface_reply) \
3287 _(ipsec_spd_add_del_reply) \
3288 _(ipsec_interface_add_del_spd_reply) \
3289 _(ipsec_spd_add_del_entry_reply) \
3290 _(ipsec_sad_add_del_entry_reply) \
3291 _(ipsec_sa_set_key_reply) \
3292 _(ikev2_profile_add_del_reply) \
3293 _(ikev2_profile_set_auth_reply) \
3294 _(ikev2_profile_set_id_reply) \
3295 _(ikev2_profile_set_ts_reply) \
3296 _(ikev2_set_local_key_reply) \
3297 _(delete_loopback_reply) \
3298 _(bd_ip_mac_add_del_reply) \
3299 _(map_del_domain_reply) \
3300 _(map_add_del_rule_reply) \
3301 _(want_interface_events_reply) \
3302 _(want_stats_reply) \
3303 _(cop_interface_enable_disable_reply) \
3304 _(cop_whitelist_enable_disable_reply) \
3305 _(sw_interface_clear_stats_reply) \
3306 _(trace_profile_add_reply) \
3307 _(trace_profile_apply_reply) \
3308 _(trace_profile_del_reply) \
3309 _(lisp_add_del_locator_set_reply) \
3310 _(lisp_add_del_locator_reply) \
3311 _(lisp_add_del_local_eid_reply) \
3312 _(lisp_add_del_remote_mapping_reply) \
3313 _(lisp_add_del_adjacency_reply) \
3314 _(lisp_gpe_add_del_fwd_entry_reply) \
3315 _(lisp_add_del_map_resolver_reply) \
3316 _(lisp_gpe_enable_disable_reply) \
3317 _(lisp_gpe_add_del_iface_reply) \
3318 _(lisp_enable_disable_reply) \
3319 _(lisp_pitr_set_locator_set_reply) \
3320 _(lisp_add_del_map_request_itr_rlocs_reply) \
3321 _(lisp_eid_table_add_del_map_reply) \
3322 _(vxlan_gpe_add_del_tunnel_reply) \
3323 _(af_packet_delete_reply) \
3324 _(policer_classify_set_interface_reply) \
3325 _(netmap_create_reply) \
3326 _(netmap_delete_reply) \
3327 _(ipfix_enable_reply) \
3328 _(pg_capture_reply) \
3329 _(pg_enable_disable_reply) \
3330 _(ip_source_and_port_range_check_add_del_reply) \
3331 _(ip_source_and_port_range_check_interface_add_del_reply)
3334 static void vl_api_##n##_t_handler \
3335 (vl_api_##n##_t * mp) \
3337 vat_main_t * vam = &vat_main; \
3338 i32 retval = ntohl(mp->retval); \
3339 if (vam->async_mode) { \
3340 vam->async_errors += (retval < 0); \
3342 vam->retval = retval; \
3343 vam->result_ready = 1; \
3346 foreach_standard_reply_retval_handler;
3350 static void vl_api_##n##_t_handler_json \
3351 (vl_api_##n##_t * mp) \
3353 vat_main_t * vam = &vat_main; \
3354 vat_json_node_t node; \
3355 vat_json_init_object(&node); \
3356 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3357 vat_json_print(vam->ofp, &node); \
3358 vam->retval = ntohl(mp->retval); \
3359 vam->result_ready = 1; \
3361 foreach_standard_reply_retval_handler;
3365 * Table of message reply handlers, must include boilerplate handlers
3369 #define foreach_vpe_api_reply_msg \
3370 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3371 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3372 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3373 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3374 _(CONTROL_PING_REPLY, control_ping_reply) \
3375 _(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
3376 _(CLI_REPLY, cli_reply) \
3377 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3378 sw_interface_add_del_address_reply) \
3379 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3380 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3381 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3382 sw_interface_set_l2_xconnect_reply) \
3383 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3384 sw_interface_set_l2_bridge_reply) \
3385 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3386 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3387 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3388 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3389 _(L2_FLAGS_REPLY, l2_flags_reply) \
3390 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3391 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3392 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3393 _(TAP_DELETE_REPLY, tap_delete_reply) \
3394 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3395 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3396 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3397 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3398 proxy_arp_intfc_enable_disable_reply) \
3399 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3400 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3401 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3402 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3403 mpls_ethernet_add_del_tunnel_reply) \
3404 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3405 mpls_ethernet_add_del_tunnel_2_reply) \
3406 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3407 sw_interface_set_unnumbered_reply) \
3408 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3409 _(RESET_VRF_REPLY, reset_vrf_reply) \
3410 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3411 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3412 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3413 _(RESET_FIB_REPLY, reset_fib_reply) \
3414 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3415 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3416 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3417 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3418 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3419 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3420 sw_interface_ip6_enable_disable_reply) \
3421 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3422 sw_interface_ip6_set_link_local_address_reply) \
3423 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3424 sw_interface_ip6nd_ra_prefix_reply) \
3425 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3426 sw_interface_ip6nd_ra_config_reply) \
3427 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3428 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3429 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3430 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3431 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3432 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3433 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3434 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3435 classify_set_interface_ip_table_reply) \
3436 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3437 classify_set_interface_l2_tables_reply) \
3438 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3439 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3440 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3441 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3442 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3443 l2tpv3_interface_enable_disable_reply) \
3444 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3445 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3446 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3447 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3448 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3449 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3450 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3451 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3452 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3453 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3454 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3455 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3456 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3457 _(SHOW_VERSION_REPLY, show_version_reply) \
3458 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3459 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3460 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3461 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3462 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3463 _(IP4_ARP_EVENT, ip4_arp_event) \
3464 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3465 _(IP_ADDRESS_DETAILS, ip_address_details) \
3466 _(IP_DETAILS, ip_details) \
3467 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3468 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3469 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3470 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3471 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3472 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3473 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3474 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3475 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3476 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3477 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3478 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3479 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3480 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3481 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3482 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3483 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3484 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3485 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3486 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3487 _(MAP_RULE_DETAILS, map_rule_details) \
3488 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3489 _(WANT_STATS_REPLY, want_stats_reply) \
3490 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3491 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3492 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3493 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3494 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3495 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
3496 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
3497 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
3498 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3499 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3500 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3501 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3502 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3503 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3504 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3505 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3506 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3507 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3508 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3509 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3510 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3511 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3512 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3513 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3514 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3515 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3516 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3517 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3518 lisp_add_del_map_request_itr_rlocs_reply) \
3519 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3520 lisp_get_map_request_itr_rlocs_reply) \
3521 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3522 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3523 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3524 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3525 _(POLICER_DETAILS, policer_details) \
3526 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3527 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3528 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3529 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3530 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3531 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3532 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3533 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3534 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3535 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3536 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3537 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3538 _(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
3539 _(IPFIX_DETAILS, ipfix_details) \
3540 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3541 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3542 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3543 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3544 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3545 ip_source_and_port_range_check_add_del_reply) \
3546 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3547 ip_source_and_port_range_check_interface_add_del_reply) \
3548 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3549 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details)
3551 /* M: construct, but don't yet send a message */
3555 vam->result_ready = 0; \
3556 mp = vl_msg_api_alloc(sizeof(*mp)); \
3557 memset (mp, 0, sizeof (*mp)); \
3558 mp->_vl_msg_id = ntohs (VL_API_##T); \
3559 mp->client_index = vam->my_client_index; \
3564 vam->result_ready = 0; \
3565 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3566 memset (mp, 0, sizeof (*mp)); \
3567 mp->_vl_msg_id = ntohs (VL_API_##T); \
3568 mp->client_index = vam->my_client_index; \
3572 /* S: send a message */
3573 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3575 /* W: wait for results, with timeout */
3578 timeout = vat_time_now (vam) + 1.0; \
3580 while (vat_time_now (vam) < timeout) { \
3581 if (vam->result_ready == 1) { \
3582 return (vam->retval); \
3588 /* W2: wait for results, with timeout */
3591 timeout = vat_time_now (vam) + 1.0; \
3593 while (vat_time_now (vam) < timeout) { \
3594 if (vam->result_ready == 1) { \
3596 return (vam->retval); \
3602 /* W_L: wait for results, with timeout */
3605 timeout = vat_time_now (vam) + 1.0; \
3607 while (vat_time_now (vam) < timeout) { \
3608 if (vam->result_ready == 1) { \
3610 return (vam->retval); \
3613 vam->noprint_msg = 0; \
3624 #define STR_VTR_OP_CASE(op) \
3625 case L2_VTR_ ## op: \
3629 str_vtr_op (u32 vtr_op)
3633 STR_VTR_OP_CASE (DISABLED);
3634 STR_VTR_OP_CASE (PUSH_1);
3635 STR_VTR_OP_CASE (PUSH_2);
3636 STR_VTR_OP_CASE (POP_1);
3637 STR_VTR_OP_CASE (POP_2);
3638 STR_VTR_OP_CASE (TRANSLATE_1_1);
3639 STR_VTR_OP_CASE (TRANSLATE_1_2);
3640 STR_VTR_OP_CASE (TRANSLATE_2_1);
3641 STR_VTR_OP_CASE (TRANSLATE_2_2);
3648 dump_sub_interface_table (vat_main_t * vam)
3650 const sw_interface_subif_t *sub = NULL;
3652 if (vam->json_output)
3655 ("JSON output supported only for VPE API calls and dump_stats_table");
3660 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3661 "Interface", "sw_if_index",
3662 "sub id", "dot1ad", "tags", "outer id",
3663 "inner id", "exact", "default", "outer any", "inner any");
3665 vec_foreach (sub, vam->sw_if_subif_table)
3668 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3669 sub->interface_name,
3671 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3672 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3673 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3674 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3675 if (sub->vtr_op != L2_VTR_DISABLED)
3678 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3679 "tag1: %d tag2: %d ]\n",
3680 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3681 sub->vtr_tag1, sub->vtr_tag2);
3689 name_sort_cmp (void *a1, void *a2)
3691 name_sort_t *n1 = a1;
3692 name_sort_t *n2 = a2;
3694 return strcmp ((char *) n1->name, (char *) n2->name);
3698 dump_interface_table (vat_main_t * vam)
3701 name_sort_t *nses = 0, *ns;
3703 if (vam->json_output)
3706 ("JSON output supported only for VPE API calls and dump_stats_table");
3711 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3713 vec_add2 (nses, ns, 1);
3714 ns->name = (u8 *)(p->key);
3715 ns->value = (u32) p->value[0];
3719 vec_sort_with_function (nses, name_sort_cmp);
3721 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3722 vec_foreach (ns, nses)
3724 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3731 dump_ip_table (vat_main_t * vam, int is_ipv6)
3733 const ip_details_t *det = NULL;
3734 const ip_address_details_t *address = NULL;
3737 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3739 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3746 fformat (vam->ofp, "%-12d\n", i);
3748 " %-30s%-13s\n", "Address", "Prefix length");
3753 vec_foreach (address, det->addr)
3757 is_ipv6 ? format_ip6_address : format_ip4_address,
3758 address->ip, address->prefix_length);
3766 dump_ipv4_table (vat_main_t * vam)
3768 if (vam->json_output)
3771 ("JSON output supported only for VPE API calls and dump_stats_table");
3775 return dump_ip_table (vam, 0);
3779 dump_ipv6_table (vat_main_t * vam)
3781 if (vam->json_output)
3784 ("JSON output supported only for VPE API calls and dump_stats_table");
3788 return dump_ip_table (vam, 1);
3792 counter_type_to_str (u8 counter_type, u8 is_combined)
3796 switch (counter_type)
3798 case VNET_INTERFACE_COUNTER_DROP:
3800 case VNET_INTERFACE_COUNTER_PUNT:
3802 case VNET_INTERFACE_COUNTER_IP4:
3804 case VNET_INTERFACE_COUNTER_IP6:
3806 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3808 case VNET_INTERFACE_COUNTER_RX_MISS:
3810 case VNET_INTERFACE_COUNTER_RX_ERROR:
3812 case VNET_INTERFACE_COUNTER_TX_ERROR:
3815 return "INVALID-COUNTER-TYPE";
3820 switch (counter_type)
3822 case VNET_INTERFACE_COUNTER_RX:
3824 case VNET_INTERFACE_COUNTER_TX:
3827 return "INVALID-COUNTER-TYPE";
3833 dump_stats_table (vat_main_t * vam)
3835 vat_json_node_t node;
3836 vat_json_node_t *msg_array;
3837 vat_json_node_t *msg;
3838 vat_json_node_t *counter_array;
3839 vat_json_node_t *counter;
3840 interface_counter_t c;
3842 ip4_fib_counter_t *c4;
3843 ip6_fib_counter_t *c6;
3846 if (!vam->json_output)
3848 clib_warning ("dump_stats_table supported only in JSON format");
3852 vat_json_init_object (&node);
3854 /* interface counters */
3855 msg_array = vat_json_object_add (&node, "interface_counters");
3856 vat_json_init_array (msg_array);
3857 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3859 msg = vat_json_array_add (msg_array);
3860 vat_json_init_object (msg);
3861 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3862 (u8 *) counter_type_to_str (i, 0));
3863 vat_json_object_add_int (msg, "is_combined", 0);
3864 counter_array = vat_json_object_add (msg, "data");
3865 vat_json_init_array (counter_array);
3866 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3868 packets = vam->simple_interface_counters[i][j];
3869 vat_json_array_add_uint (counter_array, packets);
3872 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3874 msg = vat_json_array_add (msg_array);
3875 vat_json_init_object (msg);
3876 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3877 (u8 *) counter_type_to_str (i, 1));
3878 vat_json_object_add_int (msg, "is_combined", 1);
3879 counter_array = vat_json_object_add (msg, "data");
3880 vat_json_init_array (counter_array);
3881 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3883 c = vam->combined_interface_counters[i][j];
3884 counter = vat_json_array_add (counter_array);
3885 vat_json_init_object (counter);
3886 vat_json_object_add_uint (counter, "packets", c.packets);
3887 vat_json_object_add_uint (counter, "bytes", c.bytes);
3891 /* ip4 fib counters */
3892 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
3893 vat_json_init_array (msg_array);
3894 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
3896 msg = vat_json_array_add (msg_array);
3897 vat_json_init_object (msg);
3898 vat_json_object_add_uint (msg, "vrf_id",
3899 vam->ip4_fib_counters_vrf_id_by_index[i]);
3900 counter_array = vat_json_object_add (msg, "c");
3901 vat_json_init_array (counter_array);
3902 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
3904 counter = vat_json_array_add (counter_array);
3905 vat_json_init_object (counter);
3906 c4 = &vam->ip4_fib_counters[i][j];
3907 vat_json_object_add_ip4 (counter, "address", c4->address);
3908 vat_json_object_add_uint (counter, "address_length",
3909 c4->address_length);
3910 vat_json_object_add_uint (counter, "packets", c4->packets);
3911 vat_json_object_add_uint (counter, "bytes", c4->bytes);
3915 /* ip6 fib counters */
3916 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
3917 vat_json_init_array (msg_array);
3918 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
3920 msg = vat_json_array_add (msg_array);
3921 vat_json_init_object (msg);
3922 vat_json_object_add_uint (msg, "vrf_id",
3923 vam->ip6_fib_counters_vrf_id_by_index[i]);
3924 counter_array = vat_json_object_add (msg, "c");
3925 vat_json_init_array (counter_array);
3926 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
3928 counter = vat_json_array_add (counter_array);
3929 vat_json_init_object (counter);
3930 c6 = &vam->ip6_fib_counters[i][j];
3931 vat_json_object_add_ip6 (counter, "address", c6->address);
3932 vat_json_object_add_uint (counter, "address_length",
3933 c6->address_length);
3934 vat_json_object_add_uint (counter, "packets", c6->packets);
3935 vat_json_object_add_uint (counter, "bytes", c6->bytes);
3939 vat_json_print (vam->ofp, &node);
3940 vat_json_free (&node);
3946 exec (vat_main_t * vam)
3948 api_main_t *am = &api_main;
3949 vl_api_cli_request_t *mp;
3953 unformat_input_t *i = vam->input;
3955 if (vec_len (i->buffer) == 0)
3958 if (vam->exec_mode == 0 && unformat (i, "mode"))
3963 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
3970 M (CLI_REQUEST, cli_request);
3973 * Copy cmd into shared memory.
3974 * In order for the CLI command to work, it
3975 * must be a vector ending in \n, not a C-string ending
3978 pthread_mutex_lock (&am->vlib_rp->mutex);
3979 oldheap = svm_push_data_heap (am->vlib_rp);
3981 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
3982 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
3984 svm_pop_heap (oldheap);
3985 pthread_mutex_unlock (&am->vlib_rp->mutex);
3987 mp->cmd_in_shmem = (u64) cmd;
3989 timeout = vat_time_now (vam) + 10.0;
3991 while (vat_time_now (vam) < timeout)
3993 if (vam->result_ready == 1)
3996 if (vam->shmem_result != NULL)
3997 fformat (vam->ofp, "%s", vam->shmem_result);
3998 pthread_mutex_lock (&am->vlib_rp->mutex);
3999 oldheap = svm_push_data_heap (am->vlib_rp);
4001 free_me = (u8 *) vam->shmem_result;
4004 svm_pop_heap (oldheap);
4005 pthread_mutex_unlock (&am->vlib_rp->mutex);
4013 api_create_loopback (vat_main_t * vam)
4015 unformat_input_t *i = vam->input;
4016 vl_api_create_loopback_t *mp;
4021 memset (mac_address, 0, sizeof (mac_address));
4023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4025 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4031 /* Construct the API message */
4032 M (CREATE_LOOPBACK, create_loopback);
4034 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4041 api_delete_loopback (vat_main_t * vam)
4043 unformat_input_t *i = vam->input;
4044 vl_api_delete_loopback_t *mp;
4046 u32 sw_if_index = ~0;
4048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4050 if (unformat (i, "sw_if_index %d", &sw_if_index))
4056 if (sw_if_index == ~0)
4058 errmsg ("missing sw_if_index\n");
4062 /* Construct the API message */
4063 M (DELETE_LOOPBACK, delete_loopback);
4064 mp->sw_if_index = ntohl (sw_if_index);
4071 api_want_stats (vat_main_t * vam)
4073 unformat_input_t *i = vam->input;
4074 vl_api_want_stats_t *mp;
4078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4080 if (unformat (i, "enable"))
4082 else if (unformat (i, "disable"))
4090 errmsg ("missing enable|disable\n");
4094 M (WANT_STATS, want_stats);
4095 mp->enable_disable = enable;
4102 api_want_interface_events (vat_main_t * vam)
4104 unformat_input_t *i = vam->input;
4105 vl_api_want_interface_events_t *mp;
4109 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4111 if (unformat (i, "enable"))
4113 else if (unformat (i, "disable"))
4121 errmsg ("missing enable|disable\n");
4125 M (WANT_INTERFACE_EVENTS, want_interface_events);
4126 mp->enable_disable = enable;
4128 vam->interface_event_display = enable;
4135 /* Note: non-static, called once to set up the initial intfc table */
4137 api_sw_interface_dump (vat_main_t * vam)
4139 vl_api_sw_interface_dump_t *mp;
4142 name_sort_t *nses = 0, *ns;
4143 sw_interface_subif_t *sub = NULL;
4145 /* Toss the old name table */
4147 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4149 vec_add2 (nses, ns, 1);
4150 ns->name = (u8 *)(p->key);
4151 ns->value = (u32) p->value[0];
4155 hash_free (vam->sw_if_index_by_interface_name);
4157 vec_foreach (ns, nses) vec_free (ns->name);
4161 vec_foreach (sub, vam->sw_if_subif_table)
4163 vec_free (sub->interface_name);
4165 vec_free (vam->sw_if_subif_table);
4167 /* recreate the interface name hash table */
4168 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4170 /* Get list of ethernets */
4171 M (SW_INTERFACE_DUMP, sw_interface_dump);
4172 mp->name_filter_valid = 1;
4173 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4176 /* and local / loopback interfaces */
4177 M (SW_INTERFACE_DUMP, sw_interface_dump);
4178 mp->name_filter_valid = 1;
4179 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4183 /* and vxlan-gpe tunnel interfaces */
4184 M (SW_INTERFACE_DUMP, sw_interface_dump);
4185 mp->name_filter_valid = 1;
4186 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4187 sizeof (mp->name_filter) - 1);
4190 /* and vxlan tunnel interfaces */
4191 M (SW_INTERFACE_DUMP, sw_interface_dump);
4192 mp->name_filter_valid = 1;
4193 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4196 /* and host (af_packet) interfaces */
4197 M (SW_INTERFACE_DUMP, sw_interface_dump);
4198 mp->name_filter_valid = 1;
4199 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4202 /* and l2tpv3 tunnel interfaces */
4203 M (SW_INTERFACE_DUMP, sw_interface_dump);
4204 mp->name_filter_valid = 1;
4205 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4206 sizeof (mp->name_filter) - 1);
4209 /* and GRE tunnel interfaces */
4210 M (SW_INTERFACE_DUMP, sw_interface_dump);
4211 mp->name_filter_valid = 1;
4212 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4215 /* Use a control ping for synchronization */
4217 vl_api_control_ping_t *mp;
4218 M (CONTROL_PING, control_ping);
4225 api_sw_interface_set_flags (vat_main_t * vam)
4227 unformat_input_t *i = vam->input;
4228 vl_api_sw_interface_set_flags_t *mp;
4231 u8 sw_if_index_set = 0;
4232 u8 admin_up = 0, link_up = 0;
4234 /* Parse args required to build the message */
4235 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4237 if (unformat (i, "admin-up"))
4239 else if (unformat (i, "admin-down"))
4241 else if (unformat (i, "link-up"))
4243 else if (unformat (i, "link-down"))
4245 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4246 sw_if_index_set = 1;
4247 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4248 sw_if_index_set = 1;
4253 if (sw_if_index_set == 0)
4255 errmsg ("missing interface name or sw_if_index\n");
4259 /* Construct the API message */
4260 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4261 mp->sw_if_index = ntohl (sw_if_index);
4262 mp->admin_up_down = admin_up;
4263 mp->link_up_down = link_up;
4268 /* Wait for a reply, return the good/bad news... */
4273 api_sw_interface_clear_stats (vat_main_t * vam)
4275 unformat_input_t *i = vam->input;
4276 vl_api_sw_interface_clear_stats_t *mp;
4279 u8 sw_if_index_set = 0;
4281 /* Parse args required to build the message */
4282 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4284 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4285 sw_if_index_set = 1;
4286 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4287 sw_if_index_set = 1;
4292 /* Construct the API message */
4293 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4295 if (sw_if_index_set == 1)
4296 mp->sw_if_index = ntohl (sw_if_index);
4298 mp->sw_if_index = ~0;
4303 /* Wait for a reply, return the good/bad news... */
4308 api_sw_interface_add_del_address (vat_main_t * vam)
4310 unformat_input_t *i = vam->input;
4311 vl_api_sw_interface_add_del_address_t *mp;
4314 u8 sw_if_index_set = 0;
4315 u8 is_add = 1, del_all = 0;
4316 u32 address_length = 0;
4317 u8 v4_address_set = 0;
4318 u8 v6_address_set = 0;
4319 ip4_address_t v4address;
4320 ip6_address_t v6address;
4322 /* Parse args required to build the message */
4323 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4325 if (unformat (i, "del-all"))
4327 else if (unformat (i, "del"))
4329 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4330 sw_if_index_set = 1;
4331 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4332 sw_if_index_set = 1;
4333 else if (unformat (i, "%U/%d",
4334 unformat_ip4_address, &v4address, &address_length))
4336 else if (unformat (i, "%U/%d",
4337 unformat_ip6_address, &v6address, &address_length))
4343 if (sw_if_index_set == 0)
4345 errmsg ("missing interface name or sw_if_index\n");
4348 if (v4_address_set && v6_address_set)
4350 errmsg ("both v4 and v6 addresses set\n");
4353 if (!v4_address_set && !v6_address_set && !del_all)
4355 errmsg ("no addresses set\n");
4359 /* Construct the API message */
4360 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4362 mp->sw_if_index = ntohl (sw_if_index);
4363 mp->is_add = is_add;
4364 mp->del_all = del_all;
4368 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4372 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4374 mp->address_length = address_length;
4379 /* Wait for a reply, return good/bad news */
4384 api_sw_interface_set_table (vat_main_t * vam)
4386 unformat_input_t *i = vam->input;
4387 vl_api_sw_interface_set_table_t *mp;
4389 u32 sw_if_index, vrf_id = 0;
4390 u8 sw_if_index_set = 0;
4393 /* Parse args required to build the message */
4394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4396 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4397 sw_if_index_set = 1;
4398 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4399 sw_if_index_set = 1;
4400 else if (unformat (i, "vrf %d", &vrf_id))
4402 else if (unformat (i, "ipv6"))
4408 if (sw_if_index_set == 0)
4410 errmsg ("missing interface name or sw_if_index\n");
4414 /* Construct the API message */
4415 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4417 mp->sw_if_index = ntohl (sw_if_index);
4418 mp->is_ipv6 = is_ipv6;
4419 mp->vrf_id = ntohl (vrf_id);
4424 /* Wait for a reply... */
4429 api_sw_interface_set_vpath (vat_main_t * vam)
4431 unformat_input_t *i = vam->input;
4432 vl_api_sw_interface_set_vpath_t *mp;
4434 u32 sw_if_index = 0;
4435 u8 sw_if_index_set = 0;
4438 /* Parse args required to build the message */
4439 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4441 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4442 sw_if_index_set = 1;
4443 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4444 sw_if_index_set = 1;
4445 else if (unformat (i, "enable"))
4447 else if (unformat (i, "disable"))
4453 if (sw_if_index_set == 0)
4455 errmsg ("missing interface name or sw_if_index\n");
4459 /* Construct the API message */
4460 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4462 mp->sw_if_index = ntohl (sw_if_index);
4463 mp->enable = is_enable;
4468 /* Wait for a reply... */
4473 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4475 unformat_input_t *i = vam->input;
4476 vl_api_sw_interface_set_l2_xconnect_t *mp;
4479 u8 rx_sw_if_index_set = 0;
4481 u8 tx_sw_if_index_set = 0;
4484 /* Parse args required to build the message */
4485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4487 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4488 rx_sw_if_index_set = 1;
4489 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4490 tx_sw_if_index_set = 1;
4491 else if (unformat (i, "rx"))
4493 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4495 if (unformat (i, "%U", unformat_sw_if_index, vam,
4497 rx_sw_if_index_set = 1;
4502 else if (unformat (i, "tx"))
4504 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4506 if (unformat (i, "%U", unformat_sw_if_index, vam,
4508 tx_sw_if_index_set = 1;
4513 else if (unformat (i, "enable"))
4515 else if (unformat (i, "disable"))
4521 if (rx_sw_if_index_set == 0)
4523 errmsg ("missing rx interface name or rx_sw_if_index\n");
4527 if (enable && (tx_sw_if_index_set == 0))
4529 errmsg ("missing tx interface name or tx_sw_if_index\n");
4533 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4535 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4536 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4537 mp->enable = enable;
4546 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4548 unformat_input_t *i = vam->input;
4549 vl_api_sw_interface_set_l2_bridge_t *mp;
4552 u8 rx_sw_if_index_set = 0;
4559 /* Parse args required to build the message */
4560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4562 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4563 rx_sw_if_index_set = 1;
4564 else if (unformat (i, "bd_id %d", &bd_id))
4566 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4567 rx_sw_if_index_set = 1;
4568 else if (unformat (i, "shg %d", &shg))
4570 else if (unformat (i, "bvi"))
4572 else if (unformat (i, "enable"))
4574 else if (unformat (i, "disable"))
4580 if (rx_sw_if_index_set == 0)
4582 errmsg ("missing rx interface name or sw_if_index\n");
4586 if (enable && (bd_id_set == 0))
4588 errmsg ("missing bridge domain\n");
4592 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4594 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4595 mp->bd_id = ntohl (bd_id);
4598 mp->enable = enable;
4607 api_bridge_domain_dump (vat_main_t * vam)
4609 unformat_input_t *i = vam->input;
4610 vl_api_bridge_domain_dump_t *mp;
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))
4623 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4624 mp->bd_id = ntohl (bd_id);
4627 /* Use a control ping for synchronization */
4629 vl_api_control_ping_t *mp;
4630 M (CONTROL_PING, control_ping);
4640 api_bridge_domain_add_del (vat_main_t * vam)
4642 unformat_input_t *i = vam->input;
4643 vl_api_bridge_domain_add_del_t *mp;
4647 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4649 /* Parse args required to build the message */
4650 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4652 if (unformat (i, "bd_id %d", &bd_id))
4654 else if (unformat (i, "flood %d", &flood))
4656 else if (unformat (i, "uu-flood %d", &uu_flood))
4658 else if (unformat (i, "forward %d", &forward))
4660 else if (unformat (i, "learn %d", &learn))
4662 else if (unformat (i, "arp-term %d", &arp_term))
4664 else if (unformat (i, "del"))
4667 flood = uu_flood = forward = learn = 0;
4675 errmsg ("missing bridge domain\n");
4679 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4681 mp->bd_id = ntohl (bd_id);
4683 mp->uu_flood = uu_flood;
4684 mp->forward = forward;
4686 mp->arp_term = arp_term;
4687 mp->is_add = is_add;
4696 api_l2fib_add_del (vat_main_t * vam)
4698 unformat_input_t *i = vam->input;
4699 vl_api_l2fib_add_del_t *mp;
4706 u8 sw_if_index_set = 0;
4715 /* Parse args required to build the message */
4716 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4718 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4720 else if (unformat (i, "bd_id %d", &bd_id))
4722 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4723 sw_if_index_set = 1;
4724 else if (unformat (i, "sw_if"))
4726 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4728 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4729 sw_if_index_set = 1;
4734 else if (unformat (i, "static"))
4736 else if (unformat (i, "filter"))
4741 else if (unformat (i, "bvi"))
4746 else if (unformat (i, "del"))
4748 else if (unformat (i, "count %d", &count))
4756 errmsg ("missing mac address\n");
4762 errmsg ("missing bridge domain\n");
4766 if (is_add && (sw_if_index_set == 0))
4768 errmsg ("missing interface name or sw_if_index\n");
4774 /* Turn on async mode */
4775 vam->async_mode = 1;
4776 vam->async_errors = 0;
4777 before = vat_time_now (vam);
4780 for (j = 0; j < count; j++)
4782 M (L2FIB_ADD_DEL, l2fib_add_del);
4785 mp->bd_id = ntohl (bd_id);
4786 mp->is_add = is_add;
4790 mp->sw_if_index = ntohl (sw_if_index);
4791 mp->static_mac = static_mac;
4792 mp->filter_mac = filter_mac;
4793 mp->bvi_mac = bvi_mac;
4795 increment_mac_address (&mac);
4802 vl_api_control_ping_t *mp;
4805 /* Shut off async mode */
4806 vam->async_mode = 0;
4808 M (CONTROL_PING, control_ping);
4811 timeout = vat_time_now (vam) + 1.0;
4812 while (vat_time_now (vam) < timeout)
4813 if (vam->result_ready == 1)
4818 if (vam->retval == -99)
4819 errmsg ("timeout\n");
4821 if (vam->async_errors > 0)
4823 errmsg ("%d asynchronous errors\n", vam->async_errors);
4826 vam->async_errors = 0;
4827 after = vat_time_now (vam);
4829 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4830 count, after - before, count / (after - before));
4834 /* Wait for a reply... */
4837 /* Return the good/bad news */
4838 return (vam->retval);
4842 api_l2_flags (vat_main_t * vam)
4844 unformat_input_t *i = vam->input;
4845 vl_api_l2_flags_t *mp;
4848 u32 feature_bitmap = 0;
4849 u8 sw_if_index_set = 0;
4851 /* Parse args required to build the message */
4852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4854 if (unformat (i, "sw_if_index %d", &sw_if_index))
4855 sw_if_index_set = 1;
4856 else if (unformat (i, "sw_if"))
4858 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4860 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4861 sw_if_index_set = 1;
4866 else if (unformat (i, "learn"))
4867 feature_bitmap |= L2INPUT_FEAT_LEARN;
4868 else if (unformat (i, "forward"))
4869 feature_bitmap |= L2INPUT_FEAT_FWD;
4870 else if (unformat (i, "flood"))
4871 feature_bitmap |= L2INPUT_FEAT_FLOOD;
4872 else if (unformat (i, "uu-flood"))
4873 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
4878 if (sw_if_index_set == 0)
4880 errmsg ("missing interface name or sw_if_index\n");
4884 M (L2_FLAGS, l2_flags);
4886 mp->sw_if_index = ntohl (sw_if_index);
4887 mp->feature_bitmap = ntohl (feature_bitmap);
4896 api_bridge_flags (vat_main_t * vam)
4898 unformat_input_t *i = vam->input;
4899 vl_api_bridge_flags_t *mp;
4906 /* Parse args required to build the message */
4907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4909 if (unformat (i, "bd_id %d", &bd_id))
4911 else if (unformat (i, "learn"))
4913 else if (unformat (i, "forward"))
4915 else if (unformat (i, "flood"))
4917 else if (unformat (i, "uu-flood"))
4918 flags |= L2_UU_FLOOD;
4919 else if (unformat (i, "arp-term"))
4920 flags |= L2_ARP_TERM;
4921 else if (unformat (i, "off"))
4923 else if (unformat (i, "disable"))
4931 errmsg ("missing bridge domain\n");
4935 M (BRIDGE_FLAGS, bridge_flags);
4937 mp->bd_id = ntohl (bd_id);
4938 mp->feature_bitmap = ntohl (flags);
4939 mp->is_set = is_set;
4948 api_bd_ip_mac_add_del (vat_main_t * vam)
4950 unformat_input_t *i = vam->input;
4951 vl_api_bd_ip_mac_add_del_t *mp;
4959 ip4_address_t v4addr;
4960 ip6_address_t v6addr;
4964 /* Parse args required to build the message */
4965 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4967 if (unformat (i, "bd_id %d", &bd_id))
4971 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
4975 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
4980 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
4984 else if (unformat (i, "del"))
4992 errmsg ("missing bridge domain\n");
4995 else if (ip_set == 0)
4997 errmsg ("missing IP address\n");
5000 else if (mac_set == 0)
5002 errmsg ("missing MAC address\n");
5006 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5008 mp->bd_id = ntohl (bd_id);
5009 mp->is_ipv6 = is_ipv6;
5010 mp->is_add = is_add;
5012 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5014 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5015 clib_memcpy (mp->mac_address, macaddr, 6);
5023 api_tap_connect (vat_main_t * vam)
5025 unformat_input_t *i = vam->input;
5026 vl_api_tap_connect_t *mp;
5033 memset (mac_address, 0, sizeof (mac_address));
5035 /* Parse args required to build the message */
5036 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5038 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5042 else if (unformat (i, "random-mac"))
5044 else if (unformat (i, "tapname %s", &tap_name))
5052 errmsg ("missing tap name\n");
5055 if (vec_len (tap_name) > 63)
5057 errmsg ("tap name too long\n");
5059 vec_add1 (tap_name, 0);
5061 /* Construct the API message */
5062 M (TAP_CONNECT, tap_connect);
5064 mp->use_random_mac = random_mac;
5065 clib_memcpy (mp->mac_address, mac_address, 6);
5066 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5067 vec_free (tap_name);
5072 /* Wait for a reply... */
5077 api_tap_modify (vat_main_t * vam)
5079 unformat_input_t *i = vam->input;
5080 vl_api_tap_modify_t *mp;
5086 u32 sw_if_index = ~0;
5087 u8 sw_if_index_set = 0;
5089 memset (mac_address, 0, sizeof (mac_address));
5091 /* Parse args required to build the message */
5092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5094 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5095 sw_if_index_set = 1;
5096 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5097 sw_if_index_set = 1;
5098 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5102 else if (unformat (i, "random-mac"))
5104 else if (unformat (i, "tapname %s", &tap_name))
5110 if (sw_if_index_set == 0)
5112 errmsg ("missing vpp interface name");
5117 errmsg ("missing tap name\n");
5120 if (vec_len (tap_name) > 63)
5122 errmsg ("tap name too long\n");
5124 vec_add1 (tap_name, 0);
5126 /* Construct the API message */
5127 M (TAP_MODIFY, tap_modify);
5129 mp->use_random_mac = random_mac;
5130 mp->sw_if_index = ntohl (sw_if_index);
5131 clib_memcpy (mp->mac_address, mac_address, 6);
5132 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5133 vec_free (tap_name);
5138 /* Wait for a reply... */
5143 api_tap_delete (vat_main_t * vam)
5145 unformat_input_t *i = vam->input;
5146 vl_api_tap_delete_t *mp;
5148 u32 sw_if_index = ~0;
5149 u8 sw_if_index_set = 0;
5151 /* Parse args required to build the message */
5152 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5154 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5155 sw_if_index_set = 1;
5156 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5157 sw_if_index_set = 1;
5162 if (sw_if_index_set == 0)
5164 errmsg ("missing vpp interface name");
5168 /* Construct the API message */
5169 M (TAP_DELETE, tap_delete);
5171 mp->sw_if_index = ntohl (sw_if_index);
5176 /* Wait for a reply... */
5181 api_ip_add_del_route (vat_main_t * vam)
5183 unformat_input_t *i = vam->input;
5184 vl_api_ip_add_del_route_t *mp;
5186 u32 sw_if_index = ~0, vrf_id = 0;
5187 u8 sw_if_index_set = 0;
5189 u8 is_local = 0, is_drop = 0;
5190 u8 create_vrf_if_needed = 0;
5192 u8 next_hop_weight = 1;
5194 u8 is_multipath = 0;
5196 u8 address_length_set = 0;
5197 u32 lookup_in_vrf = 0;
5198 u32 resolve_attempts = 0;
5199 u32 dst_address_length = 0;
5200 u8 next_hop_set = 0;
5201 ip4_address_t v4_dst_address, v4_next_hop_address;
5202 ip6_address_t v6_dst_address, v6_next_hop_address;
5206 u32 random_add_del = 0;
5207 u32 *random_vector = 0;
5209 u32 random_seed = 0xdeaddabe;
5210 u32 classify_table_index = ~0;
5213 /* Parse args required to build the message */
5214 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5216 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5217 sw_if_index_set = 1;
5218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5219 sw_if_index_set = 1;
5220 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5225 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5230 else if (unformat (i, "/%d", &dst_address_length))
5232 address_length_set = 1;
5235 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5236 &v4_next_hop_address))
5240 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5241 &v6_next_hop_address))
5245 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5247 else if (unformat (i, "weight %d", &next_hop_weight))
5249 else if (unformat (i, "drop"))
5253 else if (unformat (i, "local"))
5257 else if (unformat (i, "classify %d", &classify_table_index))
5261 else if (unformat (i, "del"))
5263 else if (unformat (i, "add"))
5265 else if (unformat (i, "not-last"))
5267 else if (unformat (i, "multipath"))
5269 else if (unformat (i, "vrf %d", &vrf_id))
5271 else if (unformat (i, "create-vrf"))
5272 create_vrf_if_needed = 1;
5273 else if (unformat (i, "count %d", &count))
5275 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5277 else if (unformat (i, "random"))
5279 else if (unformat (i, "seed %d", &random_seed))
5283 clib_warning ("parse error '%U'", format_unformat_error, i);
5288 if (resolve_attempts > 0 && sw_if_index_set == 0)
5290 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5294 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5296 errmsg ("next hop / local / drop / classify not set\n");
5300 if (address_set == 0)
5302 errmsg ("missing addresses\n");
5306 if (address_length_set == 0)
5308 errmsg ("missing address length\n");
5312 /* Generate a pile of unique, random routes */
5315 u32 this_random_address;
5316 random_hash = hash_create (count, sizeof (uword));
5318 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5319 for (j = 0; j <= count; j++)
5323 this_random_address = random_u32 (&random_seed);
5324 this_random_address =
5325 clib_host_to_net_u32 (this_random_address);
5327 while (hash_get (random_hash, this_random_address));
5328 vec_add1 (random_vector, this_random_address);
5329 hash_set (random_hash, this_random_address, 1);
5331 hash_free (random_hash);
5332 v4_dst_address.as_u32 = random_vector[0];
5337 /* Turn on async mode */
5338 vam->async_mode = 1;
5339 vam->async_errors = 0;
5340 before = vat_time_now (vam);
5343 for (j = 0; j < count; j++)
5345 /* Construct the API message */
5346 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5348 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5349 mp->vrf_id = ntohl (vrf_id);
5350 if (resolve_attempts > 0)
5352 mp->resolve_attempts = ntohl (resolve_attempts);
5353 mp->resolve_if_needed = 1;
5355 mp->create_vrf_if_needed = create_vrf_if_needed;
5357 mp->is_add = is_add;
5358 mp->is_drop = is_drop;
5359 mp->is_ipv6 = is_ipv6;
5360 mp->is_local = is_local;
5361 mp->is_classify = is_classify;
5362 mp->is_multipath = is_multipath;
5363 mp->not_last = not_last;
5364 mp->next_hop_weight = next_hop_weight;
5365 mp->dst_address_length = dst_address_length;
5366 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5367 mp->classify_table_index = ntohl (classify_table_index);
5371 clib_memcpy (mp->dst_address, &v6_dst_address,
5372 sizeof (v6_dst_address));
5374 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5375 sizeof (v6_next_hop_address));
5376 increment_v6_address (&v6_dst_address);
5380 clib_memcpy (mp->dst_address, &v4_dst_address,
5381 sizeof (v4_dst_address));
5383 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5384 sizeof (v4_next_hop_address));
5386 v4_dst_address.as_u32 = random_vector[j + 1];
5388 increment_v4_address (&v4_dst_address);
5394 /* When testing multiple add/del ops, use a control-ping to sync */
5397 vl_api_control_ping_t *mp;
5400 /* Shut off async mode */
5401 vam->async_mode = 0;
5403 M (CONTROL_PING, control_ping);
5406 timeout = vat_time_now (vam) + 1.0;
5407 while (vat_time_now (vam) < timeout)
5408 if (vam->result_ready == 1)
5413 if (vam->retval == -99)
5414 errmsg ("timeout\n");
5416 if (vam->async_errors > 0)
5418 errmsg ("%d asynchronous errors\n", vam->async_errors);
5421 vam->async_errors = 0;
5422 after = vat_time_now (vam);
5424 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5425 count, after - before, count / (after - before));
5429 /* Wait for a reply... */
5433 /* Return the good/bad news */
5434 return (vam->retval);
5438 api_proxy_arp_add_del (vat_main_t * vam)
5440 unformat_input_t *i = vam->input;
5441 vl_api_proxy_arp_add_del_t *mp;
5445 ip4_address_t lo, hi;
5448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5450 if (unformat (i, "vrf %d", &vrf_id))
5452 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5453 unformat_ip4_address, &hi))
5455 else if (unformat (i, "del"))
5459 clib_warning ("parse error '%U'", format_unformat_error, i);
5466 errmsg ("address range not set\n");
5470 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5472 mp->vrf_id = ntohl (vrf_id);
5473 mp->is_add = is_add;
5474 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5475 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5484 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5486 unformat_input_t *i = vam->input;
5487 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5491 u8 sw_if_index_set = 0;
5493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5495 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5496 sw_if_index_set = 1;
5497 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5498 sw_if_index_set = 1;
5499 else if (unformat (i, "enable"))
5501 else if (unformat (i, "disable"))
5505 clib_warning ("parse error '%U'", format_unformat_error, i);
5510 if (sw_if_index_set == 0)
5512 errmsg ("missing interface name or sw_if_index\n");
5516 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5518 mp->sw_if_index = ntohl (sw_if_index);
5519 mp->enable_disable = enable;
5528 api_mpls_add_del_decap (vat_main_t * vam)
5530 unformat_input_t *i = vam->input;
5531 vl_api_mpls_add_del_decap_t *mp;
5540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5542 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5544 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5546 else if (unformat (i, "label %d", &label))
5548 else if (unformat (i, "next-index %d", &next_index))
5550 else if (unformat (i, "del"))
5552 else if (unformat (i, "s-bit-clear"))
5556 clib_warning ("parse error '%U'", format_unformat_error, i);
5561 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5563 mp->rx_vrf_id = ntohl (rx_vrf_id);
5564 mp->tx_vrf_id = ntohl (tx_vrf_id);
5565 mp->label = ntohl (label);
5566 mp->next_index = ntohl (next_index);
5568 mp->is_add = is_add;
5577 api_mpls_add_del_encap (vat_main_t * vam)
5579 unformat_input_t *i = vam->input;
5580 vl_api_mpls_add_del_encap_t *mp;
5585 ip4_address_t dst_address;
5588 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5590 if (unformat (i, "vrf %d", &vrf_id))
5592 else if (unformat (i, "label %d", &label))
5593 vec_add1 (labels, ntohl (label));
5594 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5596 else if (unformat (i, "del"))
5600 clib_warning ("parse error '%U'", format_unformat_error, i);
5605 if (vec_len (labels) == 0)
5607 errmsg ("missing encap label stack\n");
5611 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5612 sizeof (u32) * vec_len (labels));
5614 mp->vrf_id = ntohl (vrf_id);
5615 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5616 mp->is_add = is_add;
5617 mp->nlabels = vec_len (labels);
5618 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5629 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5631 unformat_input_t *i = vam->input;
5632 vl_api_mpls_gre_add_del_tunnel_t *mp;
5634 u32 inner_vrf_id = 0;
5635 u32 outer_vrf_id = 0;
5636 ip4_address_t src_address;
5637 ip4_address_t dst_address;
5638 ip4_address_t intfc_address;
5640 u8 intfc_address_length = 0;
5644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5646 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5648 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5650 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5652 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5654 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5655 &intfc_address, &tmp))
5656 intfc_address_length = tmp;
5657 else if (unformat (i, "l2-only"))
5659 else if (unformat (i, "del"))
5663 clib_warning ("parse error '%U'", format_unformat_error, i);
5668 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5670 mp->inner_vrf_id = ntohl (inner_vrf_id);
5671 mp->outer_vrf_id = ntohl (outer_vrf_id);
5672 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5673 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5674 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5675 mp->intfc_address_length = intfc_address_length;
5676 mp->l2_only = l2_only;
5677 mp->is_add = is_add;
5686 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5688 unformat_input_t *i = vam->input;
5689 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5691 u32 inner_vrf_id = 0;
5692 ip4_address_t intfc_address;
5693 u8 dst_mac_address[6];
5696 u8 intfc_address_length = 0;
5700 int tx_sw_if_index_set = 0;
5702 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5704 if (unformat (i, "vrf %d", &inner_vrf_id))
5706 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5707 &intfc_address, &tmp))
5708 intfc_address_length = tmp;
5709 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5710 tx_sw_if_index_set = 1;
5711 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5712 tx_sw_if_index_set = 1;
5713 else if (unformat (i, "dst %U", unformat_ethernet_address,
5716 else if (unformat (i, "l2-only"))
5718 else if (unformat (i, "del"))
5722 clib_warning ("parse error '%U'", format_unformat_error, i);
5729 errmsg ("dst (mac address) not set\n");
5732 if (!tx_sw_if_index_set)
5734 errmsg ("tx-intfc not set\n");
5738 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5740 mp->vrf_id = ntohl (inner_vrf_id);
5741 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5742 mp->adj_address_length = intfc_address_length;
5743 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5744 sizeof (dst_mac_address));
5745 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5746 mp->l2_only = l2_only;
5747 mp->is_add = is_add;
5756 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5758 unformat_input_t *i = vam->input;
5759 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5761 u32 inner_vrf_id = 0;
5762 u32 outer_vrf_id = 0;
5763 ip4_address_t adj_address;
5764 int adj_address_set = 0;
5765 ip4_address_t next_hop_address;
5766 int next_hop_address_set = 0;
5768 u8 adj_address_length = 0;
5771 u32 resolve_attempts = 5;
5772 u8 resolve_if_needed = 1;
5774 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5776 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5778 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5780 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5781 &adj_address, &tmp))
5783 adj_address_length = tmp;
5784 adj_address_set = 1;
5786 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5788 next_hop_address_set = 1;
5789 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5791 else if (unformat (i, "resolve-if-needed %d", &tmp))
5792 resolve_if_needed = tmp;
5793 else if (unformat (i, "l2-only"))
5795 else if (unformat (i, "del"))
5799 clib_warning ("parse error '%U'", format_unformat_error, i);
5804 if (!adj_address_set)
5806 errmsg ("adjacency address/mask not set\n");
5809 if (!next_hop_address_set)
5811 errmsg ("ip4 next hop address (in outer fib) not set\n");
5815 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5817 mp->inner_vrf_id = ntohl (inner_vrf_id);
5818 mp->outer_vrf_id = ntohl (outer_vrf_id);
5819 mp->resolve_attempts = ntohl (resolve_attempts);
5820 mp->resolve_if_needed = resolve_if_needed;
5821 mp->is_add = is_add;
5822 mp->l2_only = l2_only;
5823 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5824 mp->adj_address_length = adj_address_length;
5825 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5826 sizeof (next_hop_address));
5835 api_sw_interface_set_unnumbered (vat_main_t * vam)
5837 unformat_input_t *i = vam->input;
5838 vl_api_sw_interface_set_unnumbered_t *mp;
5841 u32 unnum_sw_index = ~0;
5843 u8 sw_if_index_set = 0;
5845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5847 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5848 sw_if_index_set = 1;
5849 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5850 sw_if_index_set = 1;
5851 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
5853 else if (unformat (i, "del"))
5857 clib_warning ("parse error '%U'", format_unformat_error, i);
5862 if (sw_if_index_set == 0)
5864 errmsg ("missing interface name or sw_if_index\n");
5868 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
5870 mp->sw_if_index = ntohl (sw_if_index);
5871 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
5872 mp->is_add = is_add;
5881 api_ip_neighbor_add_del (vat_main_t * vam)
5883 unformat_input_t *i = vam->input;
5884 vl_api_ip_neighbor_add_del_t *mp;
5887 u8 sw_if_index_set = 0;
5893 u8 v4_address_set = 0;
5894 u8 v6_address_set = 0;
5895 ip4_address_t v4address;
5896 ip6_address_t v6address;
5898 memset (mac_address, 0, sizeof (mac_address));
5900 /* Parse args required to build the message */
5901 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5903 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5907 else if (unformat (i, "del"))
5909 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5910 sw_if_index_set = 1;
5911 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5912 sw_if_index_set = 1;
5913 else if (unformat (i, "is_static"))
5915 else if (unformat (i, "vrf %d", &vrf_id))
5917 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
5919 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
5923 clib_warning ("parse error '%U'", format_unformat_error, i);
5928 if (sw_if_index_set == 0)
5930 errmsg ("missing interface name or sw_if_index\n");
5933 if (v4_address_set && v6_address_set)
5935 errmsg ("both v4 and v6 addresses set\n");
5938 if (!v4_address_set && !v6_address_set)
5940 errmsg ("no address set\n");
5944 /* Construct the API message */
5945 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
5947 mp->sw_if_index = ntohl (sw_if_index);
5948 mp->is_add = is_add;
5949 mp->vrf_id = ntohl (vrf_id);
5950 mp->is_static = is_static;
5952 clib_memcpy (mp->mac_address, mac_address, 6);
5956 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
5960 /* mp->is_ipv6 = 0; via memset in M macro above */
5961 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
5967 /* Wait for a reply, return good/bad news */
5975 api_reset_vrf (vat_main_t * vam)
5977 unformat_input_t *i = vam->input;
5978 vl_api_reset_vrf_t *mp;
5984 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5986 if (unformat (i, "vrf %d", &vrf_id))
5988 else if (unformat (i, "ipv6"))
5992 clib_warning ("parse error '%U'", format_unformat_error, i);
5997 if (vrf_id_set == 0)
5999 errmsg ("missing vrf id\n");
6003 M (RESET_VRF, reset_vrf);
6005 mp->vrf_id = ntohl (vrf_id);
6006 mp->is_ipv6 = is_ipv6;
6015 api_create_vlan_subif (vat_main_t * vam)
6017 unformat_input_t *i = vam->input;
6018 vl_api_create_vlan_subif_t *mp;
6021 u8 sw_if_index_set = 0;
6025 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6027 if (unformat (i, "sw_if_index %d", &sw_if_index))
6028 sw_if_index_set = 1;
6029 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6030 sw_if_index_set = 1;
6031 else if (unformat (i, "vlan %d", &vlan_id))
6035 clib_warning ("parse error '%U'", format_unformat_error, i);
6040 if (sw_if_index_set == 0)
6042 errmsg ("missing interface name or sw_if_index\n");
6046 if (vlan_id_set == 0)
6048 errmsg ("missing vlan_id\n");
6051 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6053 mp->sw_if_index = ntohl (sw_if_index);
6054 mp->vlan_id = ntohl (vlan_id);
6062 #define foreach_create_subif_bit \
6069 _(outer_vlan_id_any) \
6070 _(inner_vlan_id_any)
6073 api_create_subif (vat_main_t * vam)
6075 unformat_input_t *i = vam->input;
6076 vl_api_create_subif_t *mp;
6079 u8 sw_if_index_set = 0;
6086 u32 exact_match = 0;
6087 u32 default_sub = 0;
6088 u32 outer_vlan_id_any = 0;
6089 u32 inner_vlan_id_any = 0;
6091 u16 outer_vlan_id = 0;
6092 u16 inner_vlan_id = 0;
6094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6096 if (unformat (i, "sw_if_index %d", &sw_if_index))
6097 sw_if_index_set = 1;
6098 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6099 sw_if_index_set = 1;
6100 else if (unformat (i, "sub_id %d", &sub_id))
6102 else if (unformat (i, "outer_vlan_id %d", &tmp))
6103 outer_vlan_id = tmp;
6104 else if (unformat (i, "inner_vlan_id %d", &tmp))
6105 inner_vlan_id = tmp;
6107 #define _(a) else if (unformat (i, #a)) a = 1 ;
6108 foreach_create_subif_bit
6112 clib_warning ("parse error '%U'", format_unformat_error, i);
6117 if (sw_if_index_set == 0)
6119 errmsg ("missing interface name or sw_if_index\n");
6123 if (sub_id_set == 0)
6125 errmsg ("missing sub_id\n");
6128 M (CREATE_SUBIF, create_subif);
6130 mp->sw_if_index = ntohl (sw_if_index);
6131 mp->sub_id = ntohl (sub_id);
6133 #define _(a) mp->a = a;
6134 foreach_create_subif_bit;
6137 mp->outer_vlan_id = ntohs (outer_vlan_id);
6138 mp->inner_vlan_id = ntohs (inner_vlan_id);
6147 api_oam_add_del (vat_main_t * vam)
6149 unformat_input_t *i = vam->input;
6150 vl_api_oam_add_del_t *mp;
6154 ip4_address_t src, dst;
6158 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6160 if (unformat (i, "vrf %d", &vrf_id))
6162 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6164 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6166 else if (unformat (i, "del"))
6170 clib_warning ("parse error '%U'", format_unformat_error, i);
6177 errmsg ("missing src addr\n");
6183 errmsg ("missing dst addr\n");
6187 M (OAM_ADD_DEL, oam_add_del);
6189 mp->vrf_id = ntohl (vrf_id);
6190 mp->is_add = is_add;
6191 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6192 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6201 api_reset_fib (vat_main_t * vam)
6203 unformat_input_t *i = vam->input;
6204 vl_api_reset_fib_t *mp;
6210 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6212 if (unformat (i, "vrf %d", &vrf_id))
6214 else if (unformat (i, "ipv6"))
6218 clib_warning ("parse error '%U'", format_unformat_error, i);
6223 if (vrf_id_set == 0)
6225 errmsg ("missing vrf id\n");
6229 M (RESET_FIB, reset_fib);
6231 mp->vrf_id = ntohl (vrf_id);
6232 mp->is_ipv6 = is_ipv6;
6241 api_dhcp_proxy_config (vat_main_t * vam)
6243 unformat_input_t *i = vam->input;
6244 vl_api_dhcp_proxy_config_t *mp;
6249 u8 v4_address_set = 0;
6250 u8 v6_address_set = 0;
6251 ip4_address_t v4address;
6252 ip6_address_t v6address;
6253 u8 v4_src_address_set = 0;
6254 u8 v6_src_address_set = 0;
6255 ip4_address_t v4srcaddress;
6256 ip6_address_t v6srcaddress;
6258 /* Parse args required to build the message */
6259 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6261 if (unformat (i, "del"))
6263 else if (unformat (i, "vrf %d", &vrf_id))
6265 else if (unformat (i, "insert-cid %d", &insert_cid))
6267 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6269 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6271 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6272 v4_src_address_set = 1;
6273 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6274 v6_src_address_set = 1;
6279 if (v4_address_set && v6_address_set)
6281 errmsg ("both v4 and v6 server addresses set\n");
6284 if (!v4_address_set && !v6_address_set)
6286 errmsg ("no server addresses set\n");
6290 if (v4_src_address_set && v6_src_address_set)
6292 errmsg ("both v4 and v6 src addresses set\n");
6295 if (!v4_src_address_set && !v6_src_address_set)
6297 errmsg ("no src addresses set\n");
6301 if (!(v4_src_address_set && v4_address_set) &&
6302 !(v6_src_address_set && v6_address_set))
6304 errmsg ("no matching server and src addresses set\n");
6308 /* Construct the API message */
6309 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6311 mp->insert_circuit_id = insert_cid;
6312 mp->is_add = is_add;
6313 mp->vrf_id = ntohl (vrf_id);
6317 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6318 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6322 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6323 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6329 /* Wait for a reply, return good/bad news */
6336 api_dhcp_proxy_config_2 (vat_main_t * vam)
6338 unformat_input_t *i = vam->input;
6339 vl_api_dhcp_proxy_config_2_t *mp;
6342 u32 server_vrf_id = 0;
6345 u8 v4_address_set = 0;
6346 u8 v6_address_set = 0;
6347 ip4_address_t v4address;
6348 ip6_address_t v6address;
6349 u8 v4_src_address_set = 0;
6350 u8 v6_src_address_set = 0;
6351 ip4_address_t v4srcaddress;
6352 ip6_address_t v6srcaddress;
6354 /* Parse args required to build the message */
6355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6357 if (unformat (i, "del"))
6359 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6361 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6363 else if (unformat (i, "insert-cid %d", &insert_cid))
6365 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6367 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6369 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6370 v4_src_address_set = 1;
6371 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6372 v6_src_address_set = 1;
6377 if (v4_address_set && v6_address_set)
6379 errmsg ("both v4 and v6 server addresses set\n");
6382 if (!v4_address_set && !v6_address_set)
6384 errmsg ("no server addresses set\n");
6388 if (v4_src_address_set && v6_src_address_set)
6390 errmsg ("both v4 and v6 src addresses set\n");
6393 if (!v4_src_address_set && !v6_src_address_set)
6395 errmsg ("no src addresses set\n");
6399 if (!(v4_src_address_set && v4_address_set) &&
6400 !(v6_src_address_set && v6_address_set))
6402 errmsg ("no matching server and src addresses set\n");
6406 /* Construct the API message */
6407 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6409 mp->insert_circuit_id = insert_cid;
6410 mp->is_add = is_add;
6411 mp->rx_vrf_id = ntohl (rx_vrf_id);
6412 mp->server_vrf_id = ntohl (server_vrf_id);
6416 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6417 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6421 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6422 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6428 /* Wait for a reply, return good/bad news */
6435 api_dhcp_proxy_set_vss (vat_main_t * vam)
6437 unformat_input_t *i = vam->input;
6438 vl_api_dhcp_proxy_set_vss_t *mp;
6449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6451 if (unformat (i, "tbl_id %d", &tbl_id))
6453 if (unformat (i, "fib_id %d", &fib_id))
6455 if (unformat (i, "oui %d", &oui))
6457 else if (unformat (i, "ipv6"))
6459 else if (unformat (i, "del"))
6463 clib_warning ("parse error '%U'", format_unformat_error, i);
6468 if (tbl_id_set == 0)
6470 errmsg ("missing tbl id\n");
6474 if (fib_id_set == 0)
6476 errmsg ("missing fib id\n");
6481 errmsg ("missing oui\n");
6485 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6486 mp->tbl_id = ntohl (tbl_id);
6487 mp->fib_id = ntohl (fib_id);
6488 mp->oui = ntohl (oui);
6489 mp->is_ipv6 = is_ipv6;
6490 mp->is_add = is_add;
6499 api_dhcp_client_config (vat_main_t * vam)
6501 unformat_input_t *i = vam->input;
6502 vl_api_dhcp_client_config_t *mp;
6505 u8 sw_if_index_set = 0;
6508 u8 disable_event = 0;
6510 /* Parse args required to build the message */
6511 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6513 if (unformat (i, "del"))
6515 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6516 sw_if_index_set = 1;
6517 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6518 sw_if_index_set = 1;
6519 else if (unformat (i, "hostname %s", &hostname))
6521 else if (unformat (i, "disable_event"))
6527 if (sw_if_index_set == 0)
6529 errmsg ("missing interface name or sw_if_index\n");
6533 if (vec_len (hostname) > 63)
6535 errmsg ("hostname too long\n");
6537 vec_add1 (hostname, 0);
6539 /* Construct the API message */
6540 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6542 mp->sw_if_index = ntohl (sw_if_index);
6543 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6544 vec_free (hostname);
6545 mp->is_add = is_add;
6546 mp->want_dhcp_event = disable_event ? 0 : 1;
6547 mp->pid = getpid ();
6552 /* Wait for a reply, return good/bad news */
6559 api_set_ip_flow_hash (vat_main_t * vam)
6561 unformat_input_t *i = vam->input;
6562 vl_api_set_ip_flow_hash_t *mp;
6574 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6576 if (unformat (i, "vrf %d", &vrf_id))
6578 else if (unformat (i, "ipv6"))
6580 else if (unformat (i, "src"))
6582 else if (unformat (i, "dst"))
6584 else if (unformat (i, "sport"))
6586 else if (unformat (i, "dport"))
6588 else if (unformat (i, "proto"))
6590 else if (unformat (i, "reverse"))
6595 clib_warning ("parse error '%U'", format_unformat_error, i);
6600 if (vrf_id_set == 0)
6602 errmsg ("missing vrf id\n");
6606 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6612 mp->reverse = reverse;
6613 mp->vrf_id = ntohl (vrf_id);
6614 mp->is_ipv6 = is_ipv6;
6623 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6625 unformat_input_t *i = vam->input;
6626 vl_api_sw_interface_ip6_enable_disable_t *mp;
6629 u8 sw_if_index_set = 0;
6632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6634 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6635 sw_if_index_set = 1;
6636 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6637 sw_if_index_set = 1;
6638 else if (unformat (i, "enable"))
6640 else if (unformat (i, "disable"))
6644 clib_warning ("parse error '%U'", format_unformat_error, i);
6649 if (sw_if_index_set == 0)
6651 errmsg ("missing interface name or sw_if_index\n");
6655 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6657 mp->sw_if_index = ntohl (sw_if_index);
6658 mp->enable = enable;
6667 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6669 unformat_input_t *i = vam->input;
6670 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6673 u8 sw_if_index_set = 0;
6674 u32 address_length = 0;
6675 u8 v6_address_set = 0;
6676 ip6_address_t v6address;
6678 /* Parse args required to build the message */
6679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6681 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6682 sw_if_index_set = 1;
6683 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6684 sw_if_index_set = 1;
6685 else if (unformat (i, "%U/%d",
6686 unformat_ip6_address, &v6address, &address_length))
6692 if (sw_if_index_set == 0)
6694 errmsg ("missing interface name or sw_if_index\n");
6697 if (!v6_address_set)
6699 errmsg ("no address set\n");
6703 /* Construct the API message */
6704 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6705 sw_interface_ip6_set_link_local_address);
6707 mp->sw_if_index = ntohl (sw_if_index);
6708 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6709 mp->address_length = address_length;
6714 /* Wait for a reply, return good/bad news */
6723 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6725 unformat_input_t *i = vam->input;
6726 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6729 u8 sw_if_index_set = 0;
6730 u32 address_length = 0;
6731 u8 v6_address_set = 0;
6732 ip6_address_t v6address;
6734 u8 no_advertise = 0;
6736 u8 no_autoconfig = 0;
6739 u32 val_lifetime = 0;
6740 u32 pref_lifetime = 0;
6742 /* Parse args required to build the message */
6743 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6745 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6746 sw_if_index_set = 1;
6747 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6748 sw_if_index_set = 1;
6749 else if (unformat (i, "%U/%d",
6750 unformat_ip6_address, &v6address, &address_length))
6752 else if (unformat (i, "val_life %d", &val_lifetime))
6754 else if (unformat (i, "pref_life %d", &pref_lifetime))
6756 else if (unformat (i, "def"))
6758 else if (unformat (i, "noadv"))
6760 else if (unformat (i, "offl"))
6762 else if (unformat (i, "noauto"))
6764 else if (unformat (i, "nolink"))
6766 else if (unformat (i, "isno"))
6770 clib_warning ("parse error '%U'", format_unformat_error, i);
6775 if (sw_if_index_set == 0)
6777 errmsg ("missing interface name or sw_if_index\n");
6780 if (!v6_address_set)
6782 errmsg ("no address set\n");
6786 /* Construct the API message */
6787 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6789 mp->sw_if_index = ntohl (sw_if_index);
6790 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6791 mp->address_length = address_length;
6792 mp->use_default = use_default;
6793 mp->no_advertise = no_advertise;
6794 mp->off_link = off_link;
6795 mp->no_autoconfig = no_autoconfig;
6796 mp->no_onlink = no_onlink;
6798 mp->val_lifetime = ntohl (val_lifetime);
6799 mp->pref_lifetime = ntohl (pref_lifetime);
6804 /* Wait for a reply, return good/bad news */
6812 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6814 unformat_input_t *i = vam->input;
6815 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6818 u8 sw_if_index_set = 0;
6823 u8 send_unicast = 0;
6826 u8 default_router = 0;
6827 u32 max_interval = 0;
6828 u32 min_interval = 0;
6830 u32 initial_count = 0;
6831 u32 initial_interval = 0;
6834 /* Parse args required to build the message */
6835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6837 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6838 sw_if_index_set = 1;
6839 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6840 sw_if_index_set = 1;
6841 else if (unformat (i, "maxint %d", &max_interval))
6843 else if (unformat (i, "minint %d", &min_interval))
6845 else if (unformat (i, "life %d", &lifetime))
6847 else if (unformat (i, "count %d", &initial_count))
6849 else if (unformat (i, "interval %d", &initial_interval))
6851 else if (unformat (i, "suppress") || unformat (i, "surpress"))
6853 else if (unformat (i, "managed"))
6855 else if (unformat (i, "other"))
6857 else if (unformat (i, "ll"))
6859 else if (unformat (i, "send"))
6861 else if (unformat (i, "cease"))
6863 else if (unformat (i, "isno"))
6865 else if (unformat (i, "def"))
6869 clib_warning ("parse error '%U'", format_unformat_error, i);
6874 if (sw_if_index_set == 0)
6876 errmsg ("missing interface name or sw_if_index\n");
6880 /* Construct the API message */
6881 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
6883 mp->sw_if_index = ntohl (sw_if_index);
6884 mp->max_interval = ntohl (max_interval);
6885 mp->min_interval = ntohl (min_interval);
6886 mp->lifetime = ntohl (lifetime);
6887 mp->initial_count = ntohl (initial_count);
6888 mp->initial_interval = ntohl (initial_interval);
6889 mp->suppress = suppress;
6890 mp->managed = managed;
6892 mp->ll_option = ll_option;
6893 mp->send_unicast = send_unicast;
6896 mp->default_router = default_router;
6901 /* Wait for a reply, return good/bad news */
6909 api_set_arp_neighbor_limit (vat_main_t * vam)
6911 unformat_input_t *i = vam->input;
6912 vl_api_set_arp_neighbor_limit_t *mp;
6918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6920 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
6922 else if (unformat (i, "ipv6"))
6926 clib_warning ("parse error '%U'", format_unformat_error, i);
6933 errmsg ("missing limit value\n");
6937 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
6939 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
6940 mp->is_ipv6 = is_ipv6;
6949 api_l2_patch_add_del (vat_main_t * vam)
6951 unformat_input_t *i = vam->input;
6952 vl_api_l2_patch_add_del_t *mp;
6955 u8 rx_sw_if_index_set = 0;
6957 u8 tx_sw_if_index_set = 0;
6960 /* Parse args required to build the message */
6961 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6963 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6964 rx_sw_if_index_set = 1;
6965 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6966 tx_sw_if_index_set = 1;
6967 else if (unformat (i, "rx"))
6969 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6971 if (unformat (i, "%U", unformat_sw_if_index, vam,
6973 rx_sw_if_index_set = 1;
6978 else if (unformat (i, "tx"))
6980 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6982 if (unformat (i, "%U", unformat_sw_if_index, vam,
6984 tx_sw_if_index_set = 1;
6989 else if (unformat (i, "del"))
6995 if (rx_sw_if_index_set == 0)
6997 errmsg ("missing rx interface name or rx_sw_if_index\n");
7001 if (tx_sw_if_index_set == 0)
7003 errmsg ("missing tx interface name or tx_sw_if_index\n");
7007 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7009 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7010 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7011 mp->is_add = is_add;
7020 api_trace_profile_add (vat_main_t * vam)
7022 unformat_input_t *input = vam->input;
7023 vl_api_trace_profile_add_t *mp;
7026 u32 trace_option_elts = 0;
7027 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
7028 int has_pow_option = 0;
7029 int has_ppc_option = 0;
7031 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7033 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
7034 "trace-tsp %d node-id 0x%x app-data 0x%x",
7035 &id, &trace_type, &trace_option_elts, &trace_tsp,
7036 &node_id, &app_data))
7038 else if (unformat (input, "pow"))
7040 else if (unformat (input, "ppc encap"))
7041 has_ppc_option = PPC_ENCAP;
7042 else if (unformat (input, "ppc decap"))
7043 has_ppc_option = PPC_DECAP;
7044 else if (unformat (input, "ppc none"))
7045 has_ppc_option = PPC_NONE;
7049 M (TRACE_PROFILE_ADD, trace_profile_add);
7050 mp->id = htons (id);
7051 mp->trace_type = trace_type;
7052 mp->trace_num_elt = trace_option_elts;
7053 mp->trace_ppc = has_ppc_option;
7054 mp->trace_app_data = htonl (app_data);
7055 mp->pow_enable = has_pow_option;
7056 mp->trace_tsp = trace_tsp;
7057 mp->node_id = htonl (node_id);
7067 api_trace_profile_apply (vat_main_t * vam)
7069 unformat_input_t *input = vam->input;
7070 vl_api_trace_profile_apply_t *mp;
7073 u32 mask_width = ~0;
7080 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7082 if (unformat (input, "%U/%d", unformat_ip6_address, &addr, &mask_width))
7084 else if (unformat (input, "id %d", &id))
7086 else if (unformat (input, "vrf-id %d", &vrf_id))
7088 else if (unformat (input, "add"))
7090 else if (unformat (input, "pop"))
7092 else if (unformat (input, "none"))
7098 if ((is_add + is_pop + is_none) != 1)
7100 errmsg ("One of (add, pop, none) required");
7103 if (mask_width == ~0)
7105 errmsg ("<address>/<mask-width> required");
7108 M (TRACE_PROFILE_APPLY, trace_profile_apply);
7109 clib_memcpy (mp->dest_ipv6, &addr, sizeof (mp->dest_ipv6));
7110 mp->id = htons (id);
7111 mp->prefix_length = htonl (mask_width);
7112 mp->vrf_id = htonl (vrf_id);
7114 mp->trace_op = IOAM_HBYH_ADD;
7116 mp->trace_op = IOAM_HBYH_POP;
7118 mp->trace_op = IOAM_HBYH_MOD;
7132 api_trace_profile_del (vat_main_t * vam)
7134 vl_api_trace_profile_del_t *mp;
7137 M (TRACE_PROFILE_DEL, trace_profile_del);
7144 api_sr_tunnel_add_del (vat_main_t * vam)
7146 unformat_input_t *i = vam->input;
7147 vl_api_sr_tunnel_add_del_t *mp;
7151 ip6_address_t src_address;
7152 int src_address_set = 0;
7153 ip6_address_t dst_address;
7155 int dst_address_set = 0;
7157 u32 rx_table_id = 0;
7158 u32 tx_table_id = 0;
7159 ip6_address_t *segments = 0;
7160 ip6_address_t *this_seg;
7161 ip6_address_t *tags = 0;
7162 ip6_address_t *this_tag;
7163 ip6_address_t next_address, tag;
7165 u8 *policy_name = 0;
7167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7169 if (unformat (i, "del"))
7171 else if (unformat (i, "name %s", &name))
7173 else if (unformat (i, "policy %s", &policy_name))
7175 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7177 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7179 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7180 src_address_set = 1;
7181 else if (unformat (i, "dst %U/%d",
7182 unformat_ip6_address, &dst_address, &dst_mask_width))
7183 dst_address_set = 1;
7184 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7186 vec_add2 (segments, this_seg, 1);
7187 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7188 sizeof (*this_seg));
7190 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7192 vec_add2 (tags, this_tag, 1);
7193 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7195 else if (unformat (i, "clean"))
7196 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7197 else if (unformat (i, "protected"))
7198 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7199 else if (unformat (i, "InPE %d", &pl_index))
7201 if (pl_index <= 0 || pl_index > 4)
7203 pl_index_range_error:
7204 errmsg ("pl index %d out of range\n", pl_index);
7208 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7210 else if (unformat (i, "EgPE %d", &pl_index))
7212 if (pl_index <= 0 || pl_index > 4)
7213 goto pl_index_range_error;
7215 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7217 else if (unformat (i, "OrgSrc %d", &pl_index))
7219 if (pl_index <= 0 || pl_index > 4)
7220 goto pl_index_range_error;
7222 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7228 if (!src_address_set)
7230 errmsg ("src address required\n");
7234 if (!dst_address_set)
7236 errmsg ("dst address required\n");
7242 errmsg ("at least one sr segment required\n");
7246 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7247 vec_len (segments) * sizeof (ip6_address_t)
7248 + vec_len (tags) * sizeof (ip6_address_t));
7250 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7251 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7252 mp->dst_mask_width = dst_mask_width;
7253 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7254 mp->n_segments = vec_len (segments);
7255 mp->n_tags = vec_len (tags);
7256 mp->is_add = is_del == 0;
7257 clib_memcpy (mp->segs_and_tags, segments,
7258 vec_len (segments) * sizeof (ip6_address_t));
7259 clib_memcpy (mp->segs_and_tags +
7260 vec_len (segments) * sizeof (ip6_address_t), tags,
7261 vec_len (tags) * sizeof (ip6_address_t));
7263 mp->outer_vrf_id = ntohl (rx_table_id);
7264 mp->inner_vrf_id = ntohl (tx_table_id);
7265 memcpy (mp->name, name, vec_len (name));
7266 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7268 vec_free (segments);
7277 api_sr_policy_add_del (vat_main_t * vam)
7279 unformat_input_t *input = vam->input;
7280 vl_api_sr_policy_add_del_t *mp;
7284 u8 *tunnel_name = 0;
7285 u8 **tunnel_names = 0;
7290 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7291 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7293 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7295 if (unformat (input, "del"))
7297 else if (unformat (input, "name %s", &name))
7299 else if (unformat (input, "tunnel %s", &tunnel_name))
7303 vec_add1 (tunnel_names, tunnel_name);
7305 - length = #bytes to store in serial vector
7306 - +1 = byte to store that length
7308 tunnel_names_length += (vec_len (tunnel_name) + 1);
7319 errmsg ("policy name required\n");
7323 if ((!tunnel_set) && (!is_del))
7325 errmsg ("tunnel name required\n");
7329 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7333 mp->is_add = !is_del;
7335 memcpy (mp->name, name, vec_len (name));
7336 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7337 u8 *serial_orig = 0;
7338 vec_validate (serial_orig, tunnel_names_length);
7339 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7340 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7342 for (j = 0; j < vec_len (tunnel_names); j++)
7344 tun_name_len = vec_len (tunnel_names[j]);
7345 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7346 serial_orig += 1; // Move along one byte to store the actual tunnel name
7347 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7348 serial_orig += tun_name_len; // Advance past the copy
7350 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7352 vec_free (tunnel_names);
7353 vec_free (tunnel_name);
7361 api_sr_multicast_map_add_del (vat_main_t * vam)
7363 unformat_input_t *input = vam->input;
7364 vl_api_sr_multicast_map_add_del_t *mp;
7367 ip6_address_t multicast_address;
7368 u8 *policy_name = 0;
7369 int multicast_address_set = 0;
7371 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7373 if (unformat (input, "del"))
7377 (input, "address %U", unformat_ip6_address, &multicast_address))
7378 multicast_address_set = 1;
7379 else if (unformat (input, "sr-policy %s", &policy_name))
7385 if (!is_del && !policy_name)
7387 errmsg ("sr-policy name required\n");
7392 if (!multicast_address_set)
7394 errmsg ("address required\n");
7398 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7400 mp->is_add = !is_del;
7401 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7402 clib_memcpy (mp->multicast_address, &multicast_address,
7403 sizeof (mp->multicast_address));
7406 vec_free (policy_name);
7414 #define foreach_ip4_proto_field \
7425 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7427 u8 **maskp = va_arg (*args, u8 **);
7429 u8 found_something = 0;
7432 #define _(a) u8 a=0;
7433 foreach_ip4_proto_field;
7439 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7441 if (unformat (input, "version"))
7443 else if (unformat (input, "hdr_length"))
7445 else if (unformat (input, "src"))
7447 else if (unformat (input, "dst"))
7449 else if (unformat (input, "proto"))
7452 #define _(a) else if (unformat (input, #a)) a=1;
7453 foreach_ip4_proto_field
7459 #define _(a) found_something += a;
7460 foreach_ip4_proto_field;
7463 if (found_something == 0)
7466 vec_validate (mask, sizeof (*ip) - 1);
7468 ip = (ip4_header_t *) mask;
7470 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7471 foreach_ip4_proto_field;
7474 ip->ip_version_and_header_length = 0;
7477 ip->ip_version_and_header_length |= 0xF0;
7480 ip->ip_version_and_header_length |= 0x0F;
7486 #define foreach_ip6_proto_field \
7494 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7496 u8 **maskp = va_arg (*args, u8 **);
7498 u8 found_something = 0;
7500 u32 ip_version_traffic_class_and_flow_label;
7502 #define _(a) u8 a=0;
7503 foreach_ip6_proto_field;
7506 u8 traffic_class = 0;
7509 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7511 if (unformat (input, "version"))
7513 else if (unformat (input, "traffic-class"))
7515 else if (unformat (input, "flow-label"))
7517 else if (unformat (input, "src"))
7519 else if (unformat (input, "dst"))
7521 else if (unformat (input, "proto"))
7524 #define _(a) else if (unformat (input, #a)) a=1;
7525 foreach_ip6_proto_field
7531 #define _(a) found_something += a;
7532 foreach_ip6_proto_field;
7535 if (found_something == 0)
7538 vec_validate (mask, sizeof (*ip) - 1);
7540 ip = (ip6_header_t *) mask;
7542 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7543 foreach_ip6_proto_field;
7546 ip_version_traffic_class_and_flow_label = 0;
7549 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7552 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7555 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7557 ip->ip_version_traffic_class_and_flow_label =
7558 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7565 unformat_l3_mask (unformat_input_t * input, va_list * args)
7567 u8 **maskp = va_arg (*args, u8 **);
7569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7571 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7573 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7582 unformat_l2_mask (unformat_input_t * input, va_list * args)
7584 u8 **maskp = va_arg (*args, u8 **);
7599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7601 if (unformat (input, "src"))
7603 else if (unformat (input, "dst"))
7605 else if (unformat (input, "proto"))
7607 else if (unformat (input, "tag1"))
7609 else if (unformat (input, "tag2"))
7611 else if (unformat (input, "ignore-tag1"))
7613 else if (unformat (input, "ignore-tag2"))
7615 else if (unformat (input, "cos1"))
7617 else if (unformat (input, "cos2"))
7619 else if (unformat (input, "dot1q"))
7621 else if (unformat (input, "dot1ad"))
7626 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7627 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7630 if (tag1 || ignore_tag1 || cos1 || dot1q)
7632 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7635 vec_validate (mask, len - 1);
7638 memset (mask, 0xff, 6);
7641 memset (mask + 6, 0xff, 6);
7645 /* inner vlan tag */
7654 mask[21] = mask[20] = 0xff;
7675 mask[16] = mask[17] = 0xff;
7685 mask[12] = mask[13] = 0xff;
7692 unformat_classify_mask (unformat_input_t * input, va_list * args)
7694 u8 **maskp = va_arg (*args, u8 **);
7695 u32 *skipp = va_arg (*args, u32 *);
7696 u32 *matchp = va_arg (*args, u32 *);
7703 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7705 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7707 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7709 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7715 if (mask || l2 || l3)
7719 /* "With a free Ethernet header in every package" */
7721 vec_validate (l2, 13);
7725 vec_append (mask, l3);
7730 /* Scan forward looking for the first significant mask octet */
7731 for (i = 0; i < vec_len (mask); i++)
7735 /* compute (skip, match) params */
7736 *skipp = i / sizeof (u32x4);
7737 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7739 /* Pad mask to an even multiple of the vector size */
7740 while (vec_len (mask) % sizeof (u32x4))
7743 match = vec_len (mask) / sizeof (u32x4);
7745 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7747 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7748 if (*tmp || *(tmp + 1))
7753 clib_warning ("BUG: match 0");
7755 _vec_len (mask) = match * sizeof (u32x4);
7766 #define foreach_l2_next \
7768 _(ethernet, ETHERNET_INPUT) \
7773 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7775 u32 *miss_next_indexp = va_arg (*args, u32 *);
7780 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
7784 if (unformat (input, "%d", &tmp))
7793 *miss_next_indexp = next_index;
7797 #define foreach_ip_next \
7804 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7806 u32 *miss_next_indexp = va_arg (*args, u32 *);
7811 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7815 if (unformat (input, "%d", &tmp))
7824 *miss_next_indexp = next_index;
7828 #define foreach_acl_next \
7832 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7834 u32 *miss_next_indexp = va_arg (*args, u32 *);
7839 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7843 if (unformat (input, "permit"))
7848 else if (unformat (input, "%d", &tmp))
7857 *miss_next_indexp = next_index;
7862 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7864 u32 *r = va_arg (*args, u32 *);
7866 if (unformat (input, "conform-color"))
7867 *r = POLICE_CONFORM;
7868 else if (unformat (input, "exceed-color"))
7877 api_classify_add_del_table (vat_main_t * vam)
7879 unformat_input_t *i = vam->input;
7880 vl_api_classify_add_del_table_t *mp;
7886 u32 table_index = ~0;
7887 u32 next_table_index = ~0;
7888 u32 miss_next_index = ~0;
7889 u32 memory_size = 32 << 20;
7893 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7895 if (unformat (i, "del"))
7897 else if (unformat (i, "buckets %d", &nbuckets))
7899 else if (unformat (i, "memory_size %d", &memory_size))
7901 else if (unformat (i, "skip %d", &skip))
7903 else if (unformat (i, "match %d", &match))
7905 else if (unformat (i, "table %d", &table_index))
7907 else if (unformat (i, "mask %U", unformat_classify_mask,
7908 &mask, &skip, &match))
7910 else if (unformat (i, "next-table %d", &next_table_index))
7912 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
7915 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
7918 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
7925 if (is_add && mask == 0)
7927 errmsg ("Mask required\n");
7931 if (is_add && skip == ~0)
7933 errmsg ("skip count required\n");
7937 if (is_add && match == ~0)
7939 errmsg ("match count required\n");
7943 if (!is_add && table_index == ~0)
7945 errmsg ("table index required for delete\n");
7949 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
7951 mp->is_add = is_add;
7952 mp->table_index = ntohl (table_index);
7953 mp->nbuckets = ntohl (nbuckets);
7954 mp->memory_size = ntohl (memory_size);
7955 mp->skip_n_vectors = ntohl (skip);
7956 mp->match_n_vectors = ntohl (match);
7957 mp->next_table_index = ntohl (next_table_index);
7958 mp->miss_next_index = ntohl (miss_next_index);
7959 clib_memcpy (mp->mask, mask, vec_len (mask));
7969 unformat_ip4_match (unformat_input_t * input, va_list * args)
7971 u8 **matchp = va_arg (*args, u8 **);
7978 int src = 0, dst = 0;
7979 ip4_address_t src_val, dst_val;
7986 int fragment_id = 0;
7987 u32 fragment_id_val;
7993 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7995 if (unformat (input, "version %d", &version_val))
7997 else if (unformat (input, "hdr_length %d", &hdr_length_val))
7999 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8001 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8003 else if (unformat (input, "proto %d", &proto_val))
8005 else if (unformat (input, "tos %d", &tos_val))
8007 else if (unformat (input, "length %d", &length_val))
8009 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8011 else if (unformat (input, "ttl %d", &ttl_val))
8013 else if (unformat (input, "checksum %d", &checksum_val))
8019 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8020 + ttl + checksum == 0)
8024 * Aligned because we use the real comparison functions
8026 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8028 ip = (ip4_header_t *) match;
8030 /* These are realistically matched in practice */
8032 ip->src_address.as_u32 = src_val.as_u32;
8035 ip->dst_address.as_u32 = dst_val.as_u32;
8038 ip->protocol = proto_val;
8041 /* These are not, but they're included for completeness */
8043 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8046 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8052 ip->length = length_val;
8058 ip->checksum = checksum_val;
8065 unformat_ip6_match (unformat_input_t * input, va_list * args)
8067 u8 **matchp = va_arg (*args, u8 **);
8072 u8 traffic_class = 0;
8073 u32 traffic_class_val = 0;
8076 int src = 0, dst = 0;
8077 ip6_address_t src_val, dst_val;
8080 int payload_length = 0;
8081 u32 payload_length_val;
8084 u32 ip_version_traffic_class_and_flow_label;
8086 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8088 if (unformat (input, "version %d", &version_val))
8090 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8092 else if (unformat (input, "flow_label %d", &flow_label_val))
8094 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8096 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8098 else if (unformat (input, "proto %d", &proto_val))
8100 else if (unformat (input, "payload_length %d", &payload_length_val))
8102 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8108 if (version + traffic_class + flow_label + src + dst + proto +
8109 payload_length + hop_limit == 0)
8113 * Aligned because we use the real comparison functions
8115 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8117 ip = (ip6_header_t *) match;
8120 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8123 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8126 ip->protocol = proto_val;
8128 ip_version_traffic_class_and_flow_label = 0;
8131 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8134 ip_version_traffic_class_and_flow_label |=
8135 (traffic_class_val & 0xFF) << 20;
8138 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8140 ip->ip_version_traffic_class_and_flow_label =
8141 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8144 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8147 ip->hop_limit = hop_limit_val;
8154 unformat_l3_match (unformat_input_t * input, va_list * args)
8156 u8 **matchp = va_arg (*args, u8 **);
8158 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8160 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8162 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8171 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8173 u8 *tagp = va_arg (*args, u8 *);
8176 if (unformat (input, "%d", &tag))
8178 tagp[0] = (tag >> 8) & 0x0F;
8179 tagp[1] = tag & 0xFF;
8187 unformat_l2_match (unformat_input_t * input, va_list * args)
8189 u8 **matchp = va_arg (*args, u8 **);
8209 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8211 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8214 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8216 else if (unformat (input, "proto %U",
8217 unformat_ethernet_type_host_byte_order, &proto_val))
8219 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8221 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8223 else if (unformat (input, "ignore-tag1"))
8225 else if (unformat (input, "ignore-tag2"))
8227 else if (unformat (input, "cos1 %d", &cos1_val))
8229 else if (unformat (input, "cos2 %d", &cos2_val))
8234 if ((src + dst + proto + tag1 + tag2 +
8235 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8238 if (tag1 || ignore_tag1 || cos1)
8240 if (tag2 || ignore_tag2 || cos2)
8243 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8246 clib_memcpy (match, dst_val, 6);
8249 clib_memcpy (match + 6, src_val, 6);
8253 /* inner vlan tag */
8254 match[19] = tag2_val[1];
8255 match[18] = tag2_val[0];
8257 match[18] |= (cos2_val & 0x7) << 5;
8260 match[21] = proto_val & 0xff;
8261 match[20] = proto_val >> 8;
8265 match[15] = tag1_val[1];
8266 match[14] = tag1_val[0];
8269 match[14] |= (cos1_val & 0x7) << 5;
8275 match[15] = tag1_val[1];
8276 match[14] = tag1_val[0];
8279 match[17] = proto_val & 0xff;
8280 match[16] = proto_val >> 8;
8283 match[14] |= (cos1_val & 0x7) << 5;
8289 match[18] |= (cos2_val & 0x7) << 5;
8291 match[14] |= (cos1_val & 0x7) << 5;
8294 match[13] = proto_val & 0xff;
8295 match[12] = proto_val >> 8;
8304 unformat_classify_match (unformat_input_t * input, va_list * args)
8306 u8 **matchp = va_arg (*args, u8 **);
8307 u32 skip_n_vectors = va_arg (*args, u32);
8308 u32 match_n_vectors = va_arg (*args, u32);
8314 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8316 if (unformat (input, "hex %U", unformat_hex_string, &match))
8318 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8320 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8326 if (match || l2 || l3)
8330 /* "Win a free Ethernet header in every packet" */
8332 vec_validate_aligned (l2, 13, sizeof (u32x4));
8336 vec_append_aligned (match, l3, sizeof (u32x4));
8341 /* Make sure the vector is big enough even if key is all 0's */
8342 vec_validate_aligned
8343 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8346 /* Set size, include skipped vectors */
8347 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8358 api_classify_add_del_session (vat_main_t * vam)
8360 unformat_input_t *i = vam->input;
8361 vl_api_classify_add_del_session_t *mp;
8363 u32 table_index = ~0;
8364 u32 hit_next_index = ~0;
8365 u32 opaque_index = ~0;
8369 u32 skip_n_vectors = 0;
8370 u32 match_n_vectors = 0;
8373 * Warning: you have to supply skip_n and match_n
8374 * because the API client cant simply look at the classify
8378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8380 if (unformat (i, "del"))
8382 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8385 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8388 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8391 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8393 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8395 else if (unformat (i, "opaque-index %d", &opaque_index))
8397 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8399 else if (unformat (i, "match_n %d", &match_n_vectors))
8401 else if (unformat (i, "match %U", unformat_classify_match,
8402 &match, skip_n_vectors, match_n_vectors))
8404 else if (unformat (i, "advance %d", &advance))
8406 else if (unformat (i, "table-index %d", &table_index))
8412 if (table_index == ~0)
8414 errmsg ("Table index required\n");
8418 if (is_add && match == 0)
8420 errmsg ("Match value required\n");
8424 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8426 mp->is_add = is_add;
8427 mp->table_index = ntohl (table_index);
8428 mp->hit_next_index = ntohl (hit_next_index);
8429 mp->opaque_index = ntohl (opaque_index);
8430 mp->advance = ntohl (advance);
8431 clib_memcpy (mp->match, match, vec_len (match));
8440 api_classify_set_interface_ip_table (vat_main_t * vam)
8442 unformat_input_t *i = vam->input;
8443 vl_api_classify_set_interface_ip_table_t *mp;
8446 int sw_if_index_set;
8447 u32 table_index = ~0;
8450 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8452 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8453 sw_if_index_set = 1;
8454 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8455 sw_if_index_set = 1;
8456 else if (unformat (i, "table %d", &table_index))
8460 clib_warning ("parse error '%U'", format_unformat_error, i);
8465 if (sw_if_index_set == 0)
8467 errmsg ("missing interface name or sw_if_index\n");
8472 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8474 mp->sw_if_index = ntohl (sw_if_index);
8475 mp->table_index = ntohl (table_index);
8476 mp->is_ipv6 = is_ipv6;
8485 api_classify_set_interface_l2_tables (vat_main_t * vam)
8487 unformat_input_t *i = vam->input;
8488 vl_api_classify_set_interface_l2_tables_t *mp;
8491 int sw_if_index_set;
8492 u32 ip4_table_index = ~0;
8493 u32 ip6_table_index = ~0;
8494 u32 other_table_index = ~0;
8496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8498 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8499 sw_if_index_set = 1;
8500 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8501 sw_if_index_set = 1;
8502 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8504 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8506 else if (unformat (i, "other-table %d", &other_table_index))
8510 clib_warning ("parse error '%U'", format_unformat_error, i);
8515 if (sw_if_index_set == 0)
8517 errmsg ("missing interface name or sw_if_index\n");
8522 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8524 mp->sw_if_index = ntohl (sw_if_index);
8525 mp->ip4_table_index = ntohl (ip4_table_index);
8526 mp->ip6_table_index = ntohl (ip6_table_index);
8527 mp->other_table_index = ntohl (other_table_index);
8537 api_ipfix_enable (vat_main_t * vam)
8539 unformat_input_t *i = vam->input;
8540 vl_api_ipfix_enable_t *mp;
8541 ip4_address_t collector_address;
8542 u8 collector_address_set = 0;
8543 u32 collector_port = ~0;
8544 ip4_address_t src_address;
8545 u8 src_address_set = 0;
8548 u32 template_interval = ~0;
8551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8553 if (unformat (i, "collector_address %U", unformat_ip4_address,
8554 &collector_address))
8555 collector_address_set = 1;
8556 else if (unformat (i, "collector_port %d", &collector_port))
8558 else if (unformat (i, "src_address %U", unformat_ip4_address,
8560 src_address_set = 1;
8561 else if (unformat (i, "vrf_id %d", &vrf_id))
8563 else if (unformat (i, "path_mtu %d", &path_mtu))
8565 else if (unformat (i, "template_interval %d", &template_interval))
8571 if (collector_address_set == 0)
8573 errmsg ("collector_address required\n");
8577 if (src_address_set == 0)
8579 errmsg ("src_address required\n");
8583 M (IPFIX_ENABLE, ipfix_enable);
8585 memcpy (mp->collector_address, collector_address.data,
8586 sizeof (collector_address.data));
8587 mp->collector_port = htons ((u16) collector_port);
8588 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8589 mp->vrf_id = htonl (vrf_id);
8590 mp->path_mtu = htonl (path_mtu);
8591 mp->template_interval = htonl (template_interval);
8599 api_get_node_index (vat_main_t * vam)
8601 unformat_input_t *i = vam->input;
8602 vl_api_get_node_index_t *mp;
8606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8608 if (unformat (i, "node %s", &name))
8615 errmsg ("node name required\n");
8618 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8620 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8624 M (GET_NODE_INDEX, get_node_index);
8625 clib_memcpy (mp->node_name, name, vec_len (name));
8635 api_get_next_index (vat_main_t * vam)
8637 unformat_input_t *i = vam->input;
8638 vl_api_get_next_index_t *mp;
8640 u8 *node_name = 0, *next_node_name = 0;
8642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8644 if (unformat (i, "node-name %s", &node_name))
8646 else if (unformat (i, "next-node-name %s", &next_node_name))
8652 errmsg ("node name required\n");
8655 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8657 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8661 if (next_node_name == 0)
8663 errmsg ("next node name required\n");
8666 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8668 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8672 M (GET_NEXT_INDEX, get_next_index);
8673 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8674 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8675 vec_free (node_name);
8676 vec_free (next_node_name);
8685 api_add_node_next (vat_main_t * vam)
8687 unformat_input_t *i = vam->input;
8688 vl_api_add_node_next_t *mp;
8693 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8695 if (unformat (i, "node %s", &name))
8697 else if (unformat (i, "next %s", &next))
8704 errmsg ("node name required\n");
8707 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8709 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8714 errmsg ("next node required\n");
8717 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8719 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8723 M (ADD_NODE_NEXT, add_node_next);
8724 clib_memcpy (mp->node_name, name, vec_len (name));
8725 clib_memcpy (mp->next_name, next, vec_len (next));
8736 api_l2tpv3_create_tunnel (vat_main_t * vam)
8738 unformat_input_t *i = vam->input;
8739 ip6_address_t client_address, our_address;
8740 int client_address_set = 0;
8741 int our_address_set = 0;
8742 u32 local_session_id = 0;
8743 u32 remote_session_id = 0;
8744 u64 local_cookie = 0;
8745 u64 remote_cookie = 0;
8746 u8 l2_sublayer_present = 0;
8747 vl_api_l2tpv3_create_tunnel_t *mp;
8750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8752 if (unformat (i, "client_address %U", unformat_ip6_address,
8754 client_address_set = 1;
8755 else if (unformat (i, "our_address %U", unformat_ip6_address,
8757 our_address_set = 1;
8758 else if (unformat (i, "local_session_id %d", &local_session_id))
8760 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8762 else if (unformat (i, "local_cookie %lld", &local_cookie))
8764 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8766 else if (unformat (i, "l2-sublayer-present"))
8767 l2_sublayer_present = 1;
8772 if (client_address_set == 0)
8774 errmsg ("client_address required\n");
8778 if (our_address_set == 0)
8780 errmsg ("our_address required\n");
8784 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8786 clib_memcpy (mp->client_address, client_address.as_u8,
8787 sizeof (mp->client_address));
8789 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8791 mp->local_session_id = ntohl (local_session_id);
8792 mp->remote_session_id = ntohl (remote_session_id);
8793 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8794 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8795 mp->l2_sublayer_present = l2_sublayer_present;
8805 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8807 unformat_input_t *i = vam->input;
8809 u8 sw_if_index_set = 0;
8810 u64 new_local_cookie = 0;
8811 u64 new_remote_cookie = 0;
8812 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
8815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8817 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8818 sw_if_index_set = 1;
8819 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8820 sw_if_index_set = 1;
8821 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
8823 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
8829 if (sw_if_index_set == 0)
8831 errmsg ("missing interface name or sw_if_index\n");
8835 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
8837 mp->sw_if_index = ntohl (sw_if_index);
8838 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
8839 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
8848 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
8850 unformat_input_t *i = vam->input;
8851 vl_api_l2tpv3_interface_enable_disable_t *mp;
8854 u8 sw_if_index_set = 0;
8855 u8 enable_disable = 1;
8857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8859 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8860 sw_if_index_set = 1;
8861 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8862 sw_if_index_set = 1;
8863 else if (unformat (i, "enable"))
8865 else if (unformat (i, "disable"))
8871 if (sw_if_index_set == 0)
8873 errmsg ("missing interface name or sw_if_index\n");
8877 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
8879 mp->sw_if_index = ntohl (sw_if_index);
8880 mp->enable_disable = enable_disable;
8889 api_l2tpv3_set_lookup_key (vat_main_t * vam)
8891 unformat_input_t *i = vam->input;
8892 vl_api_l2tpv3_set_lookup_key_t *mp;
8896 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8898 if (unformat (i, "lookup_v6_src"))
8899 key = L2T_LOOKUP_SRC_ADDRESS;
8900 else if (unformat (i, "lookup_v6_dst"))
8901 key = L2T_LOOKUP_DST_ADDRESS;
8902 else if (unformat (i, "lookup_session_id"))
8903 key = L2T_LOOKUP_SESSION_ID;
8908 if (key == (u8) ~ 0)
8910 errmsg ("l2tp session lookup key unset\n");
8914 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
8924 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
8925 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8927 vat_main_t *vam = &vat_main;
8929 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
8930 format_ip6_address, mp->our_address,
8931 format_ip6_address, mp->client_address,
8932 clib_net_to_host_u32 (mp->sw_if_index));
8935 " local cookies %016llx %016llx remote cookie %016llx\n",
8936 clib_net_to_host_u64 (mp->local_cookie[0]),
8937 clib_net_to_host_u64 (mp->local_cookie[1]),
8938 clib_net_to_host_u64 (mp->remote_cookie));
8940 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
8941 clib_net_to_host_u32 (mp->local_session_id),
8942 clib_net_to_host_u32 (mp->remote_session_id));
8944 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
8945 mp->l2_sublayer_present ? "preset" : "absent");
8949 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
8950 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8952 vat_main_t *vam = &vat_main;
8953 vat_json_node_t *node = NULL;
8954 struct in6_addr addr;
8956 if (VAT_JSON_ARRAY != vam->json_tree.type)
8958 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8959 vat_json_init_array (&vam->json_tree);
8961 node = vat_json_array_add (&vam->json_tree);
8963 vat_json_init_object (node);
8965 clib_memcpy (&addr, mp->our_address, sizeof (addr));
8966 vat_json_object_add_ip6 (node, "our_address", addr);
8967 clib_memcpy (&addr, mp->client_address, sizeof (addr));
8968 vat_json_object_add_ip6 (node, "client_address", addr);
8970 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
8971 vat_json_init_array (lc);
8972 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
8973 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
8974 vat_json_object_add_uint (node, "remote_cookie",
8975 clib_net_to_host_u64 (mp->remote_cookie));
8977 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
8978 vat_json_object_add_uint (node, "local_session_id",
8979 clib_net_to_host_u32 (mp->local_session_id));
8980 vat_json_object_add_uint (node, "remote_session_id",
8981 clib_net_to_host_u32 (mp->remote_session_id));
8982 vat_json_object_add_string_copy (node, "l2_sublayer",
8983 mp->l2_sublayer_present ? (u8 *) "present"
8988 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
8990 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
8993 /* Get list of l2tpv3-tunnel interfaces */
8994 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
8997 /* Use a control ping for synchronization */
8999 vl_api_control_ping_t *mp;
9000 M (CONTROL_PING, control_ping);
9007 static void vl_api_sw_interface_tap_details_t_handler
9008 (vl_api_sw_interface_tap_details_t * mp)
9010 vat_main_t *vam = &vat_main;
9012 fformat (vam->ofp, "%-16s %d\n",
9013 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9016 static void vl_api_sw_interface_tap_details_t_handler_json
9017 (vl_api_sw_interface_tap_details_t * mp)
9019 vat_main_t *vam = &vat_main;
9020 vat_json_node_t *node = NULL;
9022 if (VAT_JSON_ARRAY != vam->json_tree.type)
9024 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9025 vat_json_init_array (&vam->json_tree);
9027 node = vat_json_array_add (&vam->json_tree);
9029 vat_json_init_object (node);
9030 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9031 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9035 api_sw_interface_tap_dump (vat_main_t * vam)
9037 vl_api_sw_interface_tap_dump_t *mp;
9040 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9041 /* Get list of tap interfaces */
9042 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9045 /* Use a control ping for synchronization */
9047 vl_api_control_ping_t *mp;
9048 M (CONTROL_PING, control_ping);
9054 static uword unformat_vxlan_decap_next
9055 (unformat_input_t * input, va_list * args)
9057 u32 *result = va_arg (*args, u32 *);
9060 if (unformat (input, "drop"))
9061 *result = VXLAN_INPUT_NEXT_DROP;
9062 else if (unformat (input, "ip4"))
9063 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9064 else if (unformat (input, "ip6"))
9065 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9066 else if (unformat (input, "l2"))
9067 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9068 else if (unformat (input, "%d", &tmp))
9076 api_vxlan_add_del_tunnel (vat_main_t * vam)
9078 unformat_input_t *line_input = vam->input;
9079 vl_api_vxlan_add_del_tunnel_t *mp;
9081 ip4_address_t src4, dst4;
9082 ip6_address_t src6, dst6;
9084 u8 ipv4_set = 0, ipv6_set = 0;
9087 u32 encap_vrf_id = 0;
9088 u32 decap_next_index = ~0;
9091 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9093 if (unformat (line_input, "del"))
9095 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9100 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9105 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9110 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9115 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9117 else if (unformat (line_input, "decap-next %U",
9118 unformat_vxlan_decap_next, &decap_next_index))
9120 else if (unformat (line_input, "vni %d", &vni))
9124 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9131 errmsg ("tunnel src address not specified\n");
9136 errmsg ("tunnel dst address not specified\n");
9140 if (ipv4_set && ipv6_set)
9142 errmsg ("both IPv4 and IPv6 addresses specified");
9146 if ((vni == 0) || (vni >> 24))
9148 errmsg ("vni not specified or out of range\n");
9152 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9156 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9157 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9161 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9162 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9164 mp->encap_vrf_id = ntohl (encap_vrf_id);
9165 mp->decap_next_index = ntohl (decap_next_index);
9166 mp->vni = ntohl (vni);
9167 mp->is_add = is_add;
9168 mp->is_ipv6 = ipv6_set;
9176 static void vl_api_vxlan_tunnel_details_t_handler
9177 (vl_api_vxlan_tunnel_details_t * mp)
9179 vat_main_t *vam = &vat_main;
9181 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9182 ntohl (mp->sw_if_index),
9183 format_ip46_address, &(mp->src_address[0]),
9185 format_ip46_address, &(mp->dst_address[0]),
9187 ntohl (mp->encap_vrf_id),
9188 ntohl (mp->decap_next_index), ntohl (mp->vni));
9191 static void vl_api_vxlan_tunnel_details_t_handler_json
9192 (vl_api_vxlan_tunnel_details_t * mp)
9194 vat_main_t *vam = &vat_main;
9195 vat_json_node_t *node = NULL;
9197 struct in6_addr ip6;
9199 if (VAT_JSON_ARRAY != vam->json_tree.type)
9201 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9202 vat_json_init_array (&vam->json_tree);
9204 node = vat_json_array_add (&vam->json_tree);
9206 vat_json_init_object (node);
9207 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9210 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9211 vat_json_object_add_ip6 (node, "src_address", ip6);
9212 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9213 vat_json_object_add_ip6 (node, "dst_address", ip6);
9217 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9218 vat_json_object_add_ip4 (node, "src_address", ip4);
9219 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9220 vat_json_object_add_ip4 (node, "dst_address", ip4);
9222 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9223 vat_json_object_add_uint (node, "decap_next_index",
9224 ntohl (mp->decap_next_index));
9225 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9226 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9230 api_vxlan_tunnel_dump (vat_main_t * vam)
9232 unformat_input_t *i = vam->input;
9233 vl_api_vxlan_tunnel_dump_t *mp;
9236 u8 sw_if_index_set = 0;
9238 /* Parse args required to build the message */
9239 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9241 if (unformat (i, "sw_if_index %d", &sw_if_index))
9242 sw_if_index_set = 1;
9247 if (sw_if_index_set == 0)
9252 if (!vam->json_output)
9254 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9255 "sw_if_index", "src_address", "dst_address",
9256 "encap_vrf_id", "decap_next_index", "vni");
9259 /* Get list of vxlan-tunnel interfaces */
9260 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9262 mp->sw_if_index = htonl (sw_if_index);
9266 /* Use a control ping for synchronization */
9268 vl_api_control_ping_t *mp;
9269 M (CONTROL_PING, control_ping);
9276 api_gre_add_del_tunnel (vat_main_t * vam)
9278 unformat_input_t *line_input = vam->input;
9279 vl_api_gre_add_del_tunnel_t *mp;
9281 ip4_address_t src4, dst4;
9285 u32 outer_fib_id = 0;
9287 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9289 if (unformat (line_input, "del"))
9291 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9293 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9295 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9299 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9306 errmsg ("tunnel src address not specified\n");
9311 errmsg ("tunnel dst address not specified\n");
9316 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9318 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9319 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9320 mp->outer_fib_id = ntohl (outer_fib_id);
9321 mp->is_add = is_add;
9329 static void vl_api_gre_tunnel_details_t_handler
9330 (vl_api_gre_tunnel_details_t * mp)
9332 vat_main_t *vam = &vat_main;
9334 fformat (vam->ofp, "%11d%15U%15U%14d\n",
9335 ntohl (mp->sw_if_index),
9336 format_ip4_address, &mp->src_address,
9337 format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id));
9340 static void vl_api_gre_tunnel_details_t_handler_json
9341 (vl_api_gre_tunnel_details_t * mp)
9343 vat_main_t *vam = &vat_main;
9344 vat_json_node_t *node = NULL;
9347 if (VAT_JSON_ARRAY != vam->json_tree.type)
9349 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9350 vat_json_init_array (&vam->json_tree);
9352 node = vat_json_array_add (&vam->json_tree);
9354 vat_json_init_object (node);
9355 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9356 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9357 vat_json_object_add_ip4 (node, "src_address", ip4);
9358 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9359 vat_json_object_add_ip4 (node, "dst_address", ip4);
9360 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9364 api_gre_tunnel_dump (vat_main_t * vam)
9366 unformat_input_t *i = vam->input;
9367 vl_api_gre_tunnel_dump_t *mp;
9370 u8 sw_if_index_set = 0;
9372 /* Parse args required to build the message */
9373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9375 if (unformat (i, "sw_if_index %d", &sw_if_index))
9376 sw_if_index_set = 1;
9381 if (sw_if_index_set == 0)
9386 if (!vam->json_output)
9388 fformat (vam->ofp, "%11s%15s%15s%14s\n",
9389 "sw_if_index", "src_address", "dst_address", "outer_fib_id");
9392 /* Get list of gre-tunnel interfaces */
9393 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9395 mp->sw_if_index = htonl (sw_if_index);
9399 /* Use a control ping for synchronization */
9401 vl_api_control_ping_t *mp;
9402 M (CONTROL_PING, control_ping);
9409 api_l2_fib_clear_table (vat_main_t * vam)
9411 // unformat_input_t * i = vam->input;
9412 vl_api_l2_fib_clear_table_t *mp;
9415 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9424 api_l2_interface_efp_filter (vat_main_t * vam)
9426 unformat_input_t *i = vam->input;
9427 vl_api_l2_interface_efp_filter_t *mp;
9431 u8 sw_if_index_set = 0;
9433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9435 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9436 sw_if_index_set = 1;
9437 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9438 sw_if_index_set = 1;
9439 else if (unformat (i, "enable"))
9441 else if (unformat (i, "disable"))
9445 clib_warning ("parse error '%U'", format_unformat_error, i);
9450 if (sw_if_index_set == 0)
9452 errmsg ("missing sw_if_index\n");
9456 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9458 mp->sw_if_index = ntohl (sw_if_index);
9459 mp->enable_disable = enable;
9467 #define foreach_vtr_op \
9468 _("disable", L2_VTR_DISABLED) \
9469 _("push-1", L2_VTR_PUSH_1) \
9470 _("push-2", L2_VTR_PUSH_2) \
9471 _("pop-1", L2_VTR_POP_1) \
9472 _("pop-2", L2_VTR_POP_2) \
9473 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9474 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9475 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9476 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9479 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9481 unformat_input_t *i = vam->input;
9482 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9485 u8 sw_if_index_set = 0;
9492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9494 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9495 sw_if_index_set = 1;
9496 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9497 sw_if_index_set = 1;
9498 else if (unformat (i, "vtr_op %d", &vtr_op))
9500 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9503 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9505 else if (unformat (i, "tag1 %d", &tag1))
9507 else if (unformat (i, "tag2 %d", &tag2))
9511 clib_warning ("parse error '%U'", format_unformat_error, i);
9516 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9518 errmsg ("missing vtr operation or sw_if_index\n");
9522 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9523 mp->sw_if_index = ntohl (sw_if_index);
9524 mp->vtr_op = ntohl (vtr_op);
9525 mp->push_dot1q = ntohl (push_dot1q);
9526 mp->tag1 = ntohl (tag1);
9527 mp->tag2 = ntohl (tag2);
9536 api_create_vhost_user_if (vat_main_t * vam)
9538 unformat_input_t *i = vam->input;
9539 vl_api_create_vhost_user_if_t *mp;
9543 u8 file_name_set = 0;
9544 u32 custom_dev_instance = ~0;
9546 u8 use_custom_mac = 0;
9548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9550 if (unformat (i, "socket %s", &file_name))
9554 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9556 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9558 else if (unformat (i, "server"))
9564 if (file_name_set == 0)
9566 errmsg ("missing socket file name\n");
9570 if (vec_len (file_name) > 255)
9572 errmsg ("socket file name too long\n");
9575 vec_add1 (file_name, 0);
9577 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9579 mp->is_server = is_server;
9580 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9581 vec_free (file_name);
9582 if (custom_dev_instance != ~0)
9585 mp->custom_dev_instance = ntohl (custom_dev_instance);
9587 mp->use_custom_mac = use_custom_mac;
9588 clib_memcpy (mp->mac_address, hwaddr, 6);
9597 api_modify_vhost_user_if (vat_main_t * vam)
9599 unformat_input_t *i = vam->input;
9600 vl_api_modify_vhost_user_if_t *mp;
9604 u8 file_name_set = 0;
9605 u32 custom_dev_instance = ~0;
9606 u8 sw_if_index_set = 0;
9607 u32 sw_if_index = (u32) ~ 0;
9609 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9611 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9612 sw_if_index_set = 1;
9613 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9614 sw_if_index_set = 1;
9615 else if (unformat (i, "socket %s", &file_name))
9619 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9621 else if (unformat (i, "server"))
9627 if (sw_if_index_set == 0)
9629 errmsg ("missing sw_if_index or interface name\n");
9633 if (file_name_set == 0)
9635 errmsg ("missing socket file name\n");
9639 if (vec_len (file_name) > 255)
9641 errmsg ("socket file name too long\n");
9644 vec_add1 (file_name, 0);
9646 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9648 mp->sw_if_index = ntohl (sw_if_index);
9649 mp->is_server = is_server;
9650 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9651 vec_free (file_name);
9652 if (custom_dev_instance != ~0)
9655 mp->custom_dev_instance = ntohl (custom_dev_instance);
9665 api_delete_vhost_user_if (vat_main_t * vam)
9667 unformat_input_t *i = vam->input;
9668 vl_api_delete_vhost_user_if_t *mp;
9670 u32 sw_if_index = ~0;
9671 u8 sw_if_index_set = 0;
9673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9675 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9676 sw_if_index_set = 1;
9677 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9678 sw_if_index_set = 1;
9683 if (sw_if_index_set == 0)
9685 errmsg ("missing sw_if_index or interface name\n");
9690 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9692 mp->sw_if_index = ntohl (sw_if_index);
9700 static void vl_api_sw_interface_vhost_user_details_t_handler
9701 (vl_api_sw_interface_vhost_user_details_t * mp)
9703 vat_main_t *vam = &vat_main;
9705 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9706 (char *) mp->interface_name,
9707 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9708 clib_net_to_host_u64 (mp->features), mp->is_server,
9709 ntohl (mp->num_regions), (char *) mp->sock_filename);
9710 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9713 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9714 (vl_api_sw_interface_vhost_user_details_t * mp)
9716 vat_main_t *vam = &vat_main;
9717 vat_json_node_t *node = NULL;
9719 if (VAT_JSON_ARRAY != vam->json_tree.type)
9721 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9722 vat_json_init_array (&vam->json_tree);
9724 node = vat_json_array_add (&vam->json_tree);
9726 vat_json_init_object (node);
9727 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9728 vat_json_object_add_string_copy (node, "interface_name",
9729 mp->interface_name);
9730 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9731 ntohl (mp->virtio_net_hdr_sz));
9732 vat_json_object_add_uint (node, "features",
9733 clib_net_to_host_u64 (mp->features));
9734 vat_json_object_add_uint (node, "is_server", mp->is_server);
9735 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9736 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9737 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9741 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9743 vl_api_sw_interface_vhost_user_dump_t *mp;
9746 "Interface name idx hdr_sz features server regions filename\n");
9748 /* Get list of vhost-user interfaces */
9749 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9752 /* Use a control ping for synchronization */
9754 vl_api_control_ping_t *mp;
9755 M (CONTROL_PING, control_ping);
9762 api_show_version (vat_main_t * vam)
9764 vl_api_show_version_t *mp;
9767 M (SHOW_VERSION, show_version);
9777 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9779 unformat_input_t *line_input = vam->input;
9780 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9782 ip4_address_t local4, remote4;
9783 ip6_address_t local6, remote6;
9785 u8 ipv4_set = 0, ipv6_set = 0;
9788 u32 encap_vrf_id = 0;
9789 u32 decap_vrf_id = 0;
9794 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9796 if (unformat (line_input, "del"))
9798 else if (unformat (line_input, "local %U",
9799 unformat_ip4_address, &local4))
9804 else if (unformat (line_input, "remote %U",
9805 unformat_ip4_address, &remote4))
9810 else if (unformat (line_input, "local %U",
9811 unformat_ip6_address, &local6))
9816 else if (unformat (line_input, "remote %U",
9817 unformat_ip6_address, &remote6))
9822 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9824 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
9826 else if (unformat (line_input, "vni %d", &vni))
9828 else if (unformat (line_input, "next-ip4"))
9830 else if (unformat (line_input, "next-ip6"))
9832 else if (unformat (line_input, "next-ethernet"))
9834 else if (unformat (line_input, "next-nsh"))
9838 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9845 errmsg ("tunnel local address not specified\n");
9848 if (remote_set == 0)
9850 errmsg ("tunnel remote address not specified\n");
9853 if (ipv4_set && ipv6_set)
9855 errmsg ("both IPv4 and IPv6 addresses specified");
9861 errmsg ("vni not specified\n");
9865 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
9870 clib_memcpy (&mp->local, &local6, sizeof (local6));
9871 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
9875 clib_memcpy (&mp->local, &local4, sizeof (local4));
9876 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
9879 mp->encap_vrf_id = ntohl (encap_vrf_id);
9880 mp->decap_vrf_id = ntohl (decap_vrf_id);
9881 mp->protocol = ntohl (protocol);
9882 mp->vni = ntohl (vni);
9883 mp->is_add = is_add;
9884 mp->is_ipv6 = ipv6_set;
9892 static void vl_api_vxlan_gpe_tunnel_details_t_handler
9893 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9895 vat_main_t *vam = &vat_main;
9897 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
9898 ntohl (mp->sw_if_index),
9899 format_ip46_address, &(mp->local[0]),
9900 format_ip46_address, &(mp->remote[0]),
9902 ntohl (mp->protocol),
9903 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
9906 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
9907 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9909 vat_main_t *vam = &vat_main;
9910 vat_json_node_t *node = NULL;
9912 struct in6_addr ip6;
9914 if (VAT_JSON_ARRAY != vam->json_tree.type)
9916 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9917 vat_json_init_array (&vam->json_tree);
9919 node = vat_json_array_add (&vam->json_tree);
9921 vat_json_init_object (node);
9922 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9925 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
9926 vat_json_object_add_ip6 (node, "local", ip6);
9927 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
9928 vat_json_object_add_ip6 (node, "remote", ip6);
9932 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
9933 vat_json_object_add_ip4 (node, "local", ip4);
9934 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
9935 vat_json_object_add_ip4 (node, "remote", ip4);
9937 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9938 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
9939 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9940 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
9941 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9945 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
9947 unformat_input_t *i = vam->input;
9948 vl_api_vxlan_gpe_tunnel_dump_t *mp;
9951 u8 sw_if_index_set = 0;
9953 /* Parse args required to build the message */
9954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9956 if (unformat (i, "sw_if_index %d", &sw_if_index))
9957 sw_if_index_set = 1;
9962 if (sw_if_index_set == 0)
9967 if (!vam->json_output)
9969 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
9970 "sw_if_index", "local", "remote", "vni",
9971 "protocol", "encap_vrf_id", "decap_vrf_id");
9974 /* Get list of vxlan-tunnel interfaces */
9975 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
9977 mp->sw_if_index = htonl (sw_if_index);
9981 /* Use a control ping for synchronization */
9983 vl_api_control_ping_t *mp;
9984 M (CONTROL_PING, control_ping);
9991 format_l2_fib_mac_address (u8 * s, va_list * args)
9993 u8 *a = va_arg (*args, u8 *);
9995 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
9996 a[2], a[3], a[4], a[5], a[6], a[7]);
9999 static void vl_api_l2_fib_table_entry_t_handler
10000 (vl_api_l2_fib_table_entry_t * mp)
10002 vat_main_t *vam = &vat_main;
10004 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10006 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10007 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10011 static void vl_api_l2_fib_table_entry_t_handler_json
10012 (vl_api_l2_fib_table_entry_t * mp)
10014 vat_main_t *vam = &vat_main;
10015 vat_json_node_t *node = NULL;
10017 if (VAT_JSON_ARRAY != vam->json_tree.type)
10019 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10020 vat_json_init_array (&vam->json_tree);
10022 node = vat_json_array_add (&vam->json_tree);
10024 vat_json_init_object (node);
10025 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10026 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10027 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10028 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10029 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10030 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10034 api_l2_fib_table_dump (vat_main_t * vam)
10036 unformat_input_t *i = vam->input;
10037 vl_api_l2_fib_table_dump_t *mp;
10042 /* Parse args required to build the message */
10043 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10045 if (unformat (i, "bd_id %d", &bd_id))
10051 if (bd_id_set == 0)
10053 errmsg ("missing bridge domain\n");
10058 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10060 /* Get list of l2 fib entries */
10061 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10063 mp->bd_id = ntohl (bd_id);
10066 /* Use a control ping for synchronization */
10068 vl_api_control_ping_t *mp;
10069 M (CONTROL_PING, control_ping);
10077 api_interface_name_renumber (vat_main_t * vam)
10079 unformat_input_t *line_input = vam->input;
10080 vl_api_interface_name_renumber_t *mp;
10081 u32 sw_if_index = ~0;
10083 u32 new_show_dev_instance = ~0;
10085 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10087 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10090 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10092 else if (unformat (line_input, "new_show_dev_instance %d",
10093 &new_show_dev_instance))
10099 if (sw_if_index == ~0)
10101 errmsg ("missing interface name or sw_if_index\n");
10105 if (new_show_dev_instance == ~0)
10107 errmsg ("missing new_show_dev_instance\n");
10111 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10113 mp->sw_if_index = ntohl (sw_if_index);
10114 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10121 api_want_ip4_arp_events (vat_main_t * vam)
10123 unformat_input_t *line_input = vam->input;
10124 vl_api_want_ip4_arp_events_t *mp;
10126 ip4_address_t address;
10127 int address_set = 0;
10128 u32 enable_disable = 1;
10130 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10132 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10134 else if (unformat (line_input, "del"))
10135 enable_disable = 0;
10140 if (address_set == 0)
10142 errmsg ("missing addresses\n");
10146 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10147 mp->enable_disable = enable_disable;
10148 mp->pid = getpid ();
10149 mp->address = address.as_u32;
10156 api_input_acl_set_interface (vat_main_t * vam)
10158 unformat_input_t *i = vam->input;
10159 vl_api_input_acl_set_interface_t *mp;
10162 int sw_if_index_set;
10163 u32 ip4_table_index = ~0;
10164 u32 ip6_table_index = ~0;
10165 u32 l2_table_index = ~0;
10168 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10170 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10171 sw_if_index_set = 1;
10172 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10173 sw_if_index_set = 1;
10174 else if (unformat (i, "del"))
10176 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10178 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10180 else if (unformat (i, "l2-table %d", &l2_table_index))
10184 clib_warning ("parse error '%U'", format_unformat_error, i);
10189 if (sw_if_index_set == 0)
10191 errmsg ("missing interface name or sw_if_index\n");
10195 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10197 mp->sw_if_index = ntohl (sw_if_index);
10198 mp->ip4_table_index = ntohl (ip4_table_index);
10199 mp->ip6_table_index = ntohl (ip6_table_index);
10200 mp->l2_table_index = ntohl (l2_table_index);
10201 mp->is_add = is_add;
10210 api_ip_address_dump (vat_main_t * vam)
10212 unformat_input_t *i = vam->input;
10213 vl_api_ip_address_dump_t *mp;
10214 u32 sw_if_index = ~0;
10215 u8 sw_if_index_set = 0;
10220 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10222 if (unformat (i, "sw_if_index %d", &sw_if_index))
10223 sw_if_index_set = 1;
10224 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10225 sw_if_index_set = 1;
10226 else if (unformat (i, "ipv4"))
10228 else if (unformat (i, "ipv6"))
10234 if (ipv4_set && ipv6_set)
10236 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10240 if ((!ipv4_set) && (!ipv6_set))
10242 errmsg ("no ipv4 nor ipv6 flag set\n");
10246 if (sw_if_index_set == 0)
10248 errmsg ("missing interface name or sw_if_index\n");
10252 vam->current_sw_if_index = sw_if_index;
10253 vam->is_ipv6 = ipv6_set;
10255 M (IP_ADDRESS_DUMP, ip_address_dump);
10256 mp->sw_if_index = ntohl (sw_if_index);
10257 mp->is_ipv6 = ipv6_set;
10260 /* Use a control ping for synchronization */
10262 vl_api_control_ping_t *mp;
10263 M (CONTROL_PING, control_ping);
10270 api_ip_dump (vat_main_t * vam)
10272 vl_api_ip_dump_t *mp;
10273 unformat_input_t *in = vam->input;
10280 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10282 if (unformat (in, "ipv4"))
10284 else if (unformat (in, "ipv6"))
10290 if (ipv4_set && ipv6_set)
10292 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10296 if ((!ipv4_set) && (!ipv6_set))
10298 errmsg ("no ipv4 nor ipv6 flag set\n");
10302 is_ipv6 = ipv6_set;
10303 vam->is_ipv6 = is_ipv6;
10305 /* free old data */
10306 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10308 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10310 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10312 M (IP_DUMP, ip_dump);
10313 mp->is_ipv6 = ipv6_set;
10316 /* Use a control ping for synchronization */
10318 vl_api_control_ping_t *mp;
10319 M (CONTROL_PING, control_ping);
10326 api_ipsec_spd_add_del (vat_main_t * vam)
10329 unformat_input_t *i = vam->input;
10330 vl_api_ipsec_spd_add_del_t *mp;
10335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10337 if (unformat (i, "spd_id %d", &spd_id))
10339 else if (unformat (i, "del"))
10343 clib_warning ("parse error '%U'", format_unformat_error, i);
10349 errmsg ("spd_id must be set\n");
10353 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10355 mp->spd_id = ntohl (spd_id);
10356 mp->is_add = is_add;
10363 clib_warning ("unsupported (no dpdk)");
10369 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10372 unformat_input_t *i = vam->input;
10373 vl_api_ipsec_interface_add_del_spd_t *mp;
10376 u8 sw_if_index_set = 0;
10377 u32 spd_id = (u32) ~ 0;
10380 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10382 if (unformat (i, "del"))
10384 else if (unformat (i, "spd_id %d", &spd_id))
10386 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10387 sw_if_index_set = 1;
10388 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10389 sw_if_index_set = 1;
10392 clib_warning ("parse error '%U'", format_unformat_error, i);
10398 if (spd_id == (u32) ~ 0)
10400 errmsg ("spd_id must be set\n");
10404 if (sw_if_index_set == 0)
10406 errmsg ("missing interface name or sw_if_index\n");
10410 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10412 mp->spd_id = ntohl (spd_id);
10413 mp->sw_if_index = ntohl (sw_if_index);
10414 mp->is_add = is_add;
10421 clib_warning ("unsupported (no dpdk)");
10427 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10430 unformat_input_t *i = vam->input;
10431 vl_api_ipsec_spd_add_del_entry_t *mp;
10433 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10434 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
10436 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10437 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10438 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10439 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10441 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10442 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10443 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10444 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10445 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10446 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10450 if (unformat (i, "del"))
10452 if (unformat (i, "outbound"))
10454 if (unformat (i, "inbound"))
10456 else if (unformat (i, "spd_id %d", &spd_id))
10458 else if (unformat (i, "sa_id %d", &sa_id))
10460 else if (unformat (i, "priority %d", &priority))
10462 else if (unformat (i, "protocol %d", &protocol))
10464 else if (unformat (i, "lport_start %d", &lport_start))
10466 else if (unformat (i, "lport_stop %d", &lport_stop))
10468 else if (unformat (i, "rport_start %d", &rport_start))
10470 else if (unformat (i, "rport_stop %d", &rport_stop))
10474 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10480 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10487 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10493 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10500 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10506 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10513 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10519 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10525 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10527 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10529 clib_warning ("unsupported action: 'resolve'");
10535 clib_warning ("parse error '%U'", format_unformat_error, i);
10541 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10543 mp->spd_id = ntohl (spd_id);
10544 mp->priority = ntohl (priority);
10545 mp->is_outbound = is_outbound;
10547 mp->is_ipv6 = is_ipv6;
10548 if (is_ipv6 || is_ip_any)
10550 clib_memcpy (mp->remote_address_start, &raddr6_start,
10551 sizeof (ip6_address_t));
10552 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10553 sizeof (ip6_address_t));
10554 clib_memcpy (mp->local_address_start, &laddr6_start,
10555 sizeof (ip6_address_t));
10556 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10557 sizeof (ip6_address_t));
10561 clib_memcpy (mp->remote_address_start, &raddr4_start,
10562 sizeof (ip4_address_t));
10563 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10564 sizeof (ip4_address_t));
10565 clib_memcpy (mp->local_address_start, &laddr4_start,
10566 sizeof (ip4_address_t));
10567 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10568 sizeof (ip4_address_t));
10570 mp->protocol = (u8) protocol;
10571 mp->local_port_start = ntohs ((u16) lport_start);
10572 mp->local_port_stop = ntohs ((u16) lport_stop);
10573 mp->remote_port_start = ntohs ((u16) rport_start);
10574 mp->remote_port_stop = ntohs ((u16) rport_stop);
10575 mp->policy = (u8) policy;
10576 mp->sa_id = ntohl (sa_id);
10577 mp->is_add = is_add;
10578 mp->is_ip_any = is_ip_any;
10584 clib_warning ("unsupported (no dpdk)");
10590 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10593 unformat_input_t *i = vam->input;
10594 vl_api_ipsec_sad_add_del_entry_t *mp;
10596 u32 sad_id = 0, spi = 0;
10597 u8 *ck = 0, *ik = 0;
10600 u8 protocol = IPSEC_PROTOCOL_AH;
10601 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10602 u32 crypto_alg = 0, integ_alg = 0;
10603 ip4_address_t tun_src4;
10604 ip4_address_t tun_dst4;
10605 ip6_address_t tun_src6;
10606 ip6_address_t tun_dst6;
10608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10610 if (unformat (i, "del"))
10612 else if (unformat (i, "sad_id %d", &sad_id))
10614 else if (unformat (i, "spi %d", &spi))
10616 else if (unformat (i, "esp"))
10617 protocol = IPSEC_PROTOCOL_ESP;
10618 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10621 is_tunnel_ipv6 = 0;
10623 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10626 is_tunnel_ipv6 = 0;
10628 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10631 is_tunnel_ipv6 = 1;
10633 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10636 is_tunnel_ipv6 = 1;
10640 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10642 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10643 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10645 clib_warning ("unsupported crypto-alg: '%U'",
10646 format_ipsec_crypto_alg, crypto_alg);
10650 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10654 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10656 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10657 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10659 clib_warning ("unsupported integ-alg: '%U'",
10660 format_ipsec_integ_alg, integ_alg);
10664 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10668 clib_warning ("parse error '%U'", format_unformat_error, i);
10674 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10676 mp->sad_id = ntohl (sad_id);
10677 mp->is_add = is_add;
10678 mp->protocol = protocol;
10679 mp->spi = ntohl (spi);
10680 mp->is_tunnel = is_tunnel;
10681 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10682 mp->crypto_algorithm = crypto_alg;
10683 mp->integrity_algorithm = integ_alg;
10684 mp->crypto_key_length = vec_len (ck);
10685 mp->integrity_key_length = vec_len (ik);
10687 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10688 mp->crypto_key_length = sizeof (mp->crypto_key);
10690 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10691 mp->integrity_key_length = sizeof (mp->integrity_key);
10694 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10696 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10700 if (is_tunnel_ipv6)
10702 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10703 sizeof (ip6_address_t));
10704 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10705 sizeof (ip6_address_t));
10709 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10710 sizeof (ip4_address_t));
10711 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10712 sizeof (ip4_address_t));
10721 clib_warning ("unsupported (no dpdk)");
10727 api_ipsec_sa_set_key (vat_main_t * vam)
10730 unformat_input_t *i = vam->input;
10731 vl_api_ipsec_sa_set_key_t *mp;
10734 u8 *ck = 0, *ik = 0;
10736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10738 if (unformat (i, "sa_id %d", &sa_id))
10740 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10742 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10746 clib_warning ("parse error '%U'", format_unformat_error, i);
10751 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10753 mp->sa_id = ntohl (sa_id);
10754 mp->crypto_key_length = vec_len (ck);
10755 mp->integrity_key_length = vec_len (ik);
10757 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10758 mp->crypto_key_length = sizeof (mp->crypto_key);
10760 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10761 mp->integrity_key_length = sizeof (mp->integrity_key);
10764 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10766 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10773 clib_warning ("unsupported (no dpdk)");
10779 api_ikev2_profile_add_del (vat_main_t * vam)
10782 unformat_input_t *i = vam->input;
10783 vl_api_ikev2_profile_add_del_t *mp;
10788 const char *valid_chars = "a-zA-Z0-9_";
10790 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10792 if (unformat (i, "del"))
10794 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10795 vec_add1 (name, 0);
10798 errmsg ("parse error '%U'", format_unformat_error, i);
10803 if (!vec_len (name))
10805 errmsg ("profile name must be specified");
10809 if (vec_len (name) > 64)
10811 errmsg ("profile name too long");
10815 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
10817 clib_memcpy (mp->name, name, vec_len (name));
10818 mp->is_add = is_add;
10826 clib_warning ("unsupported (no dpdk)");
10832 api_ikev2_profile_set_auth (vat_main_t * vam)
10835 unformat_input_t *i = vam->input;
10836 vl_api_ikev2_profile_set_auth_t *mp;
10840 u32 auth_method = 0;
10843 const char *valid_chars = "a-zA-Z0-9_";
10845 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10847 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10848 vec_add1 (name, 0);
10849 else if (unformat (i, "auth_method %U",
10850 unformat_ikev2_auth_method, &auth_method))
10852 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
10854 else if (unformat (i, "auth_data %v", &data))
10858 errmsg ("parse error '%U'", format_unformat_error, i);
10863 if (!vec_len (name))
10865 errmsg ("profile name must be specified");
10869 if (vec_len (name) > 64)
10871 errmsg ("profile name too long");
10875 if (!vec_len (data))
10877 errmsg ("auth_data must be specified");
10883 errmsg ("auth_method must be specified");
10887 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
10889 mp->is_hex = is_hex;
10890 mp->auth_method = (u8) auth_method;
10891 mp->data_len = vec_len (data);
10892 clib_memcpy (mp->name, name, vec_len (name));
10893 clib_memcpy (mp->data, data, vec_len (data));
10902 clib_warning ("unsupported (no dpdk)");
10908 api_ikev2_profile_set_id (vat_main_t * vam)
10911 unformat_input_t *i = vam->input;
10912 vl_api_ikev2_profile_set_id_t *mp;
10920 const char *valid_chars = "a-zA-Z0-9_";
10922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10924 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10925 vec_add1 (name, 0);
10926 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
10928 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
10930 data = vec_new (u8, 4);
10931 clib_memcpy (data, ip4.as_u8, 4);
10933 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
10935 else if (unformat (i, "id_data %v", &data))
10937 else if (unformat (i, "local"))
10939 else if (unformat (i, "remote"))
10943 errmsg ("parse error '%U'", format_unformat_error, i);
10948 if (!vec_len (name))
10950 errmsg ("profile name must be specified");
10954 if (vec_len (name) > 64)
10956 errmsg ("profile name too long");
10960 if (!vec_len (data))
10962 errmsg ("id_data must be specified");
10968 errmsg ("id_type must be specified");
10972 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
10974 mp->is_local = is_local;
10975 mp->id_type = (u8) id_type;
10976 mp->data_len = vec_len (data);
10977 clib_memcpy (mp->name, name, vec_len (name));
10978 clib_memcpy (mp->data, data, vec_len (data));
10987 clib_warning ("unsupported (no dpdk)");
10993 api_ikev2_profile_set_ts (vat_main_t * vam)
10996 unformat_input_t *i = vam->input;
10997 vl_api_ikev2_profile_set_ts_t *mp;
11001 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11002 ip4_address_t start_addr, end_addr;
11004 const char *valid_chars = "a-zA-Z0-9_";
11006 start_addr.as_u32 = 0;
11007 end_addr.as_u32 = (u32) ~ 0;
11009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11011 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11012 vec_add1 (name, 0);
11013 else if (unformat (i, "protocol %d", &proto))
11015 else if (unformat (i, "start_port %d", &start_port))
11017 else if (unformat (i, "end_port %d", &end_port))
11020 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
11022 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
11024 else if (unformat (i, "local"))
11026 else if (unformat (i, "remote"))
11030 errmsg ("parse error '%U'", format_unformat_error, i);
11035 if (!vec_len (name))
11037 errmsg ("profile name must be specified");
11041 if (vec_len (name) > 64)
11043 errmsg ("profile name too long");
11047 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11049 mp->is_local = is_local;
11050 mp->proto = (u8) proto;
11051 mp->start_port = (u16) start_port;
11052 mp->end_port = (u16) end_port;
11053 mp->start_addr = start_addr.as_u32;
11054 mp->end_addr = end_addr.as_u32;
11055 clib_memcpy (mp->name, name, vec_len (name));
11063 clib_warning ("unsupported (no dpdk)");
11069 api_ikev2_set_local_key (vat_main_t * vam)
11072 unformat_input_t *i = vam->input;
11073 vl_api_ikev2_set_local_key_t *mp;
11077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11079 if (unformat (i, "file %v", &file))
11080 vec_add1 (file, 0);
11083 errmsg ("parse error '%U'", format_unformat_error, i);
11088 if (!vec_len (file))
11090 errmsg ("RSA key file must be specified");
11094 if (vec_len (file) > 256)
11096 errmsg ("file name too long");
11100 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11102 clib_memcpy (mp->key_file, file, vec_len (file));
11110 clib_warning ("unsupported (no dpdk)");
11119 api_map_add_domain (vat_main_t * vam)
11121 unformat_input_t *i = vam->input;
11122 vl_api_map_add_domain_t *mp;
11125 ip4_address_t ip4_prefix;
11126 ip6_address_t ip6_prefix;
11127 ip6_address_t ip6_src;
11128 u32 num_m_args = 0;
11129 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
11130 0, psid_length = 0;
11131 u8 is_translation = 0;
11133 u8 ip6_src_len = 128;
11135 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11137 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11138 &ip4_prefix, &ip4_prefix_len))
11140 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11141 &ip6_prefix, &ip6_prefix_len))
11145 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11148 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11150 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11152 else if (unformat (i, "psid-offset %d", &psid_offset))
11154 else if (unformat (i, "psid-len %d", &psid_length))
11156 else if (unformat (i, "mtu %d", &mtu))
11158 else if (unformat (i, "map-t"))
11159 is_translation = 1;
11162 clib_warning ("parse error '%U'", format_unformat_error, i);
11167 if (num_m_args != 6)
11169 errmsg ("mandatory argument(s) missing\n");
11173 /* Construct the API message */
11174 M (MAP_ADD_DOMAIN, map_add_domain);
11176 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11177 mp->ip4_prefix_len = ip4_prefix_len;
11179 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11180 mp->ip6_prefix_len = ip6_prefix_len;
11182 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11183 mp->ip6_src_prefix_len = ip6_src_len;
11185 mp->ea_bits_len = ea_bits_len;
11186 mp->psid_offset = psid_offset;
11187 mp->psid_length = psid_length;
11188 mp->is_translation = is_translation;
11189 mp->mtu = htons (mtu);
11194 /* Wait for a reply, return good/bad news */
11199 api_map_del_domain (vat_main_t * vam)
11201 unformat_input_t *i = vam->input;
11202 vl_api_map_del_domain_t *mp;
11205 u32 num_m_args = 0;
11208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11210 if (unformat (i, "index %d", &index))
11214 clib_warning ("parse error '%U'", format_unformat_error, i);
11219 if (num_m_args != 1)
11221 errmsg ("mandatory argument(s) missing\n");
11225 /* Construct the API message */
11226 M (MAP_DEL_DOMAIN, map_del_domain);
11228 mp->index = ntohl (index);
11233 /* Wait for a reply, return good/bad news */
11238 api_map_add_del_rule (vat_main_t * vam)
11240 unformat_input_t *i = vam->input;
11241 vl_api_map_add_del_rule_t *mp;
11244 ip6_address_t ip6_dst;
11245 u32 num_m_args = 0, index, psid = 0;
11247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11249 if (unformat (i, "index %d", &index))
11251 else if (unformat (i, "psid %d", &psid))
11253 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11255 else if (unformat (i, "del"))
11261 clib_warning ("parse error '%U'", format_unformat_error, i);
11266 /* Construct the API message */
11267 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11269 mp->index = ntohl (index);
11270 mp->is_add = is_add;
11271 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11272 mp->psid = ntohs (psid);
11277 /* Wait for a reply, return good/bad news */
11282 api_map_domain_dump (vat_main_t * vam)
11284 vl_api_map_domain_dump_t *mp;
11287 /* Construct the API message */
11288 M (MAP_DOMAIN_DUMP, map_domain_dump);
11293 /* Use a control ping for synchronization */
11295 vl_api_control_ping_t *mp;
11296 M (CONTROL_PING, control_ping);
11303 api_map_rule_dump (vat_main_t * vam)
11305 unformat_input_t *i = vam->input;
11306 vl_api_map_rule_dump_t *mp;
11308 u32 domain_index = ~0;
11310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11312 if (unformat (i, "index %u", &domain_index))
11318 if (domain_index == ~0)
11320 clib_warning ("parse error: domain index expected");
11324 /* Construct the API message */
11325 M (MAP_RULE_DUMP, map_rule_dump);
11327 mp->domain_index = htonl (domain_index);
11332 /* Use a control ping for synchronization */
11334 vl_api_control_ping_t *mp;
11335 M (CONTROL_PING, control_ping);
11341 static void vl_api_map_add_domain_reply_t_handler
11342 (vl_api_map_add_domain_reply_t * mp)
11344 vat_main_t *vam = &vat_main;
11345 i32 retval = ntohl (mp->retval);
11347 if (vam->async_mode)
11349 vam->async_errors += (retval < 0);
11353 vam->retval = retval;
11354 vam->result_ready = 1;
11358 static void vl_api_map_add_domain_reply_t_handler_json
11359 (vl_api_map_add_domain_reply_t * mp)
11361 vat_main_t *vam = &vat_main;
11362 vat_json_node_t node;
11364 vat_json_init_object (&node);
11365 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11366 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11368 vat_json_print (vam->ofp, &node);
11369 vat_json_free (&node);
11371 vam->retval = ntohl (mp->retval);
11372 vam->result_ready = 1;
11376 api_get_first_msg_id (vat_main_t * vam)
11378 vl_api_get_first_msg_id_t *mp;
11380 unformat_input_t *i = vam->input;
11384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11386 if (unformat (i, "client %s", &name))
11394 errmsg ("missing client name\n");
11397 vec_add1 (name, 0);
11399 if (vec_len (name) > 63)
11401 errmsg ("client name too long\n");
11405 M (GET_FIRST_MSG_ID, get_first_msg_id);
11406 clib_memcpy (mp->name, name, vec_len (name));
11414 api_cop_interface_enable_disable (vat_main_t * vam)
11416 unformat_input_t *line_input = vam->input;
11417 vl_api_cop_interface_enable_disable_t *mp;
11419 u32 sw_if_index = ~0;
11420 u8 enable_disable = 1;
11422 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11424 if (unformat (line_input, "disable"))
11425 enable_disable = 0;
11426 if (unformat (line_input, "enable"))
11427 enable_disable = 1;
11428 else if (unformat (line_input, "%U", unformat_sw_if_index,
11429 vam, &sw_if_index))
11431 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11437 if (sw_if_index == ~0)
11439 errmsg ("missing interface name or sw_if_index\n");
11443 /* Construct the API message */
11444 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11445 mp->sw_if_index = ntohl (sw_if_index);
11446 mp->enable_disable = enable_disable;
11450 /* Wait for the reply */
11455 api_cop_whitelist_enable_disable (vat_main_t * vam)
11457 unformat_input_t *line_input = vam->input;
11458 vl_api_cop_whitelist_enable_disable_t *mp;
11460 u32 sw_if_index = ~0;
11461 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11464 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11466 if (unformat (line_input, "ip4"))
11468 else if (unformat (line_input, "ip6"))
11470 else if (unformat (line_input, "default"))
11472 else if (unformat (line_input, "%U", unformat_sw_if_index,
11473 vam, &sw_if_index))
11475 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11477 else if (unformat (line_input, "fib-id %d", &fib_id))
11483 if (sw_if_index == ~0)
11485 errmsg ("missing interface name or sw_if_index\n");
11489 /* Construct the API message */
11490 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11491 mp->sw_if_index = ntohl (sw_if_index);
11492 mp->fib_id = ntohl (fib_id);
11495 mp->default_cop = default_cop;
11499 /* Wait for the reply */
11504 api_get_node_graph (vat_main_t * vam)
11506 vl_api_get_node_graph_t *mp;
11509 M (GET_NODE_GRAPH, get_node_graph);
11513 /* Wait for the reply */
11518 /** Used for parsing LISP eids */
11519 typedef CLIB_PACKED(struct{
11520 u8 addr[16]; /**< eid address */
11521 u32 len; /**< prefix length if IP */
11522 u8 type; /**< type of eid */
11527 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11529 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11531 memset (a, 0, sizeof (a[0]));
11533 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11535 a->type = 0; /* ipv4 type */
11537 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11539 a->type = 1; /* ipv6 type */
11541 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11543 a->type = 2; /* mac type */
11550 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11559 lisp_eid_size_vat (u8 type)
11574 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11576 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11580 /** Used for transferring locators via VPP API */
11581 typedef CLIB_PACKED(struct
11583 u32 sw_if_index; /**< locator sw_if_index */
11584 u8 priority; /**< locator priority */
11585 u8 weight; /**< locator weight */
11590 api_lisp_add_del_locator_set (vat_main_t * vam)
11592 unformat_input_t *input = vam->input;
11593 vl_api_lisp_add_del_locator_set_t *mp;
11596 u8 *locator_set_name = NULL;
11597 u8 locator_set_name_set = 0;
11598 ls_locator_t locator, *locators = 0;
11599 u32 sw_if_index, priority, weight;
11601 /* Parse args required to build the message */
11602 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11604 if (unformat (input, "del"))
11608 else if (unformat (input, "locator-set %s", &locator_set_name))
11610 locator_set_name_set = 1;
11612 else if (unformat (input, "sw_if_index %u p %u w %u",
11613 &sw_if_index, &priority, &weight))
11615 locator.sw_if_index = htonl (sw_if_index);
11616 locator.priority = priority;
11617 locator.weight = weight;
11618 vec_add1 (locators, locator);
11620 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11621 vam, &sw_if_index, &priority, &weight))
11623 locator.sw_if_index = htonl (sw_if_index);
11624 locator.priority = priority;
11625 locator.weight = weight;
11626 vec_add1 (locators, locator);
11632 if (locator_set_name_set == 0)
11634 errmsg ("missing locator-set name");
11635 vec_free (locators);
11639 if (vec_len (locator_set_name) > 64)
11641 errmsg ("locator-set name too long\n");
11642 vec_free (locator_set_name);
11643 vec_free (locators);
11646 vec_add1 (locator_set_name, 0);
11648 /* Construct the API message */
11649 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11651 mp->is_add = is_add;
11652 clib_memcpy (mp->locator_set_name, locator_set_name,
11653 vec_len (locator_set_name));
11654 vec_free (locator_set_name);
11656 mp->locator_num = vec_len (locators);
11658 clib_memcpy (mp->locators, locators,
11659 (sizeof (ls_locator_t) * vec_len (locators)));
11660 vec_free (locators);
11665 /* Wait for a reply... */
11673 api_lisp_add_del_locator (vat_main_t * vam)
11675 unformat_input_t *input = vam->input;
11676 vl_api_lisp_add_del_locator_t *mp;
11678 u32 tmp_if_index = ~0;
11679 u32 sw_if_index = ~0;
11680 u8 sw_if_index_set = 0;
11681 u8 sw_if_index_if_name_set = 0;
11683 u8 priority_set = 0;
11687 u8 *locator_set_name = NULL;
11688 u8 locator_set_name_set = 0;
11690 /* Parse args required to build the message */
11691 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11693 if (unformat (input, "del"))
11697 else if (unformat (input, "locator-set %s", &locator_set_name))
11699 locator_set_name_set = 1;
11701 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11704 sw_if_index_if_name_set = 1;
11705 sw_if_index = tmp_if_index;
11707 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11709 sw_if_index_set = 1;
11710 sw_if_index = tmp_if_index;
11712 else if (unformat (input, "p %d", &priority))
11716 else if (unformat (input, "w %d", &weight))
11724 if (locator_set_name_set == 0)
11726 errmsg ("missing locator-set name");
11730 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11732 errmsg ("missing sw_if_index");
11733 vec_free (locator_set_name);
11737 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11739 errmsg ("cannot use both params interface name and sw_if_index");
11740 vec_free (locator_set_name);
11744 if (priority_set == 0)
11746 errmsg ("missing locator-set priority\n");
11747 vec_free (locator_set_name);
11751 if (weight_set == 0)
11753 errmsg ("missing locator-set weight\n");
11754 vec_free (locator_set_name);
11758 if (vec_len (locator_set_name) > 64)
11760 errmsg ("locator-set name too long\n");
11761 vec_free (locator_set_name);
11764 vec_add1 (locator_set_name, 0);
11766 /* Construct the API message */
11767 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11769 mp->is_add = is_add;
11770 mp->sw_if_index = ntohl (sw_if_index);
11771 mp->priority = priority;
11772 mp->weight = weight;
11773 clib_memcpy (mp->locator_set_name, locator_set_name,
11774 vec_len (locator_set_name));
11775 vec_free (locator_set_name);
11780 /* Wait for a reply... */
11788 api_lisp_add_del_local_eid (vat_main_t * vam)
11790 unformat_input_t *input = vam->input;
11791 vl_api_lisp_add_del_local_eid_t *mp;
11795 lisp_eid_vat_t _eid, *eid = &_eid;
11796 u8 *locator_set_name = 0;
11797 u8 locator_set_name_set = 0;
11800 /* Parse args required to build the message */
11801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11803 if (unformat (input, "del"))
11807 else if (unformat (input, "vni %d", &vni))
11811 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
11815 else if (unformat (input, "locator-set %s", &locator_set_name))
11817 locator_set_name_set = 1;
11823 if (locator_set_name_set == 0)
11825 errmsg ("missing locator-set name\n");
11831 errmsg ("EID address not set!");
11832 vec_free (locator_set_name);
11836 if (vec_len (locator_set_name) > 64)
11838 errmsg ("locator-set name too long\n");
11839 vec_free (locator_set_name);
11842 vec_add1 (locator_set_name, 0);
11844 /* Construct the API message */
11845 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
11847 mp->is_add = is_add;
11848 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
11849 mp->eid_type = eid->type;
11850 mp->prefix_len = eid->len;
11851 mp->vni = clib_host_to_net_u32 (vni);
11852 clib_memcpy (mp->locator_set_name, locator_set_name,
11853 vec_len (locator_set_name));
11855 vec_free (locator_set_name);
11860 /* Wait for a reply... */
11868 /** Used for transferring locators via VPP API */
11869 typedef CLIB_PACKED(struct
11871 u8 is_ip4; /**< is locator an IPv4 address? */
11872 u8 priority; /**< locator priority */
11873 u8 weight; /**< locator weight */
11874 u8 addr[16]; /**< IPv4/IPv6 address */
11879 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
11881 unformat_input_t *input = vam->input;
11882 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
11885 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
11886 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
11887 u8 rmt_eid_set = 0, lcl_eid_set = 0;
11888 u32 action = ~0, p, w;
11889 ip4_address_t rmt_rloc4, lcl_rloc4;
11890 ip6_address_t rmt_rloc6, lcl_rloc6;
11891 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
11893 memset (&rloc, 0, sizeof (rloc));
11895 /* Parse args required to build the message */
11896 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11898 if (unformat (input, "del"))
11902 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
11906 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
11910 else if (unformat (input, "p %d w %d", &p, &w))
11914 errmsg ("No RLOC configured for setting priority/weight!");
11917 curr_rloc->priority = p;
11918 curr_rloc->weight = w;
11920 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
11921 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
11925 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
11926 rloc.priority = rloc.weight = 0;
11927 vec_add1 (lcl_locs, rloc);
11929 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
11930 vec_add1 (rmt_locs, rloc);
11931 /* priority and weight saved in rmt loc */
11932 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11934 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
11935 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
11938 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
11939 rloc.priority = rloc.weight = 0;
11940 vec_add1 (lcl_locs, rloc);
11942 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
11943 vec_add1 (rmt_locs, rloc);
11944 /* priority and weight saved in rmt loc */
11945 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11947 else if (unformat (input, "action %d", &action))
11953 clib_warning ("parse error '%U'", format_unformat_error, input);
11960 errmsg ("remote eid addresses not set\n");
11964 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
11966 errmsg ("eid types don't match\n");
11970 if (0 == rmt_locs && (u32) ~ 0 == action)
11972 errmsg ("action not set for negative mapping\n");
11976 /* Construct the API message */
11977 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
11979 mp->is_add = is_add;
11980 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
11981 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
11982 mp->eid_type = rmt_eid->type;
11983 mp->rmt_len = rmt_eid->len;
11984 mp->lcl_len = lcl_eid->len;
11985 mp->action = action;
11987 if (0 != rmt_locs && 0 != lcl_locs)
11989 mp->loc_num = vec_len (rmt_locs);
11990 clib_memcpy (mp->lcl_locs, lcl_locs,
11991 (sizeof (rloc_t) * vec_len (lcl_locs)));
11992 clib_memcpy (mp->rmt_locs, rmt_locs,
11993 (sizeof (rloc_t) * vec_len (rmt_locs)));
11995 vec_free (lcl_locs);
11996 vec_free (rmt_locs);
12001 /* Wait for a reply... */
12009 api_lisp_add_del_map_resolver (vat_main_t * vam)
12011 unformat_input_t *input = vam->input;
12012 vl_api_lisp_add_del_map_resolver_t *mp;
12017 ip4_address_t ipv4;
12018 ip6_address_t ipv6;
12020 /* Parse args required to build the message */
12021 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12023 if (unformat (input, "del"))
12027 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
12031 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
12039 if (ipv4_set && ipv6_set)
12041 errmsg ("both eid v4 and v6 addresses set\n");
12045 if (!ipv4_set && !ipv6_set)
12047 errmsg ("eid addresses not set\n");
12051 /* Construct the API message */
12052 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12054 mp->is_add = is_add;
12058 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12063 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12069 /* Wait for a reply... */
12077 api_lisp_gpe_enable_disable (vat_main_t * vam)
12079 unformat_input_t *input = vam->input;
12080 vl_api_lisp_gpe_enable_disable_t *mp;
12085 /* Parse args required to build the message */
12086 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12088 if (unformat (input, "enable"))
12093 else if (unformat (input, "disable"))
12104 errmsg ("Value not set\n");
12108 /* Construct the API message */
12109 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12116 /* Wait for a reply... */
12124 api_lisp_enable_disable (vat_main_t * vam)
12126 unformat_input_t *input = vam->input;
12127 vl_api_lisp_enable_disable_t *mp;
12132 /* Parse args required to build the message */
12133 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12135 if (unformat (input, "enable"))
12140 else if (unformat (input, "disable"))
12150 errmsg ("Value not set\n");
12154 /* Construct the API message */
12155 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12162 /* Wait for a reply... */
12170 * Enable/disable LISP proxy ITR.
12172 * @param vam vpp API test context
12173 * @return return code
12176 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12179 u8 ls_name_set = 0;
12180 unformat_input_t *input = vam->input;
12181 vl_api_lisp_pitr_set_locator_set_t *mp;
12185 /* Parse args required to build the message */
12186 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12188 if (unformat (input, "del"))
12190 else if (unformat (input, "locator-set %s", &ls_name))
12194 errmsg ("parse error '%U'", format_unformat_error, input);
12201 errmsg ("locator-set name not set!");
12205 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12207 mp->is_add = is_add;
12208 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12209 vec_free (ls_name);
12214 /* wait for reply */
12222 api_show_lisp_pitr (vat_main_t * vam)
12224 vl_api_show_lisp_pitr_t *mp;
12227 if (!vam->json_output)
12229 fformat (vam->ofp, "%=20s\n", "lisp status:");
12232 M (SHOW_LISP_PITR, show_lisp_pitr);
12236 /* Wait for a reply... */
12244 * Add/delete mapping between vni and vrf
12247 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12250 unformat_input_t *input = vam->input;
12251 vl_api_lisp_eid_table_add_del_map_t *mp;
12252 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12253 u32 vni, vrf, bd_index;
12255 /* Parse args required to build the message */
12256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12258 if (unformat (input, "del"))
12260 else if (unformat (input, "vrf %d", &vrf))
12262 else if (unformat (input, "bd_index %d", &bd_index))
12264 else if (unformat (input, "vni %d", &vni))
12270 if (!vni_set || (!vrf_set && !bd_index_set))
12272 errmsg ("missing arguments!");
12276 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12278 mp->is_add = is_add;
12279 mp->vni = htonl (vni);
12280 mp->dp_table = htonl (vrf);
12281 mp->is_l2 = bd_index_set;
12286 /* wait for reply */
12294 * Add/del remote mapping to/from LISP control plane
12296 * @param vam vpp API test context
12297 * @return return code
12300 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12302 unformat_input_t *input = vam->input;
12303 vl_api_lisp_add_del_remote_mapping_t *mp;
12306 //TODO: seid need remove
12307 lisp_eid_vat_t _eid, *eid = &_eid;
12308 lisp_eid_vat_t _seid, *seid = &_seid;
12309 u8 is_add = 1, del_all = 0, eid_set = 0;
12310 u32 action = ~0, p, w;
12311 ip4_address_t rloc4;
12312 ip6_address_t rloc6;
12313 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12315 memset (&rloc, 0, sizeof (rloc));
12317 /* Parse args required to build the message */
12318 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12320 if (unformat (input, "del-all"))
12324 else if (unformat (input, "del"))
12328 else if (unformat (input, "add"))
12332 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12336 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12338 //TODO: Need remove, but first must be remove from CSIT test
12340 else if (unformat (input, "vni %d", &vni))
12344 else if (unformat (input, "p %d w %d", &p, &w))
12348 errmsg ("No RLOC configured for setting priority/weight!");
12351 curr_rloc->priority = p;
12352 curr_rloc->weight = w;
12354 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12357 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12358 vec_add1 (rlocs, rloc);
12359 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12361 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12364 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12365 vec_add1 (rlocs, rloc);
12366 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12368 else if (unformat (input, "action %d", &action))
12374 clib_warning ("parse error '%U'", format_unformat_error, input);
12381 errmsg ("missing params!");
12385 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12387 errmsg ("no action set for negative map-reply!");
12391 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12392 mp->is_add = is_add;
12393 mp->vni = htonl (vni);
12394 mp->action = (u8) action;
12395 mp->eid_len = eid->len;
12396 mp->del_all = del_all;
12397 mp->eid_type = eid->type;
12398 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12400 mp->rloc_num = vec_len (rlocs);
12401 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12407 /* Wait for a reply... */
12415 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12416 * forwarding entries in data-plane accordingly.
12418 * @param vam vpp API test context
12419 * @return return code
12422 api_lisp_add_del_adjacency (vat_main_t * vam)
12424 unformat_input_t *input = vam->input;
12425 vl_api_lisp_add_del_adjacency_t *mp;
12428 ip4_address_t seid4, deid4;
12429 ip6_address_t seid6, deid6;
12430 u8 deid_mac[6] = { 0 };
12431 u8 seid_mac[6] = { 0 };
12432 u8 deid_type, seid_type;
12433 u32 seid_len = 0, deid_len = 0, len;
12436 seid_type = deid_type = (u8) ~ 0;
12438 /* Parse args required to build the message */
12439 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12441 if (unformat (input, "del"))
12445 else if (unformat (input, "add"))
12449 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12452 deid_type = 0; /* ipv4 */
12455 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12458 deid_type = 1; /* ipv6 */
12461 else if (unformat (input, "deid %U", unformat_ethernet_address,
12464 deid_type = 2; /* mac */
12466 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12469 seid_type = 0; /* ipv4 */
12472 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12475 seid_type = 1; /* ipv6 */
12478 else if (unformat (input, "seid %U", unformat_ethernet_address,
12481 seid_type = 2; /* mac */
12483 else if (unformat (input, "vni %d", &vni))
12489 errmsg ("parse error '%U'", format_unformat_error, input);
12494 if ((u8) ~ 0 == deid_type)
12496 errmsg ("missing params!");
12500 if (seid_type != deid_type)
12502 errmsg ("source and destination EIDs are of different types!");
12506 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12507 mp->is_add = is_add;
12508 mp->vni = htonl (vni);
12509 mp->seid_len = seid_len;
12510 mp->deid_len = deid_len;
12511 mp->eid_type = deid_type;
12513 switch (mp->eid_type)
12516 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12517 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12520 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12521 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12524 clib_memcpy (mp->seid, seid_mac, 6);
12525 clib_memcpy (mp->deid, deid_mac, 6);
12528 errmsg ("unknown EID type %d!", mp->eid_type);
12535 /* Wait for a reply... */
12543 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12545 unformat_input_t *input = vam->input;
12546 vl_api_lisp_gpe_add_del_iface_t *mp;
12548 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12549 u32 dp_table = 0, vni = 0;
12551 /* Parse args required to build the message */
12552 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12554 if (unformat (input, "up"))
12559 else if (unformat (input, "down"))
12564 else if (unformat (input, "table_id %d", &dp_table))
12568 else if (unformat (input, "bd_id %d", &dp_table))
12573 else if (unformat (input, "vni %d", &vni))
12581 if (action_set == 0)
12583 errmsg ("Action not set\n");
12586 if (dp_table_set == 0 || vni_set == 0)
12588 errmsg ("vni and dp_table must be set\n");
12592 /* Construct the API message */
12593 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12595 mp->is_add = is_add;
12596 mp->dp_table = dp_table;
12603 /* Wait for a reply... */
12611 * Add/del map request itr rlocs from LISP control plane and updates
12613 * @param vam vpp API test context
12614 * @return return code
12617 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12619 unformat_input_t *input = vam->input;
12620 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12622 u8 *locator_set_name = 0;
12623 u8 locator_set_name_set = 0;
12626 /* Parse args required to build the message */
12627 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12629 if (unformat (input, "del"))
12633 else if (unformat (input, "%_%v%_", &locator_set_name))
12635 locator_set_name_set = 1;
12639 clib_warning ("parse error '%U'", format_unformat_error, input);
12644 if (is_add && !locator_set_name_set)
12646 errmsg ("itr-rloc is not set!");
12650 if (is_add && vec_len (locator_set_name) > 64)
12652 errmsg ("itr-rloc locator-set name too long\n");
12653 vec_free (locator_set_name);
12657 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12658 mp->is_add = is_add;
12661 clib_memcpy (mp->locator_set_name, locator_set_name,
12662 vec_len (locator_set_name));
12666 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12668 vec_free (locator_set_name);
12673 /* Wait for a reply... */
12681 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12684 vl_api_lisp_locator_dump_t *mp;
12687 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12689 mp->locator_set_index = htonl (locator_set_index);
12690 mp->filter = filter;
12695 /* Use a control ping for synchronization */
12697 vl_api_noprint_control_ping_t *mp;
12698 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12701 /* Wait for a reply... */
12706 clean_locator_set_message (vat_main_t * vam)
12708 locator_set_msg_t *ls = 0;
12710 vec_foreach (ls, vam->locator_set_msg)
12712 vec_free (ls->locator_set_name);
12715 vec_free (vam->locator_set_msg);
12719 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12721 locator_set_msg_t *ls;
12722 locator_msg_t *loc;
12724 int i = 0, ret = 0;
12726 vec_foreach (ls, vam->locator_set_msg)
12728 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12731 vec_free (vam->locator_msg);
12732 clean_locator_set_message (vam);
12736 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12737 ls->locator_set_index,
12738 vec_len (vam->locator_msg) ? "" : "\n");
12740 vec_foreach (loc, vam->locator_msg)
12744 tmp_str = format (tmp_str, "%=37s", " ");
12748 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12749 loc->sw_if_index, loc->priority, loc->weight);
12753 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12754 loc->is_ipv6 ? format_ip6_address :
12755 format_ip4_address,
12756 loc->ip_address, loc->priority, loc->weight);
12761 fformat (vam->ofp, "%s", tmp_str);
12762 vec_free (tmp_str);
12763 vec_free (vam->locator_msg);
12766 clean_locator_set_message (vam);
12772 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
12774 locator_set_msg_t *ls;
12775 locator_msg_t *loc;
12776 vat_json_node_t *node = NULL;
12777 vat_json_node_t *locator_array;
12778 vat_json_node_t *locator;
12779 struct in6_addr ip6;
12780 struct in_addr ip4;
12783 if (!vec_len (vam->locator_set_msg))
12785 /* just print [] */
12786 vat_json_init_array (&vam->json_tree);
12787 vat_json_print (vam->ofp, &vam->json_tree);
12788 vam->json_tree.type = VAT_JSON_NONE;
12792 if (VAT_JSON_ARRAY != vam->json_tree.type)
12794 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12795 vat_json_init_array (&vam->json_tree);
12798 vec_foreach (ls, vam->locator_set_msg)
12800 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12803 vec_free (ls->locator_set_name);
12804 vec_free (vam->locator_msg);
12805 vec_free (vam->locator_set_msg);
12806 vat_json_free (&vam->json_tree);
12807 vam->json_tree.type = VAT_JSON_NONE;
12811 node = vat_json_array_add (&vam->json_tree);
12812 vat_json_init_object (node);
12814 vat_json_object_add_uint (node, "locator-set-index",
12815 ls->locator_set_index);
12816 vat_json_object_add_string_copy (node, "locator-set",
12817 ls->locator_set_name);
12818 locator_array = vat_json_object_add_list (node, "locator");
12819 vec_foreach (loc, vam->locator_msg)
12821 locator = vat_json_array_add (locator_array);
12822 vat_json_init_object (locator);
12825 vat_json_object_add_uint (locator, "locator-index",
12832 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
12833 vat_json_object_add_ip6 (locator, "locator", ip6);
12837 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
12838 vat_json_object_add_ip4 (locator, "locator", ip4);
12841 vat_json_object_add_uint (locator, "priority", loc->priority);
12842 vat_json_object_add_uint (locator, "weight", loc->weight);
12845 vec_free (ls->locator_set_name);
12846 vec_free (vam->locator_msg);
12849 vat_json_print (vam->ofp, &vam->json_tree);
12850 vat_json_free (&vam->json_tree);
12851 vam->json_tree.type = VAT_JSON_NONE;
12853 vec_free (vam->locator_set_msg);
12859 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
12860 u32 * locator_set_index)
12862 locator_set_msg_t *ls;
12865 *locator_set_index = ~0;
12867 if (!vec_len (vam->locator_set_msg))
12872 vec_foreach (ls, vam->locator_set_msg)
12874 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
12876 *locator_set_index = ls->locator_set_index;
12877 vec_free (vam->locator_set_msg);
12882 vec_free (vam->locator_set_msg);
12888 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
12889 u32 * locator_set_index)
12891 vl_api_lisp_locator_set_dump_t *mp;
12894 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12898 /* Use a control ping for synchronization */
12900 vl_api_noprint_control_ping_t *mp;
12901 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12905 vam->noprint_msg = 1;
12906 /* Wait for a reply... */
12910 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
12911 vam->noprint_msg = 0;
12920 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
12927 if (!vam->json_output)
12929 fformat (vam->ofp, "%=20s%=16s%=16s\n",
12930 "locator", "priority", "weight");
12935 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
12938 if (!ret && ~0 == locator_set_index)
12943 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
12949 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
12951 vl_api_lisp_locator_set_dump_t *mp;
12954 if (!vam->json_output)
12956 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
12957 "locator-set", "locator-set-index", "locator", "priority",
12961 vam->noprint_msg = 1;
12963 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12965 mp->filter = filter;
12970 /* Use a control ping for synchronization */
12972 vl_api_noprint_control_ping_t *mp;
12973 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12977 /* Wait for a reply... */
12981 if (vam->noprint_msg)
12983 if (!vam->json_output)
12985 print_locator_in_locator_set(vam, filter);
12989 json_locator_in_locator_set(vam, filter);
12992 vam->noprint_msg = 0;
13001 api_lisp_locator_set_dump (vat_main_t * vam)
13003 unformat_input_t *input = vam->input;
13004 vam->noprint_msg = 0;
13005 u32 locator_set_index = ~0;
13006 u8 locator_set_index_set = 0;
13007 u8 *locator_set = 0;
13008 u8 locator_set_set = 0;
13012 /* Parse args required to build the message */
13013 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13015 if (unformat (input, "locator-set-index %u", &locator_set_index))
13017 locator_set_index_set = 1;
13019 else if (unformat (input, "locator-set %s", &locator_set))
13021 locator_set_set = 1;
13023 else if (unformat (input, "local"))
13027 else if (unformat (input, "remote"))
13037 if (locator_set_index_set && locator_set_set)
13039 errmsg ("use only input parameter!\n");
13043 if (locator_set_index_set || locator_set_set)
13045 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
13049 ret = lisp_locator_set_dump (vam, filter);
13052 vec_free (locator_set);
13058 api_lisp_eid_table_map_dump (vat_main_t * vam)
13060 vl_api_lisp_eid_table_map_dump_t *mp;
13063 if (!vam->json_output)
13065 fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
13068 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13073 /* Use a control ping for synchronization */
13075 vl_api_control_ping_t *mp;
13076 M (CONTROL_PING, control_ping);
13079 /* Wait for a reply... */
13087 get_locator_set (vat_main_t * vam)
13089 vl_api_lisp_locator_set_dump_t *mp;
13092 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13096 /* Use a control ping for synchronization */
13098 vl_api_noprint_control_ping_t *mp;
13099 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13103 /* Wait for a reply... */
13111 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13114 u8 *(*format_eid) (u8 *, va_list *) = 0;
13116 ASSERT (vam != NULL);
13117 ASSERT (eid_table != NULL);
13124 switch (eid_table->eid_type)
13128 format_eid = (eid_table->eid_type ? format_ip6_address :
13129 format_ip4_address);
13130 str = format (0, "[%d] %U/%d",
13131 clib_net_to_host_u32 (eid_table->vni),
13132 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13135 str = format (0, "[%d] %U",
13136 clib_net_to_host_u32 (eid_table->vni),
13137 format_ethernet_address, eid_table->eid);
13140 errmsg ("unknown EID type %d!", eid_table->eid_type);
13152 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13153 eid_table_t * eid_table)
13155 locator_set_msg_t *ls = 0;
13157 ASSERT (vam != NULL);
13158 ASSERT (eid_table != NULL);
13160 if (eid_table->is_local)
13162 vec_foreach (ls, vam->locator_set_msg)
13164 if (ls->locator_set_index == eid_table->locator_set_index)
13166 str = format (0, "local(%s)", ls->locator_set_name);
13171 str = format (0, "local(N/A)");
13175 str = format (0, "remote");
13182 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13183 eid_table_t * eid_table)
13185 locator_msg_t *loc = 0;
13186 int first_line = 1;
13188 ASSERT (vam != NULL);
13189 ASSERT (eid_table != NULL);
13191 vec_foreach (loc, vam->locator_msg)
13197 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13201 str = format (str, "%=55s%-U\n", " ",
13202 loc->is_ipv6 ? format_ip6_address :
13203 format_ip4_address, loc->ip_address);
13211 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13212 eid_table->ttl, eid_table->authoritative);
13216 str = format (str, "%-30U%-20u%-u\n",
13217 loc->is_ipv6 ? format_ip6_address :
13218 format_ip4_address,
13219 loc->ip_address, eid_table->ttl,
13220 eid_table->authoritative);
13229 print_lisp_eid_table_dump (vat_main_t * vam)
13231 eid_table_t *eid_table = 0;
13232 u8 *tmp_str = 0, *tmp_str2 = 0;
13235 ASSERT (vam != NULL);
13237 ret = get_locator_set (vam);
13240 vec_free (vam->eid_tables);
13244 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13245 "ttl", "authoritative");
13247 vec_foreach (eid_table, vam->eid_tables)
13249 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13252 vec_free (vam->locator_msg);
13253 clean_locator_set_message (vam);
13254 vec_free (vam->eid_tables);
13258 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13261 vec_free (vam->locator_msg);
13262 clean_locator_set_message (vam);
13263 vec_free (vam->eid_tables);
13267 tmp_str = format (0, "%-35s", tmp_str2);
13268 vec_free (tmp_str2);
13270 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13271 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13272 vec_free (tmp_str2);
13274 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13275 tmp_str = format (tmp_str, "%-s", tmp_str2);
13276 vec_free (tmp_str2);
13278 fformat (vam->ofp, "%s", tmp_str);
13279 vec_free (tmp_str);
13280 vec_free (vam->locator_msg);
13283 clean_locator_set_message (vam);
13284 vec_free (vam->eid_tables);
13290 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13291 eid_table_t * eid_table)
13293 locator_set_msg_t *ls = 0;
13296 ASSERT (vam != NULL);
13297 ASSERT (node != NULL);
13298 ASSERT (eid_table != NULL);
13300 if (eid_table->is_local)
13302 vec_foreach (ls, vam->locator_set_msg)
13304 if (ls->locator_set_index == eid_table->locator_set_index)
13306 vat_json_object_add_string_copy (node, "locator-set",
13307 ls->locator_set_name);
13312 s = format (0, "N/A");
13314 vat_json_object_add_string_copy (node, "locator-set", s);
13319 s = format (0, "remote");
13321 vat_json_object_add_string_copy (node, "locator-set", s);
13327 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13328 eid_table_t * eid_table)
13331 struct in6_addr ip6;
13332 struct in_addr ip4;
13334 ASSERT (vam != NULL);
13335 ASSERT (node != NULL);
13336 ASSERT (eid_table != NULL);
13338 switch (eid_table->eid_type)
13341 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13342 vat_json_object_add_ip4 (node, "eid", ip4);
13343 vat_json_object_add_uint (node, "eid-prefix-len",
13344 eid_table->eid_prefix_len);
13347 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13348 vat_json_object_add_ip6 (node, "eid", ip6);
13349 vat_json_object_add_uint (node, "eid-prefix-len",
13350 eid_table->eid_prefix_len);
13353 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13355 vat_json_object_add_string_copy (node, "eid", s);
13359 errmsg ("unknown EID type %d!", eid_table->eid_type);
13367 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13368 eid_table_t * eid_table)
13370 locator_msg_t *loc = 0;
13371 vat_json_node_t *locator_array = 0;
13372 vat_json_node_t *locator = 0;
13373 struct in6_addr ip6;
13374 struct in_addr ip4;
13376 ASSERT (vam != NULL);
13377 ASSERT (node != NULL);
13378 ASSERT (eid_table != NULL);
13380 locator_array = vat_json_object_add_list (node, "locator");
13381 vec_foreach (loc, vam->locator_msg)
13383 locator = vat_json_array_add (locator_array);
13384 vat_json_init_object (locator);
13387 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13393 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13394 vat_json_object_add_ip6 (locator, "locator", ip6);
13398 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13399 vat_json_object_add_ip4 (locator, "locator", ip4);
13406 json_lisp_eid_table_dump (vat_main_t * vam)
13408 eid_table_t *eid_table;
13409 vat_json_node_t *node = 0;
13412 ASSERT (vam != NULL);
13414 ret = get_locator_set (vam);
13417 vec_free (vam->eid_tables);
13421 if (!vec_len (vam->eid_tables))
13423 /* just print [] */
13424 vat_json_init_array (&vam->json_tree);
13425 vat_json_print (vam->ofp, &vam->json_tree);
13426 vam->json_tree.type = VAT_JSON_NONE;
13430 if (VAT_JSON_ARRAY != vam->json_tree.type)
13432 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13433 vat_json_init_array (&vam->json_tree);
13436 vec_foreach (eid_table, vam->eid_tables)
13438 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13441 vec_free (vam->locator_msg);
13442 vec_free (vam->eid_tables);
13443 clean_locator_set_message (vam);
13444 vat_json_free (&vam->json_tree);
13445 vam->json_tree.type = VAT_JSON_NONE;
13449 node = vat_json_array_add (&vam->json_tree);
13450 vat_json_init_object (node);
13452 vat_json_object_add_uint (node, "vni", eid_table->vni);
13454 json_locator_set_for_eid_table (vam, node, eid_table);
13455 ret = json_eid_for_eid_table (vam, node, eid_table);
13458 vec_free (vam->locator_msg);
13459 vec_free (vam->eid_tables);
13460 clean_locator_set_message (vam);
13461 vat_json_free (&vam->json_tree);
13462 vam->json_tree.type = VAT_JSON_NONE;
13466 json_locator_for_eid_table (vam, node, eid_table);
13468 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13469 vat_json_object_add_uint (node, "authoritative",
13470 eid_table->authoritative);
13472 vec_free (vam->locator_msg);
13475 vat_json_print (vam->ofp, &vam->json_tree);
13476 vat_json_free (&vam->json_tree);
13477 vam->json_tree.type = VAT_JSON_NONE;
13479 clean_locator_set_message (vam);
13480 vec_free (vam->eid_tables);
13486 api_lisp_eid_table_dump (vat_main_t * vam)
13488 unformat_input_t *i = vam->input;
13489 vl_api_lisp_eid_table_dump_t *mp;
13491 struct in_addr ip4;
13492 struct in6_addr ip6;
13494 u8 eid_type = ~0, eid_set = 0;
13495 u32 prefix_length = ~0, t, vni = 0;
13498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13500 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13506 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13512 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13517 else if (unformat (i, "vni %d", &t))
13521 else if (unformat (i, "local"))
13525 else if (unformat (i, "remote"))
13531 errmsg ("parse error '%U'", format_unformat_error, i);
13536 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13538 mp->filter = filter;
13542 mp->vni = htonl (vni);
13543 mp->eid_type = eid_type;
13547 mp->prefix_length = prefix_length;
13548 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13551 mp->prefix_length = prefix_length;
13552 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13555 clib_memcpy (mp->eid, mac, sizeof (mac));
13558 errmsg ("unknown EID type %d!", eid_type);
13563 vam->noprint_msg = 1;
13568 /* Use a control ping for synchronization */
13570 vl_api_noprint_control_ping_t *mp;
13571 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13575 /* Wait for a reply... */
13579 if (vam->noprint_msg)
13581 if (!vam->json_output)
13583 vam->retval = print_lisp_eid_table_dump(vam);
13587 vam->retval = json_lisp_eid_table_dump(vam);
13590 vam->noprint_msg = 0;
13599 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13601 vl_api_lisp_gpe_tunnel_dump_t *mp;
13604 if (!vam->json_output)
13606 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13607 "%=16s%=16s%=16s%=16s%=16s\n",
13608 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13609 "Decap next", "Lisp version", "Flags", "Next protocol",
13610 "ver_res", "res", "iid");
13613 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13617 /* Use a control ping for synchronization */
13619 vl_api_control_ping_t *mp;
13620 M (CONTROL_PING, control_ping);
13623 /* Wait for a reply... */
13631 api_lisp_map_resolver_dump (vat_main_t * vam)
13633 vl_api_lisp_map_resolver_dump_t *mp;
13636 if (!vam->json_output)
13638 fformat (vam->ofp, "%=20s\n", "Map resolver");
13641 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13645 /* Use a control ping for synchronization */
13647 vl_api_control_ping_t *mp;
13648 M (CONTROL_PING, control_ping);
13651 /* Wait for a reply... */
13659 api_show_lisp_status (vat_main_t * vam)
13661 vl_api_show_lisp_status_t *mp;
13664 if (!vam->json_output)
13666 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13669 M (SHOW_LISP_STATUS, show_lisp_status);
13672 /* Wait for a reply... */
13680 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13682 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13685 if (!vam->json_output)
13687 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13690 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13693 /* Wait for a reply... */
13701 api_af_packet_create (vat_main_t * vam)
13703 unformat_input_t *i = vam->input;
13704 vl_api_af_packet_create_t *mp;
13706 u8 *host_if_name = 0;
13708 u8 random_hw_addr = 1;
13710 memset (hw_addr, 0, sizeof (hw_addr));
13712 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13714 if (unformat (i, "name %s", &host_if_name))
13715 vec_add1 (host_if_name, 0);
13716 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13717 random_hw_addr = 0;
13722 if (!vec_len (host_if_name))
13724 errmsg ("host-interface name must be specified");
13728 if (vec_len (host_if_name) > 64)
13730 errmsg ("host-interface name too long");
13734 M (AF_PACKET_CREATE, af_packet_create);
13736 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13737 clib_memcpy (mp->hw_addr, hw_addr, 6);
13738 mp->use_random_hw_addr = random_hw_addr;
13739 vec_free (host_if_name);
13742 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13748 api_af_packet_delete (vat_main_t * vam)
13750 unformat_input_t *i = vam->input;
13751 vl_api_af_packet_delete_t *mp;
13753 u8 *host_if_name = 0;
13755 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13757 if (unformat (i, "name %s", &host_if_name))
13758 vec_add1 (host_if_name, 0);
13763 if (!vec_len (host_if_name))
13765 errmsg ("host-interface name must be specified");
13769 if (vec_len (host_if_name) > 64)
13771 errmsg ("host-interface name too long");
13775 M (AF_PACKET_DELETE, af_packet_delete);
13777 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13778 vec_free (host_if_name);
13787 api_policer_add_del (vat_main_t * vam)
13789 unformat_input_t *i = vam->input;
13790 vl_api_policer_add_del_t *mp;
13801 u8 color_aware = 0;
13802 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13804 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
13805 conform_action.dscp = 0;
13806 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
13807 exceed_action.dscp = 0;
13808 violate_action.action_type = SSE2_QOS_ACTION_DROP;
13809 violate_action.dscp = 0;
13811 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13813 if (unformat (i, "del"))
13815 else if (unformat (i, "name %s", &name))
13816 vec_add1 (name, 0);
13817 else if (unformat (i, "cir %u", &cir))
13819 else if (unformat (i, "eir %u", &eir))
13821 else if (unformat (i, "cb %u", &cb))
13823 else if (unformat (i, "eb %u", &eb))
13825 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13828 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13831 else if (unformat (i, "type %U", unformat_policer_type, &type))
13833 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13836 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13839 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13842 else if (unformat (i, "color-aware"))
13848 if (!vec_len (name))
13850 errmsg ("policer name must be specified");
13854 if (vec_len (name) > 64)
13856 errmsg ("policer name too long");
13860 M (POLICER_ADD_DEL, policer_add_del);
13862 clib_memcpy (mp->name, name, vec_len (name));
13864 mp->is_add = is_add;
13869 mp->rate_type = rate_type;
13870 mp->round_type = round_type;
13872 mp->conform_action_type = conform_action.action_type;
13873 mp->conform_dscp = conform_action.dscp;
13874 mp->exceed_action_type = exceed_action.action_type;
13875 mp->exceed_dscp = exceed_action.dscp;
13876 mp->violate_action_type = violate_action.action_type;
13877 mp->violate_dscp = violate_action.dscp;
13878 mp->color_aware = color_aware;
13887 api_policer_dump (vat_main_t * vam)
13889 unformat_input_t *i = vam->input;
13890 vl_api_policer_dump_t *mp;
13892 u8 *match_name = 0;
13893 u8 match_name_valid = 0;
13895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13897 if (unformat (i, "name %s", &match_name))
13899 vec_add1 (match_name, 0);
13900 match_name_valid = 1;
13906 M (POLICER_DUMP, policer_dump);
13907 mp->match_name_valid = match_name_valid;
13908 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13909 vec_free (match_name);
13913 /* Use a control ping for synchronization */
13915 vl_api_control_ping_t *mp;
13916 M (CONTROL_PING, control_ping);
13919 /* Wait for a reply... */
13927 api_policer_classify_set_interface (vat_main_t * vam)
13929 unformat_input_t *i = vam->input;
13930 vl_api_policer_classify_set_interface_t *mp;
13933 int sw_if_index_set;
13934 u32 ip4_table_index = ~0;
13935 u32 ip6_table_index = ~0;
13936 u32 l2_table_index = ~0;
13939 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13941 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13942 sw_if_index_set = 1;
13943 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13944 sw_if_index_set = 1;
13945 else if (unformat (i, "del"))
13947 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13949 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13951 else if (unformat (i, "l2-table %d", &l2_table_index))
13955 clib_warning ("parse error '%U'", format_unformat_error, i);
13960 if (sw_if_index_set == 0)
13962 errmsg ("missing interface name or sw_if_index\n");
13966 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13968 mp->sw_if_index = ntohl (sw_if_index);
13969 mp->ip4_table_index = ntohl (ip4_table_index);
13970 mp->ip6_table_index = ntohl (ip6_table_index);
13971 mp->l2_table_index = ntohl (l2_table_index);
13972 mp->is_add = is_add;
13981 api_policer_classify_dump (vat_main_t * vam)
13983 unformat_input_t *i = vam->input;
13984 vl_api_policer_classify_dump_t *mp;
13986 u8 type = POLICER_CLASSIFY_N_TABLES;
13988 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13992 errmsg ("classify table type must be specified\n");
13996 if (!vam->json_output)
13998 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14001 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14006 /* Use a control ping for synchronization */
14008 vl_api_control_ping_t *mp;
14009 M (CONTROL_PING, control_ping);
14012 /* Wait for a reply... */
14020 api_netmap_create (vat_main_t * vam)
14022 unformat_input_t *i = vam->input;
14023 vl_api_netmap_create_t *mp;
14027 u8 random_hw_addr = 1;
14031 memset (hw_addr, 0, sizeof (hw_addr));
14033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14035 if (unformat (i, "name %s", &if_name))
14036 vec_add1 (if_name, 0);
14037 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14038 random_hw_addr = 0;
14039 else if (unformat (i, "pipe"))
14041 else if (unformat (i, "master"))
14043 else if (unformat (i, "slave"))
14049 if (!vec_len (if_name))
14051 errmsg ("interface name must be specified");
14055 if (vec_len (if_name) > 64)
14057 errmsg ("interface name too long");
14061 M (NETMAP_CREATE, netmap_create);
14063 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14064 clib_memcpy (mp->hw_addr, hw_addr, 6);
14065 mp->use_random_hw_addr = random_hw_addr;
14066 mp->is_pipe = is_pipe;
14067 mp->is_master = is_master;
14068 vec_free (if_name);
14077 api_netmap_delete (vat_main_t * vam)
14079 unformat_input_t *i = vam->input;
14080 vl_api_netmap_delete_t *mp;
14084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14086 if (unformat (i, "name %s", &if_name))
14087 vec_add1 (if_name, 0);
14092 if (!vec_len (if_name))
14094 errmsg ("interface name must be specified");
14098 if (vec_len (if_name) > 64)
14100 errmsg ("interface name too long");
14104 M (NETMAP_DELETE, netmap_delete);
14106 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14107 vec_free (if_name);
14115 static void vl_api_mpls_gre_tunnel_details_t_handler
14116 (vl_api_mpls_gre_tunnel_details_t * mp)
14118 vat_main_t *vam = &vat_main;
14120 i32 len = ntohl (mp->nlabels);
14122 if (mp->l2_only == 0)
14124 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14125 ntohl (mp->tunnel_index),
14126 format_ip4_address, &mp->tunnel_src,
14127 format_ip4_address, &mp->tunnel_dst,
14128 format_ip4_address, &mp->intfc_address,
14129 ntohl (mp->mask_width));
14130 for (i = 0; i < len; i++)
14132 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14134 fformat (vam->ofp, "\n");
14135 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14136 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14140 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14141 ntohl (mp->tunnel_index),
14142 format_ip4_address, &mp->tunnel_src,
14143 format_ip4_address, &mp->tunnel_dst,
14144 format_ip4_address, &mp->intfc_address);
14145 for (i = 0; i < len; i++)
14147 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14149 fformat (vam->ofp, "\n");
14150 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14151 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14155 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14156 (vl_api_mpls_gre_tunnel_details_t * mp)
14158 vat_main_t *vam = &vat_main;
14159 vat_json_node_t *node = NULL;
14160 struct in_addr ip4;
14162 i32 len = ntohl (mp->nlabels);
14164 if (VAT_JSON_ARRAY != vam->json_tree.type)
14166 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14167 vat_json_init_array (&vam->json_tree);
14169 node = vat_json_array_add (&vam->json_tree);
14171 vat_json_init_object (node);
14172 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14173 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14174 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14175 vat_json_object_add_uint (node, "inner_fib_index",
14176 ntohl (mp->inner_fib_index));
14177 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14178 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14179 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14180 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14181 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14182 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14183 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14184 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14185 vat_json_object_add_uint (node, "outer_fib_index",
14186 ntohl (mp->outer_fib_index));
14187 vat_json_object_add_uint (node, "label_count", len);
14188 for (i = 0; i < len; i++)
14190 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14195 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14197 vl_api_mpls_gre_tunnel_dump_t *mp;
14201 /* Parse args required to build the message */
14202 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14204 if (!unformat (vam->input, "tunnel_index %d", &index))
14211 fformat (vam->ofp, " tunnel_index %d\n", index);
14213 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14214 mp->tunnel_index = htonl (index);
14217 /* Use a control ping for synchronization */
14219 vl_api_control_ping_t *mp;
14220 M (CONTROL_PING, control_ping);
14226 static void vl_api_mpls_eth_tunnel_details_t_handler
14227 (vl_api_mpls_eth_tunnel_details_t * mp)
14229 vat_main_t *vam = &vat_main;
14231 i32 len = ntohl (mp->nlabels);
14233 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14234 ntohl (mp->tunnel_index),
14235 format_ethernet_address, &mp->tunnel_dst_mac,
14236 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14237 for (i = 0; i < len; i++)
14239 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14241 fformat (vam->ofp, "\n");
14242 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14243 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14246 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14247 (vl_api_mpls_eth_tunnel_details_t * mp)
14249 vat_main_t *vam = &vat_main;
14250 vat_json_node_t *node = NULL;
14251 struct in_addr ip4;
14253 i32 len = ntohl (mp->nlabels);
14255 if (VAT_JSON_ARRAY != vam->json_tree.type)
14257 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14258 vat_json_init_array (&vam->json_tree);
14260 node = vat_json_array_add (&vam->json_tree);
14262 vat_json_init_object (node);
14263 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14264 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14265 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14266 vat_json_object_add_uint (node, "inner_fib_index",
14267 ntohl (mp->inner_fib_index));
14268 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14269 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14270 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14271 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14272 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14273 format (0, "%U", format_ethernet_address,
14274 &mp->tunnel_dst_mac));
14275 vat_json_object_add_uint (node, "tx_sw_if_index",
14276 ntohl (mp->tx_sw_if_index));
14277 vat_json_object_add_uint (node, "label_count", len);
14278 for (i = 0; i < len; i++)
14280 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14285 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14287 vl_api_mpls_eth_tunnel_dump_t *mp;
14291 /* Parse args required to build the message */
14292 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14294 if (!unformat (vam->input, "tunnel_index %d", &index))
14301 fformat (vam->ofp, " tunnel_index %d\n", index);
14303 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14304 mp->tunnel_index = htonl (index);
14307 /* Use a control ping for synchronization */
14309 vl_api_control_ping_t *mp;
14310 M (CONTROL_PING, control_ping);
14316 static void vl_api_mpls_fib_encap_details_t_handler
14317 (vl_api_mpls_fib_encap_details_t * mp)
14319 vat_main_t *vam = &vat_main;
14321 i32 len = ntohl (mp->nlabels);
14323 fformat (vam->ofp, "table %d, dest %U, label ",
14324 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14325 for (i = 0; i < len; i++)
14327 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14329 fformat (vam->ofp, "\n");
14332 static void vl_api_mpls_fib_encap_details_t_handler_json
14333 (vl_api_mpls_fib_encap_details_t * mp)
14335 vat_main_t *vam = &vat_main;
14336 vat_json_node_t *node = NULL;
14338 i32 len = ntohl (mp->nlabels);
14339 struct in_addr ip4;
14341 if (VAT_JSON_ARRAY != vam->json_tree.type)
14343 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14344 vat_json_init_array (&vam->json_tree);
14346 node = vat_json_array_add (&vam->json_tree);
14348 vat_json_init_object (node);
14349 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14350 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14351 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14352 vat_json_object_add_ip4 (node, "dest", ip4);
14353 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14354 vat_json_object_add_uint (node, "label_count", len);
14355 for (i = 0; i < len; i++)
14357 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14362 api_mpls_fib_encap_dump (vat_main_t * vam)
14364 vl_api_mpls_fib_encap_dump_t *mp;
14367 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14370 /* Use a control ping for synchronization */
14372 vl_api_control_ping_t *mp;
14373 M (CONTROL_PING, control_ping);
14379 static void vl_api_mpls_fib_decap_details_t_handler
14380 (vl_api_mpls_fib_decap_details_t * mp)
14382 vat_main_t *vam = &vat_main;
14385 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14386 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14387 ntohl (mp->label), ntohl (mp->s_bit));
14390 static void vl_api_mpls_fib_decap_details_t_handler_json
14391 (vl_api_mpls_fib_decap_details_t * mp)
14393 vat_main_t *vam = &vat_main;
14394 vat_json_node_t *node = NULL;
14395 struct in_addr ip4;
14397 if (VAT_JSON_ARRAY != vam->json_tree.type)
14399 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14400 vat_json_init_array (&vam->json_tree);
14402 node = vat_json_array_add (&vam->json_tree);
14404 vat_json_init_object (node);
14405 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14406 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14407 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14408 vat_json_object_add_ip4 (node, "dest", ip4);
14409 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14410 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14411 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14412 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14413 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14417 api_mpls_fib_decap_dump (vat_main_t * vam)
14419 vl_api_mpls_fib_decap_dump_t *mp;
14422 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14425 /* Use a control ping for synchronization */
14427 vl_api_control_ping_t *mp;
14428 M (CONTROL_PING, control_ping);
14435 api_classify_table_ids (vat_main_t * vam)
14437 vl_api_classify_table_ids_t *mp;
14440 /* Construct the API message */
14441 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14451 api_classify_table_by_interface (vat_main_t * vam)
14453 unformat_input_t *input = vam->input;
14454 vl_api_classify_table_by_interface_t *mp;
14457 u32 sw_if_index = ~0;
14458 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14460 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14462 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14467 if (sw_if_index == ~0)
14469 errmsg ("missing interface name or sw_if_index\n");
14473 /* Construct the API message */
14474 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14476 mp->sw_if_index = ntohl (sw_if_index);
14485 api_classify_table_info (vat_main_t * vam)
14487 unformat_input_t *input = vam->input;
14488 vl_api_classify_table_info_t *mp;
14492 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14494 if (unformat (input, "table_id %d", &table_id))
14499 if (table_id == ~0)
14501 errmsg ("missing table id\n");
14505 /* Construct the API message */
14506 M (CLASSIFY_TABLE_INFO, classify_table_info);
14508 mp->table_id = ntohl (table_id);
14517 api_classify_session_dump (vat_main_t * vam)
14519 unformat_input_t *input = vam->input;
14520 vl_api_classify_session_dump_t *mp;
14524 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14526 if (unformat (input, "table_id %d", &table_id))
14531 if (table_id == ~0)
14533 errmsg ("missing table id\n");
14537 /* Construct the API message */
14538 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14540 mp->table_id = ntohl (table_id);
14543 /* Use a control ping for synchronization */
14545 vl_api_control_ping_t *mp;
14546 M (CONTROL_PING, control_ping);
14555 vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
14557 vat_main_t *vam = &vat_main;
14559 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14560 "src_address %U, fib_index %u, path_mtu %u, "
14561 "template_interval %u\n",
14562 format_ip4_address, mp->collector_address,
14563 ntohs (mp->collector_port),
14564 format_ip4_address, mp->src_address,
14565 ntohl (mp->fib_index),
14566 ntohl (mp->path_mtu), ntohl (mp->template_interval));
14569 vam->result_ready = 1;
14573 vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp)
14575 vat_main_t *vam = &vat_main;
14576 vat_json_node_t node;
14577 struct in_addr collector_address;
14578 struct in_addr src_address;
14580 vat_json_init_object (&node);
14581 clib_memcpy (&collector_address, &mp->collector_address,
14582 sizeof (collector_address));
14583 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14584 vat_json_object_add_uint (&node, "collector_port",
14585 ntohs (mp->collector_port));
14586 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14587 vat_json_object_add_ip4 (&node, "src_address", src_address);
14588 vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index));
14589 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14590 vat_json_object_add_uint (&node, "template_interval",
14591 ntohl (mp->template_interval));
14593 vat_json_print (vam->ofp, &node);
14594 vat_json_free (&node);
14596 vam->result_ready = 1;
14600 api_ipfix_dump (vat_main_t * vam)
14602 vl_api_ipfix_dump_t *mp;
14605 /* Construct the API message */
14606 M (IPFIX_DUMP, ipfix_dump);
14616 api_pg_create_interface (vat_main_t * vam)
14618 unformat_input_t *input = vam->input;
14619 vl_api_pg_create_interface_t *mp;
14623 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14625 if (unformat (input, "if_id %d", &if_id))
14632 errmsg ("missing pg interface index\n");
14636 /* Construct the API message */
14637 M (PG_CREATE_INTERFACE, pg_create_interface);
14639 mp->interface_id = ntohl (if_id);
14648 api_pg_capture (vat_main_t * vam)
14650 unformat_input_t *input = vam->input;
14651 vl_api_pg_capture_t *mp;
14657 u8 pcap_file_set = 0;
14659 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14661 if (unformat (input, "if_id %d", &if_id))
14663 else if (unformat (input, "pcap %s", &pcap_file))
14665 else if (unformat (input, "count %d", &count))
14667 else if (unformat (input, "disable"))
14674 errmsg ("missing pg interface index\n");
14677 if (pcap_file_set > 0)
14679 if (vec_len (pcap_file) > 255)
14681 errmsg ("pcap file name is too long\n");
14686 u32 name_len = vec_len (pcap_file);
14687 /* Construct the API message */
14688 M (PG_CAPTURE, pg_capture);
14690 mp->interface_id = ntohl (if_id);
14691 mp->is_enabled = enable;
14692 mp->count = ntohl (count);
14693 mp->pcap_name_length = ntohl (name_len);
14694 if (pcap_file_set != 0)
14696 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14698 vec_free (pcap_file);
14707 api_pg_enable_disable (vat_main_t * vam)
14709 unformat_input_t *input = vam->input;
14710 vl_api_pg_enable_disable_t *mp;
14714 u8 stream_name_set = 0;
14715 u8 *stream_name = 0;
14716 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14718 if (unformat (input, "stream %s", &stream_name))
14719 stream_name_set = 1;
14720 else if (unformat (input, "disable"))
14726 if (stream_name_set > 0)
14728 if (vec_len (stream_name) > 255)
14730 errmsg ("stream name too long\n");
14735 u32 name_len = vec_len (stream_name);
14736 /* Construct the API message */
14737 M (PG_ENABLE_DISABLE, pg_enable_disable);
14739 mp->is_enabled = enable;
14740 if (stream_name_set != 0)
14742 mp->stream_name_length = ntohl (name_len);
14743 clib_memcpy (mp->stream_name, stream_name, name_len);
14745 vec_free (stream_name);
14754 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14756 unformat_input_t *input = vam->input;
14757 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14760 u16 *low_ports = 0;
14761 u16 *high_ports = 0;
14764 ip4_address_t ip4_addr;
14765 ip6_address_t ip6_addr;
14773 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14775 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14781 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14786 else if (unformat (input, "vrf %d", &vrf_id))
14788 else if (unformat (input, "del"))
14790 else if (unformat (input, "port %d", &tmp))
14792 if (tmp == 0 || tmp > 65535)
14794 errmsg ("port %d out of range", tmp);
14798 this_hi = this_low + 1;
14799 vec_add1 (low_ports, this_low);
14800 vec_add1 (high_ports, this_hi);
14802 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14804 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14806 errmsg ("incorrect range parameters\n");
14810 /* Note: in debug CLI +1 is added to high before
14811 passing to real fn that does "the work"
14812 (ip_source_and_port_range_check_add_del).
14813 This fn is a wrapper around the binary API fn a
14814 control plane will call, which expects this increment
14815 to have occurred. Hence letting the binary API control
14816 plane fn do the increment for consistency between VAT
14817 and other control planes.
14820 vec_add1 (low_ports, this_low);
14821 vec_add1 (high_ports, this_hi);
14827 if (prefix_set == 0)
14829 errmsg ("<address>/<mask> not specified\n");
14835 errmsg ("VRF ID required, not specified\n");
14842 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14846 if (vec_len (low_ports) == 0)
14848 errmsg ("At least one port or port range required\n");
14852 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14853 ip_source_and_port_range_check_add_del);
14855 mp->is_add = is_add;
14860 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14865 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14868 mp->mask_length = length;
14869 mp->number_of_ranges = vec_len (low_ports);
14871 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14872 vec_free (low_ports);
14874 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14875 vec_free (high_ports);
14877 mp->vrf_id = ntohl (vrf_id);
14886 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14888 unformat_input_t *input = vam->input;
14889 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14891 u32 sw_if_index = ~0;
14893 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14894 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14897 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14899 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14901 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14903 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14905 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14907 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14909 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14911 else if (unformat (input, "del"))
14917 if (sw_if_index == ~0)
14919 errmsg ("Interface required but not specified\n");
14925 errmsg ("VRF ID required but not specified\n");
14929 if (tcp_out_vrf_id == 0
14930 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14933 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14937 /* Construct the API message */
14938 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14939 ip_source_and_port_range_check_interface_add_del);
14941 mp->sw_if_index = ntohl (sw_if_index);
14942 mp->is_add = is_add;
14943 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14944 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14945 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14946 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14951 /* Wait for a reply... */
14956 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
14958 unformat_input_t *i = vam->input;
14959 vl_api_ipsec_gre_add_del_tunnel_t *mp;
14961 u32 local_sa_id = 0;
14962 u32 remote_sa_id = 0;
14963 ip4_address_t src_address;
14964 ip4_address_t dst_address;
14967 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14969 if (unformat (i, "local_sa %d", &local_sa_id))
14971 else if (unformat (i, "remote_sa %d", &remote_sa_id))
14973 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
14975 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
14977 else if (unformat (i, "del"))
14981 clib_warning ("parse error '%U'", format_unformat_error, i);
14986 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
14988 mp->local_sa_id = ntohl (local_sa_id);
14989 mp->remote_sa_id = ntohl (remote_sa_id);
14990 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
14991 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
14992 mp->is_add = is_add;
15000 static void vl_api_ipsec_gre_tunnel_details_t_handler
15001 (vl_api_ipsec_gre_tunnel_details_t * mp)
15003 vat_main_t *vam = &vat_main;
15005 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15006 ntohl (mp->sw_if_index),
15007 format_ip4_address, &mp->src_address,
15008 format_ip4_address, &mp->dst_address,
15009 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15012 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15013 (vl_api_ipsec_gre_tunnel_details_t * mp)
15015 vat_main_t *vam = &vat_main;
15016 vat_json_node_t *node = NULL;
15017 struct in_addr ip4;
15019 if (VAT_JSON_ARRAY != vam->json_tree.type)
15021 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15022 vat_json_init_array (&vam->json_tree);
15024 node = vat_json_array_add (&vam->json_tree);
15026 vat_json_init_object (node);
15027 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15028 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15029 vat_json_object_add_ip4 (node, "src_address", ip4);
15030 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15031 vat_json_object_add_ip4 (node, "dst_address", ip4);
15032 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15033 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15037 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15039 unformat_input_t *i = vam->input;
15040 vl_api_ipsec_gre_tunnel_dump_t *mp;
15043 u8 sw_if_index_set = 0;
15045 /* Parse args required to build the message */
15046 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15048 if (unformat (i, "sw_if_index %d", &sw_if_index))
15049 sw_if_index_set = 1;
15054 if (sw_if_index_set == 0)
15059 if (!vam->json_output)
15061 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15062 "sw_if_index", "src_address", "dst_address",
15063 "local_sa_id", "remote_sa_id");
15066 /* Get list of gre-tunnel interfaces */
15067 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15069 mp->sw_if_index = htonl (sw_if_index);
15073 /* Use a control ping for synchronization */
15075 vl_api_control_ping_t *mp;
15076 M (CONTROL_PING, control_ping);
15083 q_or_quit (vat_main_t * vam)
15085 longjmp (vam->jump_buf, 1);
15086 return 0; /* not so much */
15090 q (vat_main_t * vam)
15092 return q_or_quit (vam);
15096 quit (vat_main_t * vam)
15098 return q_or_quit (vam);
15102 comment (vat_main_t * vam)
15108 cmd_cmp (void *a1, void *a2)
15113 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15117 help (vat_main_t * vam)
15122 unformat_input_t *i = vam->input;
15125 if (unformat (i, "%s", &name))
15129 vec_add1 (name, 0);
15131 hs = hash_get_mem (vam->help_by_name, name);
15133 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15135 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15140 fformat (vam->ofp, "Help is available for the following:\n");
15143 hash_foreach_pair (p, vam->function_by_name,
15145 vec_add1 (cmds, (u8 *)(p->key));
15149 vec_sort_with_function (cmds, cmd_cmp);
15151 for (j = 0; j < vec_len (cmds); j++)
15152 fformat (vam->ofp, "%s\n", cmds[j]);
15159 set (vat_main_t * vam)
15161 u8 *name = 0, *value = 0;
15162 unformat_input_t *i = vam->input;
15164 if (unformat (i, "%s", &name))
15166 /* The input buffer is a vector, not a string. */
15167 value = vec_dup (i->buffer);
15168 vec_delete (value, i->index, 0);
15169 /* Almost certainly has a trailing newline */
15170 if (value[vec_len (value) - 1] == '\n')
15171 value[vec_len (value) - 1] = 0;
15172 /* Make sure it's a proper string, one way or the other */
15173 vec_add1 (value, 0);
15174 (void) clib_macro_set_value (&vam->macro_main,
15175 (char *) name, (char *) value);
15178 errmsg ("usage: set <name> <value>\n");
15186 unset (vat_main_t * vam)
15190 if (unformat (vam->input, "%s", &name))
15191 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15192 errmsg ("unset: %s wasn't set\n", name);
15205 macro_sort_cmp (void *a1, void *a2)
15207 macro_sort_t *s1 = a1;
15208 macro_sort_t *s2 = a2;
15210 return strcmp ((char *) (s1->name), (char *) (s2->name));
15214 dump_macro_table (vat_main_t * vam)
15216 macro_sort_t *sort_me = 0, *sm;
15221 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15223 vec_add2 (sort_me, sm, 1);
15224 sm->name = (u8 *)(p->key);
15225 sm->value = (u8 *) (p->value[0]);
15229 vec_sort_with_function (sort_me, macro_sort_cmp);
15231 if (vec_len (sort_me))
15232 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15234 fformat (vam->ofp, "The macro table is empty...\n");
15236 for (i = 0; i < vec_len (sort_me); i++)
15237 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15242 dump_node_table (vat_main_t * vam)
15245 vlib_node_t *node, *next_node;
15247 if (vec_len (vam->graph_nodes) == 0)
15249 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15253 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15255 node = vam->graph_nodes[i];
15256 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15257 for (j = 0; j < vec_len (node->next_nodes); j++)
15259 if (node->next_nodes[j] != ~0)
15261 next_node = vam->graph_nodes[node->next_nodes[j]];
15262 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15270 search_node_table (vat_main_t * vam)
15272 unformat_input_t *line_input = vam->input;
15275 vlib_node_t *node, *next_node;
15278 if (vam->graph_node_index_by_name == 0)
15280 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15284 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15286 if (unformat (line_input, "%s", &node_to_find))
15288 vec_add1 (node_to_find, 0);
15289 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15292 fformat (vam->ofp, "%s not found...\n", node_to_find);
15295 node = vam->graph_nodes[p[0]];
15296 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15297 for (j = 0; j < vec_len (node->next_nodes); j++)
15299 if (node->next_nodes[j] != ~0)
15301 next_node = vam->graph_nodes[node->next_nodes[j]];
15302 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15309 clib_warning ("parse error '%U'", format_unformat_error,
15315 vec_free (node_to_find);
15324 script (vat_main_t * vam)
15327 char *save_current_file;
15328 unformat_input_t save_input;
15329 jmp_buf save_jump_buf;
15330 u32 save_line_number;
15332 FILE *new_fp, *save_ifp;
15334 if (unformat (vam->input, "%s", &s))
15336 new_fp = fopen ((char *) s, "r");
15339 errmsg ("Couldn't open script file %s\n", s);
15346 errmsg ("Missing script name\n");
15350 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15351 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15352 save_ifp = vam->ifp;
15353 save_line_number = vam->input_line_number;
15354 save_current_file = (char *) vam->current_file;
15356 vam->input_line_number = 0;
15358 vam->current_file = s;
15361 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15362 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15363 vam->ifp = save_ifp;
15364 vam->input_line_number = save_line_number;
15365 vam->current_file = (u8 *) save_current_file;
15372 echo (vat_main_t * vam)
15374 fformat (vam->ofp, "%v", vam->input->buffer);
15378 /* List of API message constructors, CLI names map to api_xxx */
15379 #define foreach_vpe_api_msg \
15380 _(create_loopback,"[mac <mac-addr>]") \
15381 _(sw_interface_dump,"") \
15382 _(sw_interface_set_flags, \
15383 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15384 _(sw_interface_add_del_address, \
15385 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15386 _(sw_interface_set_table, \
15387 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15388 _(sw_interface_set_vpath, \
15389 "<intfc> | sw_if_index <id> enable | disable") \
15390 _(sw_interface_set_l2_xconnect, \
15391 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15392 "enable | disable") \
15393 _(sw_interface_set_l2_bridge, \
15394 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15395 "[shg <split-horizon-group>] [bvi]\n" \
15396 "enable | disable") \
15397 _(bridge_domain_add_del, \
15398 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15399 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15401 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15403 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15405 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15407 "tapname <name> mac <mac-addr> | random-mac") \
15409 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15411 "<vpp-if-name> | sw_if_index <id>") \
15412 _(sw_interface_tap_dump, "") \
15413 _(ip_add_del_route, \
15414 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15415 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15416 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15417 "[multipath] [count <n>]") \
15418 _(proxy_arp_add_del, \
15419 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15420 _(proxy_arp_intfc_enable_disable, \
15421 "<intfc> | sw_if_index <id> enable | disable") \
15422 _(mpls_add_del_encap, \
15423 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15424 _(mpls_add_del_decap, \
15425 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15426 _(mpls_gre_add_del_tunnel, \
15427 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15428 "adj <ip4-address>/<mask-width> [del]") \
15429 _(sw_interface_set_unnumbered, \
15430 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15431 _(ip_neighbor_add_del, \
15432 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15433 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15434 _(reset_vrf, "vrf <id> [ipv6]") \
15435 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15436 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15437 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15438 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15439 "[outer_vlan_id_any][inner_vlan_id_any]") \
15440 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15441 _(reset_fib, "vrf <n> [ipv6]") \
15442 _(dhcp_proxy_config, \
15443 "svr <v46-address> src <v46-address>\n" \
15444 "insert-cid <n> [del]") \
15445 _(dhcp_proxy_config_2, \
15446 "svr <v46-address> src <v46-address>\n" \
15447 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15448 _(dhcp_proxy_set_vss, \
15449 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15450 _(dhcp_client_config, \
15451 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15452 _(set_ip_flow_hash, \
15453 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15454 _(sw_interface_ip6_enable_disable, \
15455 "<intfc> | sw_if_index <id> enable | disable") \
15456 _(sw_interface_ip6_set_link_local_address, \
15457 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15458 _(sw_interface_ip6nd_ra_prefix, \
15459 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15460 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15461 "[nolink] [isno]") \
15462 _(sw_interface_ip6nd_ra_config, \
15463 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15464 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15465 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15466 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15467 _(l2_patch_add_del, \
15468 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15469 "enable | disable") \
15470 _(mpls_ethernet_add_del_tunnel, \
15471 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15472 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15473 _(mpls_ethernet_add_del_tunnel_2, \
15474 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15475 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15476 _(sr_tunnel_add_del, \
15477 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15478 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15479 "[policy <policy_name>]") \
15480 _(sr_policy_add_del, \
15481 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15482 _(sr_multicast_map_add_del, \
15483 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15484 _(classify_add_del_table, \
15485 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15486 "[del] mask <mask-value>\n" \
15487 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15488 _(classify_add_del_session, \
15489 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15490 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15491 " [l3 [ip4|ip6]]") \
15492 _(classify_set_interface_ip_table, \
15493 "<intfc> | sw_if_index <nn> table <nn>") \
15494 _(classify_set_interface_l2_tables, \
15495 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15496 " [other-table <nn>]") \
15497 _(get_node_index, "node <node-name") \
15498 _(add_node_next, "node <node-name> next <next-node-name>") \
15499 _(l2tpv3_create_tunnel, \
15500 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15501 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15502 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15503 _(l2tpv3_set_tunnel_cookies, \
15504 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15505 "[new_remote_cookie <nn>]\n") \
15506 _(l2tpv3_interface_enable_disable, \
15507 "<intfc> | sw_if_index <nn> enable | disable") \
15508 _(l2tpv3_set_lookup_key, \
15509 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15510 _(sw_if_l2tpv3_tunnel_dump, "") \
15511 _(vxlan_add_del_tunnel, \
15512 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15513 " [decap-next l2|ip4|ip6] [del]") \
15514 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15515 _(gre_add_del_tunnel, \
15516 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15517 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15518 _(l2_fib_clear_table, "") \
15519 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15520 _(l2_interface_vlan_tag_rewrite, \
15521 "<intfc> | sw_if_index <nn> \n" \
15522 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15523 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15524 _(create_vhost_user_if, \
15525 "socket <filename> [server] [renumber <dev_instance>] " \
15526 "[mac <mac_address>]") \
15527 _(modify_vhost_user_if, \
15528 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15529 "[server] [renumber <dev_instance>]") \
15530 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15531 _(sw_interface_vhost_user_dump, "") \
15532 _(show_version, "") \
15533 _(vxlan_gpe_add_del_tunnel, \
15534 "local <addr> remote <addr> vni <nn>\n" \
15535 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15536 "[next-ethernet] [next-nsh]\n") \
15537 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15538 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15539 _(interface_name_renumber, \
15540 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15541 _(input_acl_set_interface, \
15542 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15543 " [l2-table <nn>] [del]") \
15544 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15545 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15546 _(ip_dump, "ipv4 | ipv6") \
15547 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15548 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15550 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15551 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15552 " integ_alg <alg> integ_key <hex>") \
15553 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15554 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15555 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15556 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15557 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15558 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15559 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15560 "(auth_data 0x<data> | auth_data <data>)") \
15561 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15562 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15563 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15564 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15565 "(local|remote)") \
15566 _(ikev2_set_local_key, "file <absolute_file_path>") \
15567 _(delete_loopback,"sw_if_index <nn>") \
15568 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15569 _(map_add_domain, \
15570 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15571 "ip6-src <ip6addr> " \
15572 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15573 _(map_del_domain, "index <n>") \
15574 _(map_add_del_rule, \
15575 "index <n> psid <n> dst <ip6addr> [del]") \
15576 _(map_domain_dump, "") \
15577 _(map_rule_dump, "index <map-domain>") \
15578 _(want_interface_events, "enable|disable") \
15579 _(want_stats,"enable|disable") \
15580 _(get_first_msg_id, "client <name>") \
15581 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15582 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15583 "fib-id <nn> [ip4][ip6][default]") \
15584 _(get_node_graph, " ") \
15585 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15586 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
15587 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
15588 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
15589 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
15590 " vrf_id <nn> add | pop | none") \
15591 _(trace_profile_del, "") \
15592 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15593 " sw_if_index <sw_if_index> p <priority> " \
15594 "w <weight>] [del]") \
15595 _(lisp_add_del_locator, "locator-set <locator_name> " \
15596 "iface <intf> | sw_if_index <sw_if_index> " \
15597 "p <priority> w <weight> [del]") \
15598 _(lisp_add_del_local_eid,"vni <vni> eid " \
15599 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15600 "locator-set <locator_name> [del]") \
15601 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15602 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15603 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15604 _(lisp_gpe_enable_disable, "enable|disable") \
15605 _(lisp_enable_disable, "enable|disable") \
15606 _(lisp_gpe_add_del_iface, "up|down") \
15607 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
15608 "rloc <locator> p <prio> " \
15609 "w <weight> [rloc <loc> ... ] " \
15610 "action <action> [del-all]") \
15611 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15612 "<src-eid> rloc <locator> p <prio> w <weight>"\
15613 "[rloc <loc> ... ] action <action>") \
15614 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15615 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15616 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15617 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
15618 "locator-set <loc-set-name>] [local | remote]")\
15619 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15620 "[local] | [remote]") \
15621 _(lisp_eid_table_map_dump, "") \
15622 _(lisp_gpe_tunnel_dump, "") \
15623 _(lisp_map_resolver_dump, "") \
15624 _(show_lisp_status, "") \
15625 _(lisp_get_map_request_itr_rlocs, "") \
15626 _(show_lisp_pitr, "") \
15627 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15628 _(af_packet_delete, "name <host interface name>") \
15629 _(policer_add_del, "name <policer name> <params> [del]") \
15630 _(policer_dump, "[name <policer name>]") \
15631 _(policer_classify_set_interface, \
15632 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15633 " [l2-table <nn>] [del]") \
15634 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15635 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15636 "[master|slave]") \
15637 _(netmap_delete, "name <interface name>") \
15638 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15639 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15640 _(mpls_fib_encap_dump, "") \
15641 _(mpls_fib_decap_dump, "") \
15642 _(classify_table_ids, "") \
15643 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15644 _(classify_table_info, "table_id <nn>") \
15645 _(classify_session_dump, "table_id <nn>") \
15646 _(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
15647 "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
15648 "[template_interval <nn>]") \
15649 _(ipfix_dump, "") \
15650 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15651 _(pg_create_interface, "if_id <nn>") \
15652 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15653 _(pg_enable_disable, "[stream <id>] disable") \
15654 _(ip_source_and_port_range_check_add_del, \
15655 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15656 _(ip_source_and_port_range_check_interface_add_del, \
15657 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15658 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
15659 _(ipsec_gre_add_del_tunnel, \
15660 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
15661 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]")
15663 /* List of command functions, CLI names map directly to functions */
15664 #define foreach_cli_function \
15665 _(comment, "usage: comment <ignore-rest-of-line>") \
15666 _(dump_interface_table, "usage: dump_interface_table") \
15667 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15668 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15669 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15670 _(dump_stats_table, "usage: dump_stats_table") \
15671 _(dump_macro_table, "usage: dump_macro_table ") \
15672 _(dump_node_table, "usage: dump_node_table") \
15673 _(echo, "usage: echo <message>") \
15674 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15675 _(help, "usage: help") \
15676 _(q, "usage: quit") \
15677 _(quit, "usage: quit") \
15678 _(search_node_table, "usage: search_node_table <name>...") \
15679 _(set, "usage: set <variable-name> <value>") \
15680 _(script, "usage: script <file-name>") \
15681 _(unset, "usage: unset <variable-name>")
15684 static void vl_api_##n##_t_handler_uni \
15685 (vl_api_##n##_t * mp) \
15687 vat_main_t * vam = &vat_main; \
15688 if (vam->json_output) { \
15689 vl_api_##n##_t_handler_json(mp); \
15691 vl_api_##n##_t_handler(mp); \
15694 foreach_vpe_api_reply_msg;
15698 vat_api_hookup (vat_main_t * vam)
15701 vl_msg_api_set_handlers(VL_API_##N, #n, \
15702 vl_api_##n##_t_handler_uni, \
15704 vl_api_##n##_t_endian, \
15705 vl_api_##n##_t_print, \
15706 sizeof(vl_api_##n##_t), 1);
15707 foreach_vpe_api_reply_msg;
15710 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15712 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15714 vam->function_by_name = hash_create_string (0, sizeof (uword));
15716 vam->help_by_name = hash_create_string (0, sizeof (uword));
15718 /* API messages we can send */
15719 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15720 foreach_vpe_api_msg;
15724 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15725 foreach_vpe_api_msg;
15728 /* CLI functions */
15729 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15730 foreach_cli_function;
15734 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15735 foreach_cli_function;
15739 #undef vl_api_version
15740 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15741 #include <vpp-api/vpe.api.h>
15742 #undef vl_api_version
15745 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15748 * Send the main API signature in slot 0. This bit of code must
15749 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15751 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15755 * fd.io coding-style-patch-verification: ON
15758 * eval: (c-set-style "gnu")