2 *------------------------------------------------------------------
5 * Copyright (c) 2014 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/sr/sr_packet.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp-api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/classify/policer_classify.h>
38 #include <vnet/mpls-gre/mpls.h>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
45 #include <vnet/map/map.h>
46 #include <vnet/cop/cop.h>
47 #include <vnet/ip/ip6_hop_by_hop.h>
48 #include <vnet/ip/ip_source_and_port_range_check.h>
49 #include <vnet/policer/xlate.h>
50 #include <vnet/policer/policer.h>
51 #include <vnet/policer/police.h>
53 #include "vat/json_format.h"
57 #define vl_typedefs /* define message structures */
58 #include <vpp-api/vpe_all_api_h.h>
61 /* declare message handlers for each api */
63 #define vl_endianfun /* define message structures */
64 #include <vpp-api/vpe_all_api_h.h>
67 /* instantiate all the print functions we know about */
68 #define vl_print(handle, ...)
70 #include <vpp-api/vpe_all_api_h.h>
74 unformat_sw_if_index (unformat_input_t * input, va_list * args)
76 vat_main_t *vam = va_arg (*args, vat_main_t *);
77 u32 *result = va_arg (*args, u32 *);
81 if (!unformat (input, "%s", &if_name))
84 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
91 /* Parse an IP4 address %d.%d.%d.%d. */
93 unformat_ip4_address (unformat_input_t * input, va_list * args)
95 u8 *result = va_arg (*args, u8 *);
98 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
101 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
114 unformat_ethernet_address (unformat_input_t * input, va_list * args)
116 u8 *result = va_arg (*args, u8 *);
119 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
120 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
124 for (i = 0; i < 6; i++)
125 if (a[i] >= (1 << 8))
128 for (i = 0; i < 6; i++)
134 /* Returns ethernet type as an int in host byte order. */
136 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
139 u16 *result = va_arg (*args, u16 *);
143 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
145 if (type >= (1 << 16))
153 /* Parse an IP6 address. */
155 unformat_ip6_address (unformat_input_t * input, va_list * args)
157 ip6_address_t *result = va_arg (*args, ip6_address_t *);
159 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
160 uword c, n_colon, double_colon_index;
162 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
163 double_colon_index = ARRAY_LEN (hex_quads);
164 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
167 if (c >= '0' && c <= '9')
169 else if (c >= 'a' && c <= 'f')
170 hex_digit = c + 10 - 'a';
171 else if (c >= 'A' && c <= 'F')
172 hex_digit = c + 10 - 'A';
173 else if (c == ':' && n_colon < 2)
177 unformat_put_input (input);
181 /* Too many hex quads. */
182 if (n_hex_quads >= ARRAY_LEN (hex_quads))
187 hex_quad = (hex_quad << 4) | hex_digit;
189 /* Hex quad must fit in 16 bits. */
190 if (n_hex_digits >= 4)
197 /* Save position of :: */
200 /* More than one :: ? */
201 if (double_colon_index < ARRAY_LEN (hex_quads))
203 double_colon_index = n_hex_quads;
206 if (n_colon > 0 && n_hex_digits > 0)
208 hex_quads[n_hex_quads++] = hex_quad;
214 if (n_hex_digits > 0)
215 hex_quads[n_hex_quads++] = hex_quad;
220 /* Expand :: to appropriate number of zero hex quads. */
221 if (double_colon_index < ARRAY_LEN (hex_quads))
223 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
225 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
226 hex_quads[n_zero + i] = hex_quads[i];
228 for (i = 0; i < n_zero; i++)
229 hex_quads[double_colon_index + i] = 0;
231 n_hex_quads = ARRAY_LEN (hex_quads);
234 /* Too few hex quads given. */
235 if (n_hex_quads < ARRAY_LEN (hex_quads))
238 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
239 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
246 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
249 u32 *r = va_arg (*args, u32 *);
252 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
253 foreach_ipsec_policy_action
264 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
267 u32 *r = va_arg (*args, u32 *);
270 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
271 foreach_ipsec_crypto_alg
282 format_ipsec_crypto_alg (u8 * s, va_list * args)
285 u32 i = va_arg (*args, u32);
290 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
291 foreach_ipsec_crypto_alg
294 return format (s, "unknown");
296 return format (s, "%s", t);
298 return format (s, "Unimplemented");
303 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
306 u32 *r = va_arg (*args, u32 *);
309 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
310 foreach_ipsec_integ_alg
321 format_ipsec_integ_alg (u8 * s, va_list * args)
324 u32 i = va_arg (*args, u32);
329 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
330 foreach_ipsec_integ_alg
333 return format (s, "unknown");
335 return format (s, "%s", t);
337 return format (s, "Unsupported");
342 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
345 u32 *r = va_arg (*args, u32 *);
348 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
349 foreach_ikev2_auth_method
360 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
363 u32 *r = va_arg (*args, u32 *);
366 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
367 foreach_ikev2_id_type
378 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
380 u8 *r = va_arg (*args, u8 *);
382 if (unformat (input, "kbps"))
383 *r = SSE2_QOS_RATE_KBPS;
384 else if (unformat (input, "pps"))
385 *r = SSE2_QOS_RATE_PPS;
392 unformat_policer_round_type (unformat_input_t * input, va_list * args)
394 u8 *r = va_arg (*args, u8 *);
396 if (unformat (input, "closest"))
397 *r = SSE2_QOS_ROUND_TO_CLOSEST;
398 else if (unformat (input, "up"))
399 *r = SSE2_QOS_ROUND_TO_UP;
400 else if (unformat (input, "down"))
401 *r = SSE2_QOS_ROUND_TO_DOWN;
408 unformat_policer_type (unformat_input_t * input, va_list * args)
410 u8 *r = va_arg (*args, u8 *);
412 if (unformat (input, "1r2c"))
413 *r = SSE2_QOS_POLICER_TYPE_1R2C;
414 else if (unformat (input, "1r3c"))
415 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
416 else if (unformat (input, "2r3c-2698"))
417 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
418 else if (unformat (input, "2r3c-4115"))
419 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
420 else if (unformat (input, "2r3c-mef5cf1"))
421 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
428 unformat_dscp (unformat_input_t * input, va_list * va)
430 u8 *r = va_arg (*va, u8 *);
433 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
442 unformat_policer_action_type (unformat_input_t * input, va_list * va)
444 sse2_qos_pol_action_params_st *a
445 = va_arg (*va, sse2_qos_pol_action_params_st *);
447 if (unformat (input, "drop"))
448 a->action_type = SSE2_QOS_ACTION_DROP;
449 else if (unformat (input, "transmit"))
450 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
451 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
452 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
459 unformat_classify_table_type (unformat_input_t * input, va_list * va)
461 u32 *r = va_arg (*va, u32 *);
464 if (unformat (input, "ip4"))
465 tid = POLICER_CLASSIFY_TABLE_IP4;
466 else if (unformat (input, "ip6"))
467 tid = POLICER_CLASSIFY_TABLE_IP6;
468 else if (unformat (input, "l2"))
469 tid = POLICER_CLASSIFY_TABLE_L2;
478 format_ip4_address (u8 * s, va_list * args)
480 u8 *a = va_arg (*args, u8 *);
481 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
485 format_ip6_address (u8 * s, va_list * args)
487 ip6_address_t *a = va_arg (*args, ip6_address_t *);
488 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
490 i_max_n_zero = ARRAY_LEN (a->as_u16);
492 i_first_zero = i_max_n_zero;
494 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
496 u32 is_zero = a->as_u16[i] == 0;
497 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
503 if ((!is_zero && n_zeros > max_n_zeros)
504 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
506 i_max_n_zero = i_first_zero;
507 max_n_zeros = n_zeros;
508 i_first_zero = ARRAY_LEN (a->as_u16);
513 last_double_colon = 0;
514 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
516 if (i == i_max_n_zero && max_n_zeros > 1)
518 s = format (s, "::");
519 i += max_n_zeros - 1;
520 last_double_colon = 1;
524 s = format (s, "%s%x",
525 (last_double_colon || i == 0) ? "" : ":",
526 clib_net_to_host_u16 (a->as_u16[i]));
527 last_double_colon = 0;
534 /* Format an IP46 address. */
536 format_ip46_address (u8 * s, va_list * args)
538 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
539 ip46_type_t type = va_arg (*args, ip46_type_t);
545 is_ip4 = ip46_address_is_ip4 (ip46);
556 format (s, "%U", format_ip4_address, &ip46->ip4) :
557 format (s, "%U", format_ip6_address, &ip46->ip6);
561 format_ethernet_address (u8 * s, va_list * args)
563 u8 *a = va_arg (*args, u8 *);
565 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
566 a[0], a[1], a[2], a[3], a[4], a[5]);
570 increment_v4_address (ip4_address_t * a)
574 v = ntohl (a->as_u32) + 1;
575 a->as_u32 = ntohl (v);
579 increment_v6_address (ip6_address_t * a)
583 v0 = clib_net_to_host_u64 (a->as_u64[0]);
584 v1 = clib_net_to_host_u64 (a->as_u64[1]);
589 a->as_u64[0] = clib_net_to_host_u64 (v0);
590 a->as_u64[1] = clib_net_to_host_u64 (v1);
594 increment_mac_address (u64 * mac)
598 tmp = clib_net_to_host_u64 (tmp);
599 tmp += 1 << 16; /* skip unused (least significant) octets */
600 tmp = clib_host_to_net_u64 (tmp);
604 static void vl_api_create_loopback_reply_t_handler
605 (vl_api_create_loopback_reply_t * mp)
607 vat_main_t *vam = &vat_main;
608 i32 retval = ntohl (mp->retval);
610 vam->retval = retval;
611 vam->regenerate_interface_table = 1;
612 vam->sw_if_index = ntohl (mp->sw_if_index);
613 vam->result_ready = 1;
616 static void vl_api_create_loopback_reply_t_handler_json
617 (vl_api_create_loopback_reply_t * mp)
619 vat_main_t *vam = &vat_main;
620 vat_json_node_t node;
622 vat_json_init_object (&node);
623 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
624 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
626 vat_json_print (vam->ofp, &node);
627 vat_json_free (&node);
628 vam->retval = ntohl (mp->retval);
629 vam->result_ready = 1;
632 static void vl_api_af_packet_create_reply_t_handler
633 (vl_api_af_packet_create_reply_t * mp)
635 vat_main_t *vam = &vat_main;
636 i32 retval = ntohl (mp->retval);
638 vam->retval = retval;
639 vam->regenerate_interface_table = 1;
640 vam->sw_if_index = ntohl (mp->sw_if_index);
641 vam->result_ready = 1;
644 static void vl_api_af_packet_create_reply_t_handler_json
645 (vl_api_af_packet_create_reply_t * mp)
647 vat_main_t *vam = &vat_main;
648 vat_json_node_t node;
650 vat_json_init_object (&node);
651 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
652 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
654 vat_json_print (vam->ofp, &node);
655 vat_json_free (&node);
657 vam->retval = ntohl (mp->retval);
658 vam->result_ready = 1;
661 static void vl_api_create_vlan_subif_reply_t_handler
662 (vl_api_create_vlan_subif_reply_t * mp)
664 vat_main_t *vam = &vat_main;
665 i32 retval = ntohl (mp->retval);
667 vam->retval = retval;
668 vam->regenerate_interface_table = 1;
669 vam->sw_if_index = ntohl (mp->sw_if_index);
670 vam->result_ready = 1;
673 static void vl_api_create_vlan_subif_reply_t_handler_json
674 (vl_api_create_vlan_subif_reply_t * mp)
676 vat_main_t *vam = &vat_main;
677 vat_json_node_t node;
679 vat_json_init_object (&node);
680 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
681 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
683 vat_json_print (vam->ofp, &node);
684 vat_json_free (&node);
686 vam->retval = ntohl (mp->retval);
687 vam->result_ready = 1;
690 static void vl_api_create_subif_reply_t_handler
691 (vl_api_create_subif_reply_t * mp)
693 vat_main_t *vam = &vat_main;
694 i32 retval = ntohl (mp->retval);
696 vam->retval = retval;
697 vam->regenerate_interface_table = 1;
698 vam->sw_if_index = ntohl (mp->sw_if_index);
699 vam->result_ready = 1;
702 static void vl_api_create_subif_reply_t_handler_json
703 (vl_api_create_subif_reply_t * mp)
705 vat_main_t *vam = &vat_main;
706 vat_json_node_t node;
708 vat_json_init_object (&node);
709 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
710 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
712 vat_json_print (vam->ofp, &node);
713 vat_json_free (&node);
715 vam->retval = ntohl (mp->retval);
716 vam->result_ready = 1;
719 static void vl_api_interface_name_renumber_reply_t_handler
720 (vl_api_interface_name_renumber_reply_t * mp)
722 vat_main_t *vam = &vat_main;
723 i32 retval = ntohl (mp->retval);
725 vam->retval = retval;
726 vam->regenerate_interface_table = 1;
727 vam->result_ready = 1;
730 static void vl_api_interface_name_renumber_reply_t_handler_json
731 (vl_api_interface_name_renumber_reply_t * mp)
733 vat_main_t *vam = &vat_main;
734 vat_json_node_t node;
736 vat_json_init_object (&node);
737 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
739 vat_json_print (vam->ofp, &node);
740 vat_json_free (&node);
742 vam->retval = ntohl (mp->retval);
743 vam->result_ready = 1;
747 * Special-case: build the interface table, maintain
748 * the next loopback sw_if_index vbl.
750 static void vl_api_sw_interface_details_t_handler
751 (vl_api_sw_interface_details_t * mp)
753 vat_main_t *vam = &vat_main;
754 u8 *s = format (0, "%s%c", mp->interface_name, 0);
756 hash_set_mem (vam->sw_if_index_by_interface_name, s,
757 ntohl (mp->sw_if_index));
759 /* In sub interface case, fill the sub interface table entry */
760 if (mp->sw_if_index != mp->sup_sw_if_index)
762 sw_interface_subif_t *sub = NULL;
764 vec_add2 (vam->sw_if_subif_table, sub, 1);
766 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
767 strncpy ((char *) sub->interface_name, (char *) s,
768 vec_len (sub->interface_name));
769 sub->sw_if_index = ntohl (mp->sw_if_index);
770 sub->sub_id = ntohl (mp->sub_id);
772 sub->sub_dot1ad = mp->sub_dot1ad;
773 sub->sub_number_of_tags = mp->sub_number_of_tags;
774 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
775 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
776 sub->sub_exact_match = mp->sub_exact_match;
777 sub->sub_default = mp->sub_default;
778 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
779 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
781 /* vlan tag rewrite */
782 sub->vtr_op = ntohl (mp->vtr_op);
783 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
784 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
785 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
789 static void vl_api_sw_interface_details_t_handler_json
790 (vl_api_sw_interface_details_t * mp)
792 vat_main_t *vam = &vat_main;
793 vat_json_node_t *node = NULL;
795 if (VAT_JSON_ARRAY != vam->json_tree.type)
797 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
798 vat_json_init_array (&vam->json_tree);
800 node = vat_json_array_add (&vam->json_tree);
802 vat_json_init_object (node);
803 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
804 vat_json_object_add_uint (node, "sup_sw_if_index",
805 ntohl (mp->sup_sw_if_index));
806 vat_json_object_add_uint (node, "l2_address_length",
807 ntohl (mp->l2_address_length));
808 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
809 sizeof (mp->l2_address));
810 vat_json_object_add_string_copy (node, "interface_name",
812 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
813 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
814 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
815 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
816 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
817 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
818 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
819 vat_json_object_add_uint (node, "sub_number_of_tags",
820 mp->sub_number_of_tags);
821 vat_json_object_add_uint (node, "sub_outer_vlan_id",
822 ntohs (mp->sub_outer_vlan_id));
823 vat_json_object_add_uint (node, "sub_inner_vlan_id",
824 ntohs (mp->sub_inner_vlan_id));
825 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
826 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
827 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
828 mp->sub_outer_vlan_id_any);
829 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
830 mp->sub_inner_vlan_id_any);
831 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
832 vat_json_object_add_uint (node, "vtr_push_dot1q",
833 ntohl (mp->vtr_push_dot1q));
834 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
835 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
838 static void vl_api_sw_interface_set_flags_t_handler
839 (vl_api_sw_interface_set_flags_t * mp)
841 vat_main_t *vam = &vat_main;
842 if (vam->interface_event_display)
843 errmsg ("interface flags: sw_if_index %d %s %s\n",
844 ntohl (mp->sw_if_index),
845 mp->admin_up_down ? "admin-up" : "admin-down",
846 mp->link_up_down ? "link-up" : "link-down");
849 static void vl_api_sw_interface_set_flags_t_handler_json
850 (vl_api_sw_interface_set_flags_t * mp)
852 /* JSON output not supported */
856 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
858 vat_main_t *vam = &vat_main;
859 i32 retval = ntohl (mp->retval);
861 vam->retval = retval;
862 vam->shmem_result = (u8 *) mp->reply_in_shmem;
863 vam->result_ready = 1;
867 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
869 vat_main_t *vam = &vat_main;
870 vat_json_node_t node;
871 api_main_t *am = &api_main;
875 vat_json_init_object (&node);
876 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
877 vat_json_object_add_uint (&node, "reply_in_shmem",
878 ntohl (mp->reply_in_shmem));
879 /* Toss the shared-memory original... */
880 pthread_mutex_lock (&am->vlib_rp->mutex);
881 oldheap = svm_push_data_heap (am->vlib_rp);
883 reply = (u8 *) (mp->reply_in_shmem);
886 svm_pop_heap (oldheap);
887 pthread_mutex_unlock (&am->vlib_rp->mutex);
889 vat_json_print (vam->ofp, &node);
890 vat_json_free (&node);
892 vam->retval = ntohl (mp->retval);
893 vam->result_ready = 1;
896 static void vl_api_classify_add_del_table_reply_t_handler
897 (vl_api_classify_add_del_table_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 i32 retval = ntohl (mp->retval);
903 vam->async_errors += (retval < 0);
907 vam->retval = retval;
909 ((mp->new_table_index != 0xFFFFFFFF) ||
910 (mp->skip_n_vectors != 0xFFFFFFFF) ||
911 (mp->match_n_vectors != 0xFFFFFFFF)))
913 * Note: this is just barely thread-safe, depends on
914 * the main thread spinning waiting for an answer...
916 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
917 ntohl (mp->new_table_index),
918 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
919 vam->result_ready = 1;
923 static void vl_api_classify_add_del_table_reply_t_handler_json
924 (vl_api_classify_add_del_table_reply_t * mp)
926 vat_main_t *vam = &vat_main;
927 vat_json_node_t node;
929 vat_json_init_object (&node);
930 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
931 vat_json_object_add_uint (&node, "new_table_index",
932 ntohl (mp->new_table_index));
933 vat_json_object_add_uint (&node, "skip_n_vectors",
934 ntohl (mp->skip_n_vectors));
935 vat_json_object_add_uint (&node, "match_n_vectors",
936 ntohl (mp->match_n_vectors));
938 vat_json_print (vam->ofp, &node);
939 vat_json_free (&node);
941 vam->retval = ntohl (mp->retval);
942 vam->result_ready = 1;
945 static void vl_api_get_node_index_reply_t_handler
946 (vl_api_get_node_index_reply_t * mp)
948 vat_main_t *vam = &vat_main;
949 i32 retval = ntohl (mp->retval);
952 vam->async_errors += (retval < 0);
956 vam->retval = retval;
958 errmsg ("node index %d\n", ntohl (mp->node_index));
959 vam->result_ready = 1;
963 static void vl_api_get_node_index_reply_t_handler_json
964 (vl_api_get_node_index_reply_t * mp)
966 vat_main_t *vam = &vat_main;
967 vat_json_node_t node;
969 vat_json_init_object (&node);
970 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
971 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
973 vat_json_print (vam->ofp, &node);
974 vat_json_free (&node);
976 vam->retval = ntohl (mp->retval);
977 vam->result_ready = 1;
980 static void vl_api_get_next_index_reply_t_handler
981 (vl_api_get_next_index_reply_t * mp)
983 vat_main_t *vam = &vat_main;
984 i32 retval = ntohl (mp->retval);
987 vam->async_errors += (retval < 0);
991 vam->retval = retval;
993 errmsg ("next node index %d\n", ntohl (mp->next_index));
994 vam->result_ready = 1;
998 static void vl_api_get_next_index_reply_t_handler_json
999 (vl_api_get_next_index_reply_t * mp)
1001 vat_main_t *vam = &vat_main;
1002 vat_json_node_t node;
1004 vat_json_init_object (&node);
1005 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1006 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1008 vat_json_print (vam->ofp, &node);
1009 vat_json_free (&node);
1011 vam->retval = ntohl (mp->retval);
1012 vam->result_ready = 1;
1015 static void vl_api_add_node_next_reply_t_handler
1016 (vl_api_add_node_next_reply_t * mp)
1018 vat_main_t *vam = &vat_main;
1019 i32 retval = ntohl (mp->retval);
1020 if (vam->async_mode)
1022 vam->async_errors += (retval < 0);
1026 vam->retval = retval;
1028 errmsg ("next index %d\n", ntohl (mp->next_index));
1029 vam->result_ready = 1;
1033 static void vl_api_add_node_next_reply_t_handler_json
1034 (vl_api_add_node_next_reply_t * mp)
1036 vat_main_t *vam = &vat_main;
1037 vat_json_node_t node;
1039 vat_json_init_object (&node);
1040 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1041 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1043 vat_json_print (vam->ofp, &node);
1044 vat_json_free (&node);
1046 vam->retval = ntohl (mp->retval);
1047 vam->result_ready = 1;
1050 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
1051 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1053 vat_main_t *vam = &vat_main;
1054 i32 retval = ntohl (mp->retval);
1055 u32 sw_if_index = ntohl (mp->tunnel_sw_if_index);
1057 if (retval >= 0 && sw_if_index != (u32) ~ 0)
1059 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
1061 vam->retval = retval;
1062 vam->result_ready = 1;
1065 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
1066 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
1068 vat_main_t *vam = &vat_main;
1069 vat_json_node_t node;
1071 vat_json_init_object (&node);
1072 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1073 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1074 ntohl (mp->tunnel_sw_if_index));
1076 vat_json_print (vam->ofp, &node);
1077 vat_json_free (&node);
1079 vam->retval = ntohl (mp->retval);
1080 vam->result_ready = 1;
1084 static void vl_api_show_version_reply_t_handler
1085 (vl_api_show_version_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 i32 retval = ntohl (mp->retval);
1092 errmsg (" program: %s\n", mp->program);
1093 errmsg (" version: %s\n", mp->version);
1094 errmsg (" build date: %s\n", mp->build_date);
1095 errmsg ("build directory: %s\n", mp->build_directory);
1097 vam->retval = retval;
1098 vam->result_ready = 1;
1101 static void vl_api_show_version_reply_t_handler_json
1102 (vl_api_show_version_reply_t * mp)
1104 vat_main_t *vam = &vat_main;
1105 vat_json_node_t node;
1107 vat_json_init_object (&node);
1108 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1109 vat_json_object_add_string_copy (&node, "program", mp->program);
1110 vat_json_object_add_string_copy (&node, "version", mp->version);
1111 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1112 vat_json_object_add_string_copy (&node, "build_directory",
1113 mp->build_directory);
1115 vat_json_print (vam->ofp, &node);
1116 vat_json_free (&node);
1118 vam->retval = ntohl (mp->retval);
1119 vam->result_ready = 1;
1123 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1125 vat_main_t *vam = &vat_main;
1126 errmsg ("arp event: address %U new mac %U sw_if_index %d\n",
1127 format_ip4_address, &mp->address,
1128 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1132 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1134 /* JSON output not supported */
1138 * Special-case: build the bridge domain table, maintain
1139 * the next bd id vbl.
1141 static void vl_api_bridge_domain_details_t_handler
1142 (vl_api_bridge_domain_details_t * mp)
1144 vat_main_t *vam = &vat_main;
1145 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1147 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1148 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1150 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1151 ntohl (mp->bd_id), mp->learn, mp->forward,
1152 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1155 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1159 static void vl_api_bridge_domain_details_t_handler_json
1160 (vl_api_bridge_domain_details_t * mp)
1162 vat_main_t *vam = &vat_main;
1163 vat_json_node_t *node, *array = NULL;
1165 if (VAT_JSON_ARRAY != vam->json_tree.type)
1167 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1168 vat_json_init_array (&vam->json_tree);
1170 node = vat_json_array_add (&vam->json_tree);
1172 vat_json_init_object (node);
1173 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1174 vat_json_object_add_uint (node, "flood", mp->flood);
1175 vat_json_object_add_uint (node, "forward", mp->forward);
1176 vat_json_object_add_uint (node, "learn", mp->learn);
1177 vat_json_object_add_uint (node, "bvi_sw_if_index",
1178 ntohl (mp->bvi_sw_if_index));
1179 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1180 array = vat_json_object_add (node, "sw_if");
1181 vat_json_init_array (array);
1185 * Special-case: build the bridge domain sw if table.
1187 static void vl_api_bridge_domain_sw_if_details_t_handler
1188 (vl_api_bridge_domain_sw_if_details_t * mp)
1190 vat_main_t *vam = &vat_main;
1195 sw_if_index = ntohl (mp->sw_if_index);
1197 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1199 if ((u32) p->value[0] == sw_if_index)
1201 sw_if_name = (u8 *)(p->key);
1207 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1208 mp->shg, sw_if_name ? (char *) sw_if_name :
1209 "sw_if_index not found!");
1212 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1213 (vl_api_bridge_domain_sw_if_details_t * mp)
1215 vat_main_t *vam = &vat_main;
1216 vat_json_node_t *node = NULL;
1217 uword last_index = 0;
1219 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1220 ASSERT (vec_len (vam->json_tree.array) >= 1);
1221 last_index = vec_len (vam->json_tree.array) - 1;
1222 node = &vam->json_tree.array[last_index];
1223 node = vat_json_object_get_element (node, "sw_if");
1224 ASSERT (NULL != node);
1225 node = vat_json_array_add (node);
1227 vat_json_init_object (node);
1228 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1229 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1230 vat_json_object_add_uint (node, "shg", mp->shg);
1233 static void vl_api_control_ping_reply_t_handler
1234 (vl_api_control_ping_reply_t * mp)
1236 vat_main_t *vam = &vat_main;
1237 i32 retval = ntohl (mp->retval);
1238 if (vam->async_mode)
1240 vam->async_errors += (retval < 0);
1244 vam->retval = retval;
1245 vam->result_ready = 1;
1249 static void vl_api_control_ping_reply_t_handler_json
1250 (vl_api_control_ping_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1255 if (VAT_JSON_NONE != vam->json_tree.type)
1257 vat_json_print (vam->ofp, &vam->json_tree);
1258 vat_json_free (&vam->json_tree);
1259 vam->json_tree.type = VAT_JSON_NONE;
1264 vat_json_init_array (&vam->json_tree);
1265 vat_json_print (vam->ofp, &vam->json_tree);
1266 vam->json_tree.type = VAT_JSON_NONE;
1269 vam->retval = retval;
1270 vam->result_ready = 1;
1273 static void vl_api_noprint_control_ping_reply_t_handler
1274 (vl_api_noprint_control_ping_reply_t * mp)
1276 vat_main_t *vam = &vat_main;
1277 i32 retval = ntohl (mp->retval);
1278 if (vam->async_mode)
1280 vam->async_errors += (retval < 0);
1284 vam->retval = retval;
1285 vam->result_ready = 1;
1289 static void vl_api_noprint_control_ping_reply_t_handler_json
1290 (vl_api_noprint_control_ping_reply_t * mp)
1292 vat_main_t *vam = &vat_main;
1293 i32 retval = ntohl (mp->retval);
1295 if (vam->noprint_msg)
1297 vam->retval = retval;
1298 vam->result_ready = 1;
1302 if (VAT_JSON_NONE != vam->json_tree.type)
1304 vat_json_print (vam->ofp, &vam->json_tree);
1305 vat_json_free (&vam->json_tree);
1306 vam->json_tree.type = VAT_JSON_NONE;
1311 vat_json_init_array (&vam->json_tree);
1312 vat_json_print (vam->ofp, &vam->json_tree);
1313 vam->json_tree.type = VAT_JSON_NONE;
1316 vam->retval = retval;
1317 vam->result_ready = 1;
1321 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1323 vat_main_t *vam = &vat_main;
1324 i32 retval = ntohl (mp->retval);
1325 if (vam->async_mode)
1327 vam->async_errors += (retval < 0);
1331 vam->retval = retval;
1332 vam->result_ready = 1;
1336 static void vl_api_l2_flags_reply_t_handler_json
1337 (vl_api_l2_flags_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 vat_json_node_t node;
1342 vat_json_init_object (&node);
1343 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1344 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1345 ntohl (mp->resulting_feature_bitmap));
1347 vat_json_print (vam->ofp, &node);
1348 vat_json_free (&node);
1350 vam->retval = ntohl (mp->retval);
1351 vam->result_ready = 1;
1354 static void vl_api_bridge_flags_reply_t_handler
1355 (vl_api_bridge_flags_reply_t * mp)
1357 vat_main_t *vam = &vat_main;
1358 i32 retval = ntohl (mp->retval);
1359 if (vam->async_mode)
1361 vam->async_errors += (retval < 0);
1365 vam->retval = retval;
1366 vam->result_ready = 1;
1370 static void vl_api_bridge_flags_reply_t_handler_json
1371 (vl_api_bridge_flags_reply_t * mp)
1373 vat_main_t *vam = &vat_main;
1374 vat_json_node_t node;
1376 vat_json_init_object (&node);
1377 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1378 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1379 ntohl (mp->resulting_feature_bitmap));
1381 vat_json_print (vam->ofp, &node);
1382 vat_json_free (&node);
1384 vam->retval = ntohl (mp->retval);
1385 vam->result_ready = 1;
1388 static void vl_api_tap_connect_reply_t_handler
1389 (vl_api_tap_connect_reply_t * mp)
1391 vat_main_t *vam = &vat_main;
1392 i32 retval = ntohl (mp->retval);
1393 if (vam->async_mode)
1395 vam->async_errors += (retval < 0);
1399 vam->retval = retval;
1400 vam->sw_if_index = ntohl (mp->sw_if_index);
1401 vam->result_ready = 1;
1406 static void vl_api_tap_connect_reply_t_handler_json
1407 (vl_api_tap_connect_reply_t * mp)
1409 vat_main_t *vam = &vat_main;
1410 vat_json_node_t node;
1412 vat_json_init_object (&node);
1413 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1414 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1416 vat_json_print (vam->ofp, &node);
1417 vat_json_free (&node);
1419 vam->retval = ntohl (mp->retval);
1420 vam->result_ready = 1;
1425 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1427 vat_main_t *vam = &vat_main;
1428 i32 retval = ntohl (mp->retval);
1429 if (vam->async_mode)
1431 vam->async_errors += (retval < 0);
1435 vam->retval = retval;
1436 vam->sw_if_index = ntohl (mp->sw_if_index);
1437 vam->result_ready = 1;
1441 static void vl_api_tap_modify_reply_t_handler_json
1442 (vl_api_tap_modify_reply_t * mp)
1444 vat_main_t *vam = &vat_main;
1445 vat_json_node_t node;
1447 vat_json_init_object (&node);
1448 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1449 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1451 vat_json_print (vam->ofp, &node);
1452 vat_json_free (&node);
1454 vam->retval = ntohl (mp->retval);
1455 vam->result_ready = 1;
1459 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1461 vat_main_t *vam = &vat_main;
1462 i32 retval = ntohl (mp->retval);
1463 if (vam->async_mode)
1465 vam->async_errors += (retval < 0);
1469 vam->retval = retval;
1470 vam->result_ready = 1;
1474 static void vl_api_tap_delete_reply_t_handler_json
1475 (vl_api_tap_delete_reply_t * mp)
1477 vat_main_t *vam = &vat_main;
1478 vat_json_node_t node;
1480 vat_json_init_object (&node);
1481 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1483 vat_json_print (vam->ofp, &node);
1484 vat_json_free (&node);
1486 vam->retval = ntohl (mp->retval);
1487 vam->result_ready = 1;
1490 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1491 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1493 vat_main_t *vam = &vat_main;
1494 i32 retval = ntohl (mp->retval);
1495 if (vam->async_mode)
1497 vam->async_errors += (retval < 0);
1501 vam->retval = retval;
1502 vam->result_ready = 1;
1506 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1507 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1509 vat_main_t *vam = &vat_main;
1510 vat_json_node_t node;
1512 vat_json_init_object (&node);
1513 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1514 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1515 ntohl (mp->tunnel_sw_if_index));
1517 vat_json_print (vam->ofp, &node);
1518 vat_json_free (&node);
1520 vam->retval = ntohl (mp->retval);
1521 vam->result_ready = 1;
1524 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1525 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1527 vat_main_t *vam = &vat_main;
1528 i32 retval = ntohl (mp->retval);
1529 if (vam->async_mode)
1531 vam->async_errors += (retval < 0);
1535 vam->retval = retval;
1536 vam->sw_if_index = ntohl (mp->sw_if_index);
1537 vam->result_ready = 1;
1541 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1542 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1544 vat_main_t *vam = &vat_main;
1545 vat_json_node_t node;
1547 vat_json_init_object (&node);
1548 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1549 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1551 vat_json_print (vam->ofp, &node);
1552 vat_json_free (&node);
1554 vam->retval = ntohl (mp->retval);
1555 vam->result_ready = 1;
1558 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1559 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1561 vat_main_t *vam = &vat_main;
1562 i32 retval = ntohl (mp->retval);
1563 if (vam->async_mode)
1565 vam->async_errors += (retval < 0);
1569 vam->retval = retval;
1570 vam->sw_if_index = ntohl (mp->sw_if_index);
1571 vam->result_ready = 1;
1575 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1576 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1578 vat_main_t *vam = &vat_main;
1579 vat_json_node_t node;
1581 vat_json_init_object (&node);
1582 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1583 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1585 vat_json_print (vam->ofp, &node);
1586 vat_json_free (&node);
1588 vam->retval = ntohl (mp->retval);
1589 vam->result_ready = 1;
1592 static void vl_api_gre_add_del_tunnel_reply_t_handler
1593 (vl_api_gre_add_del_tunnel_reply_t * mp)
1595 vat_main_t *vam = &vat_main;
1596 i32 retval = ntohl (mp->retval);
1597 if (vam->async_mode)
1599 vam->async_errors += (retval < 0);
1603 vam->retval = retval;
1604 vam->sw_if_index = ntohl (mp->sw_if_index);
1605 vam->result_ready = 1;
1609 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1610 (vl_api_gre_add_del_tunnel_reply_t * mp)
1612 vat_main_t *vam = &vat_main;
1613 vat_json_node_t node;
1615 vat_json_init_object (&node);
1616 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1617 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1619 vat_json_print (vam->ofp, &node);
1620 vat_json_free (&node);
1622 vam->retval = ntohl (mp->retval);
1623 vam->result_ready = 1;
1626 static void vl_api_create_vhost_user_if_reply_t_handler
1627 (vl_api_create_vhost_user_if_reply_t * mp)
1629 vat_main_t *vam = &vat_main;
1630 i32 retval = ntohl (mp->retval);
1631 if (vam->async_mode)
1633 vam->async_errors += (retval < 0);
1637 vam->retval = retval;
1638 vam->sw_if_index = ntohl (mp->sw_if_index);
1639 vam->result_ready = 1;
1643 static void vl_api_create_vhost_user_if_reply_t_handler_json
1644 (vl_api_create_vhost_user_if_reply_t * mp)
1646 vat_main_t *vam = &vat_main;
1647 vat_json_node_t node;
1649 vat_json_init_object (&node);
1650 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1651 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1653 vat_json_print (vam->ofp, &node);
1654 vat_json_free (&node);
1656 vam->retval = ntohl (mp->retval);
1657 vam->result_ready = 1;
1660 static void vl_api_ip_address_details_t_handler
1661 (vl_api_ip_address_details_t * mp)
1663 vat_main_t *vam = &vat_main;
1664 static ip_address_details_t empty_ip_address_details = { {0} };
1665 ip_address_details_t *address = NULL;
1666 ip_details_t *current_ip_details = NULL;
1667 ip_details_t *details = NULL;
1669 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1671 if (!details || vam->current_sw_if_index >= vec_len (details)
1672 || !details[vam->current_sw_if_index].present)
1674 errmsg ("ip address details arrived but not stored\n");
1675 errmsg ("ip_dump should be called first\n");
1679 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1681 #define addresses (current_ip_details->addr)
1683 vec_validate_init_empty (addresses, vec_len (addresses),
1684 empty_ip_address_details);
1686 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1688 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1689 address->prefix_length = mp->prefix_length;
1693 static void vl_api_ip_address_details_t_handler_json
1694 (vl_api_ip_address_details_t * mp)
1696 vat_main_t *vam = &vat_main;
1697 vat_json_node_t *node = NULL;
1698 struct in6_addr ip6;
1701 if (VAT_JSON_ARRAY != vam->json_tree.type)
1703 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1704 vat_json_init_array (&vam->json_tree);
1706 node = vat_json_array_add (&vam->json_tree);
1708 vat_json_init_object (node);
1711 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1712 vat_json_object_add_ip6 (node, "ip", ip6);
1716 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1717 vat_json_object_add_ip4 (node, "ip", ip4);
1719 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1723 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1725 vat_main_t *vam = &vat_main;
1726 static ip_details_t empty_ip_details = { 0 };
1727 ip_details_t *ip = NULL;
1728 u32 sw_if_index = ~0;
1730 sw_if_index = ntohl (mp->sw_if_index);
1732 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1733 sw_if_index, empty_ip_details);
1735 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1742 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1744 vat_main_t *vam = &vat_main;
1746 if (VAT_JSON_ARRAY != vam->json_tree.type)
1748 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1749 vat_json_init_array (&vam->json_tree);
1751 vat_json_array_add_uint (&vam->json_tree,
1752 clib_net_to_host_u32 (mp->sw_if_index));
1755 static void vl_api_map_domain_details_t_handler_json
1756 (vl_api_map_domain_details_t * mp)
1758 vat_json_node_t *node = NULL;
1759 vat_main_t *vam = &vat_main;
1760 struct in6_addr ip6;
1763 if (VAT_JSON_ARRAY != vam->json_tree.type)
1765 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1766 vat_json_init_array (&vam->json_tree);
1769 node = vat_json_array_add (&vam->json_tree);
1770 vat_json_init_object (node);
1772 vat_json_object_add_uint (node, "domain_index",
1773 clib_net_to_host_u32 (mp->domain_index));
1774 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1775 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1776 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1777 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1778 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1779 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1780 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1781 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1782 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1783 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1784 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1785 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1786 vat_json_object_add_uint (node, "flags", mp->flags);
1787 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1788 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1791 static void vl_api_map_domain_details_t_handler
1792 (vl_api_map_domain_details_t * mp)
1794 vat_main_t *vam = &vat_main;
1796 if (mp->is_translation)
1799 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1800 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1801 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1802 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1803 clib_net_to_host_u32 (mp->domain_index));
1808 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1809 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1810 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1811 format_ip6_address, mp->ip6_src,
1812 clib_net_to_host_u32 (mp->domain_index));
1814 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1815 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1816 mp->is_translation ? "map-t" : "");
1819 static void vl_api_map_rule_details_t_handler_json
1820 (vl_api_map_rule_details_t * mp)
1822 struct in6_addr ip6;
1823 vat_json_node_t *node = NULL;
1824 vat_main_t *vam = &vat_main;
1826 if (VAT_JSON_ARRAY != vam->json_tree.type)
1828 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1829 vat_json_init_array (&vam->json_tree);
1832 node = vat_json_array_add (&vam->json_tree);
1833 vat_json_init_object (node);
1835 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1836 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1837 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1841 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1843 vat_main_t *vam = &vat_main;
1844 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1845 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1849 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1851 vat_main_t *vam = &vat_main;
1852 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1853 "router_addr %U host_mac %U\n",
1854 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1855 format_ip4_address, &mp->host_address,
1856 format_ip4_address, &mp->router_address,
1857 format_ethernet_address, mp->host_mac);
1860 static void vl_api_dhcp_compl_event_t_handler_json
1861 (vl_api_dhcp_compl_event_t * mp)
1863 /* JSON output not supported */
1867 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1870 vat_main_t *vam = &vat_main;
1871 static u64 default_counter = 0;
1873 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1875 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1876 sw_if_index, default_counter);
1877 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1881 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1882 interface_counter_t counter)
1884 vat_main_t *vam = &vat_main;
1885 static interface_counter_t default_counter = { 0, };
1887 vec_validate_init_empty (vam->combined_interface_counters,
1888 vnet_counter_type, NULL);
1889 vec_validate_init_empty (vam->combined_interface_counters
1890 [vnet_counter_type], sw_if_index, default_counter);
1891 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1894 static void vl_api_vnet_interface_counters_t_handler
1895 (vl_api_vnet_interface_counters_t * mp)
1900 static void vl_api_vnet_interface_counters_t_handler_json
1901 (vl_api_vnet_interface_counters_t * mp)
1903 interface_counter_t counter;
1908 u32 first_sw_if_index;
1911 count = ntohl (mp->count);
1912 first_sw_if_index = ntohl (mp->first_sw_if_index);
1914 if (!mp->is_combined)
1916 v_packets = (u64 *) & mp->data;
1917 for (i = 0; i < count; i++)
1920 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1921 set_simple_interface_counter (mp->vnet_counter_type,
1922 first_sw_if_index + i, packets);
1928 v = (vlib_counter_t *) & mp->data;
1929 for (i = 0; i < count; i++)
1932 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1934 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1935 set_combined_interface_counter (mp->vnet_counter_type,
1936 first_sw_if_index + i, counter);
1943 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1945 vat_main_t *vam = &vat_main;
1948 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1950 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1959 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1961 vat_main_t *vam = &vat_main;
1964 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1966 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
1974 static void vl_api_vnet_ip4_fib_counters_t_handler
1975 (vl_api_vnet_ip4_fib_counters_t * mp)
1980 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1981 (vl_api_vnet_ip4_fib_counters_t * mp)
1983 vat_main_t *vam = &vat_main;
1984 vl_api_ip4_fib_counter_t *v;
1985 ip4_fib_counter_t *counter;
1992 vrf_id = ntohl (mp->vrf_id);
1993 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
1994 if (~0 == vrf_index)
1996 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
1997 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
1998 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1999 vec_validate (vam->ip4_fib_counters, vrf_index);
2000 vam->ip4_fib_counters[vrf_index] = NULL;
2003 vec_free (vam->ip4_fib_counters[vrf_index]);
2004 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2005 count = ntohl (mp->count);
2006 for (i = 0; i < count; i++)
2008 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2009 counter = &vam->ip4_fib_counters[vrf_index][i];
2010 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2011 counter->address = ip4;
2012 counter->address_length = v->address_length;
2013 counter->packets = clib_net_to_host_u64 (v->packets);
2014 counter->bytes = clib_net_to_host_u64 (v->bytes);
2019 static void vl_api_vnet_ip6_fib_counters_t_handler
2020 (vl_api_vnet_ip6_fib_counters_t * mp)
2025 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2026 (vl_api_vnet_ip6_fib_counters_t * mp)
2028 vat_main_t *vam = &vat_main;
2029 vl_api_ip6_fib_counter_t *v;
2030 ip6_fib_counter_t *counter;
2031 struct in6_addr ip6;
2037 vrf_id = ntohl (mp->vrf_id);
2038 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2039 if (~0 == vrf_index)
2041 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2042 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2043 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2044 vec_validate (vam->ip6_fib_counters, vrf_index);
2045 vam->ip6_fib_counters[vrf_index] = NULL;
2048 vec_free (vam->ip6_fib_counters[vrf_index]);
2049 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2050 count = ntohl (mp->count);
2051 for (i = 0; i < count; i++)
2053 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2054 counter = &vam->ip6_fib_counters[vrf_index][i];
2055 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2056 counter->address = ip6;
2057 counter->address_length = v->address_length;
2058 counter->packets = clib_net_to_host_u64 (v->packets);
2059 counter->bytes = clib_net_to_host_u64 (v->bytes);
2064 static void vl_api_get_first_msg_id_reply_t_handler
2065 (vl_api_get_first_msg_id_reply_t * mp)
2067 vat_main_t *vam = &vat_main;
2068 i32 retval = ntohl (mp->retval);
2070 if (vam->async_mode)
2072 vam->async_errors += (retval < 0);
2076 vam->retval = retval;
2077 vam->result_ready = 1;
2081 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2085 static void vl_api_get_first_msg_id_reply_t_handler_json
2086 (vl_api_get_first_msg_id_reply_t * mp)
2088 vat_main_t *vam = &vat_main;
2089 vat_json_node_t node;
2091 vat_json_init_object (&node);
2092 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2093 vat_json_object_add_uint (&node, "first_msg_id",
2094 (uint) ntohs (mp->first_msg_id));
2096 vat_json_print (vam->ofp, &node);
2097 vat_json_free (&node);
2099 vam->retval = ntohl (mp->retval);
2100 vam->result_ready = 1;
2103 static void vl_api_get_node_graph_reply_t_handler
2104 (vl_api_get_node_graph_reply_t * mp)
2106 vat_main_t *vam = &vat_main;
2107 api_main_t *am = &api_main;
2108 i32 retval = ntohl (mp->retval);
2109 u8 *pvt_copy, *reply;
2114 if (vam->async_mode)
2116 vam->async_errors += (retval < 0);
2120 vam->retval = retval;
2121 vam->result_ready = 1;
2124 /* "Should never happen..." */
2128 reply = (u8 *) (mp->reply_in_shmem);
2129 pvt_copy = vec_dup (reply);
2131 /* Toss the shared-memory original... */
2132 pthread_mutex_lock (&am->vlib_rp->mutex);
2133 oldheap = svm_push_data_heap (am->vlib_rp);
2137 svm_pop_heap (oldheap);
2138 pthread_mutex_unlock (&am->vlib_rp->mutex);
2140 if (vam->graph_nodes)
2142 hash_free (vam->graph_node_index_by_name);
2144 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2146 node = vam->graph_nodes[i];
2147 vec_free (node->name);
2148 vec_free (node->next_nodes);
2151 vec_free (vam->graph_nodes);
2154 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2155 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2156 vec_free (pvt_copy);
2158 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2160 node = vam->graph_nodes[i];
2161 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2165 static void vl_api_get_node_graph_reply_t_handler_json
2166 (vl_api_get_node_graph_reply_t * mp)
2168 vat_main_t *vam = &vat_main;
2169 api_main_t *am = &api_main;
2171 vat_json_node_t node;
2174 /* $$$$ make this real? */
2175 vat_json_init_object (&node);
2176 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2177 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2179 reply = (u8 *) (mp->reply_in_shmem);
2181 /* Toss the shared-memory original... */
2182 pthread_mutex_lock (&am->vlib_rp->mutex);
2183 oldheap = svm_push_data_heap (am->vlib_rp);
2187 svm_pop_heap (oldheap);
2188 pthread_mutex_unlock (&am->vlib_rp->mutex);
2190 vat_json_print (vam->ofp, &node);
2191 vat_json_free (&node);
2193 vam->retval = ntohl (mp->retval);
2194 vam->result_ready = 1;
2198 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2200 vat_main_t *vam = &vat_main;
2204 memset (&loc, 0, sizeof (loc));
2205 if (vam->noprint_msg)
2207 loc.local = mp->local;
2208 loc.priority = mp->priority;
2209 loc.weight = mp->weight;
2212 loc.sw_if_index = ntohl (mp->sw_if_index);
2216 loc.is_ipv6 = mp->is_ipv6;
2217 clib_memcpy (loc.ip_address, mp->ip_address,
2218 sizeof (loc.ip_address));
2220 vec_add1 (vam->locator_msg, loc);
2226 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
2227 ntohl (mp->sw_if_index),
2228 mp->priority, mp->weight);
2232 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
2233 mp->is_ipv6 ? format_ip6_address :
2235 mp->ip_address, mp->priority, mp->weight);
2238 fformat (vam->ofp, "%s", tmp_str);
2245 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2248 vat_main_t *vam = &vat_main;
2249 vat_json_node_t *node = NULL;
2251 struct in6_addr ip6;
2254 memset (&loc, 0, sizeof (loc));
2255 if (vam->noprint_msg)
2257 loc.local = mp->local;
2258 loc.priority = mp->priority;
2259 loc.weight = mp->weight;
2262 loc.sw_if_index = ntohl (mp->sw_if_index);
2266 loc.is_ipv6 = mp->is_ipv6;
2267 clib_memcpy (loc.ip_address, mp->ip_address,
2268 sizeof (loc.ip_address));
2270 vec_add1 (vam->locator_msg, loc);
2274 if (VAT_JSON_ARRAY != vam->json_tree.type)
2276 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2277 vat_json_init_array (&vam->json_tree);
2279 node = vat_json_array_add (&vam->json_tree);
2281 vat_json_init_object (node);
2285 vat_json_object_add_uint (node, "locator_index",
2286 ntohl (mp->sw_if_index));
2292 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2293 vat_json_object_add_ip6 (node, "locator", ip6);
2297 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2298 vat_json_object_add_ip4 (node, "locator", ip4);
2301 vat_json_object_add_uint (node, "priority", mp->priority);
2302 vat_json_object_add_uint (node, "weight", mp->weight);
2306 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2309 vat_main_t *vam = &vat_main;
2310 locator_set_msg_t ls;
2312 ls.locator_set_index = ntohl (mp->locator_set_index);
2313 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2314 vec_add1 (vam->locator_set_msg, ls);
2318 vl_api_lisp_locator_set_details_t_handler_json
2319 (vl_api_lisp_locator_set_details_t * mp)
2321 vat_main_t *vam = &vat_main;
2322 locator_set_msg_t ls;
2324 ls.locator_set_index = ntohl (mp->locator_set_index);
2325 ls.locator_set_name = format (0, "%s", mp->locator_set_name);
2326 vec_add1 (vam->locator_set_msg, ls);
2330 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2332 vat_main_t *vam = &vat_main;
2333 eid_table_t eid_table;
2335 memset (&eid_table, 0, sizeof (eid_table));
2336 eid_table.is_local = mp->is_local;
2337 eid_table.locator_set_index = mp->locator_set_index;
2338 eid_table.eid_type = mp->eid_type;
2339 eid_table.vni = mp->vni;
2340 eid_table.eid_prefix_len = mp->eid_prefix_len;
2341 eid_table.ttl = mp->ttl;
2342 eid_table.authoritative = mp->authoritative;
2343 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2344 vec_add1 (vam->eid_tables, eid_table);
2348 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2351 vat_main_t *vam = &vat_main;
2352 eid_table_t eid_table;
2354 memset (&eid_table, 0, sizeof (eid_table));
2355 eid_table.is_local = mp->is_local;
2356 eid_table.locator_set_index = mp->locator_set_index;
2357 eid_table.eid_type = mp->eid_type;
2358 eid_table.vni = mp->vni;
2359 eid_table.eid_prefix_len = mp->eid_prefix_len;
2360 eid_table.ttl = mp->ttl;
2361 eid_table.authoritative = mp->authoritative;
2362 clib_memcpy (eid_table.eid, mp->eid, sizeof (eid_table.eid));
2363 vec_add1 (vam->eid_tables, eid_table);
2367 vl_api_lisp_eid_table_map_details_t_handler
2368 (vl_api_lisp_eid_table_map_details_t * mp)
2370 vat_main_t *vam = &vat_main;
2372 u8 *line = format (0, "%=10d%=10d",
2373 clib_net_to_host_u32 (mp->vni),
2374 clib_net_to_host_u32 (mp->vrf));
2375 fformat (vam->ofp, "%v\n", line);
2380 vl_api_lisp_eid_table_map_details_t_handler_json
2381 (vl_api_lisp_eid_table_map_details_t * mp)
2383 vat_main_t *vam = &vat_main;
2384 vat_json_node_t *node = NULL;
2386 if (VAT_JSON_ARRAY != vam->json_tree.type)
2388 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2389 vat_json_init_array (&vam->json_tree);
2391 node = vat_json_array_add (&vam->json_tree);
2392 vat_json_init_object (node);
2393 vat_json_object_add_uint (node, "vrf", clib_net_to_host_u32 (mp->vrf));
2394 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2400 format_decap_next (u8 * s, va_list * args)
2402 u32 next_index = va_arg (*args, u32);
2406 case LISP_GPE_INPUT_NEXT_DROP:
2407 return format (s, "drop");
2408 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2409 return format (s, "ip4");
2410 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2411 return format (s, "ip6");
2413 return format (s, "unknown %d", next_index);
2419 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2422 vat_main_t *vam = &vat_main;
2424 u8 *flag_str = NULL;
2426 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2428 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2429 foreach_lisp_gpe_flag_bit;
2432 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2433 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2435 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2437 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2439 ntohl (mp->encap_fib_id),
2440 ntohl (mp->decap_fib_id),
2441 format_decap_next, ntohl (mp->dcap_next),
2443 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2449 vl_api_lisp_gpe_tunnel_details_t_handler_json
2450 (vl_api_lisp_gpe_tunnel_details_t * mp)
2452 vat_main_t *vam = &vat_main;
2453 vat_json_node_t *node = NULL;
2454 struct in6_addr ip6;
2458 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2460 if (VAT_JSON_ARRAY != vam->json_tree.type)
2462 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2463 vat_json_init_array (&vam->json_tree);
2465 node = vat_json_array_add (&vam->json_tree);
2467 vat_json_init_object (node);
2468 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2471 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2472 vat_json_object_add_ip6 (node, "source address", ip6);
2473 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2474 vat_json_object_add_ip6 (node, "destination address", ip6);
2478 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2479 vat_json_object_add_ip4 (node, "source address", ip4);
2480 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2481 vat_json_object_add_ip4 (node, "destination address", ip4);
2483 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2484 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2485 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2486 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2487 vat_json_object_add_uint (node, "flags", mp->flags);
2488 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2489 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2490 vat_json_object_add_uint (node, "res", mp->res);
2491 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2493 vec_free (next_decap_str);
2497 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2500 vat_main_t *vam = &vat_main;
2502 fformat (vam->ofp, "%=20U\n",
2503 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2508 vl_api_lisp_map_resolver_details_t_handler_json
2509 (vl_api_lisp_map_resolver_details_t * mp)
2511 vat_main_t *vam = &vat_main;
2512 vat_json_node_t *node = NULL;
2513 struct in6_addr ip6;
2516 if (VAT_JSON_ARRAY != vam->json_tree.type)
2518 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2519 vat_json_init_array (&vam->json_tree);
2521 node = vat_json_array_add (&vam->json_tree);
2523 vat_json_init_object (node);
2526 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2527 vat_json_object_add_ip6 (node, "map resolver", ip6);
2531 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2532 vat_json_object_add_ip4 (node, "map resolver", ip4);
2537 vl_api_show_lisp_status_reply_t_handler
2538 (vl_api_show_lisp_status_reply_t * mp)
2540 vat_main_t *vam = &vat_main;
2541 i32 retval = ntohl (mp->retval);
2545 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2546 mp->feature_status ? "enabled" : "disabled",
2547 mp->gpe_status ? "enabled" : "disabled");
2550 vam->retval = retval;
2551 vam->result_ready = 1;
2555 vl_api_show_lisp_status_reply_t_handler_json
2556 (vl_api_show_lisp_status_reply_t * mp)
2558 vat_main_t *vam = &vat_main;
2559 vat_json_node_t node;
2560 u8 *gpe_status = NULL;
2561 u8 *feature_status = NULL;
2563 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2564 feature_status = format (0, "%s",
2565 mp->feature_status ? "enabled" : "disabled");
2566 vec_add1 (gpe_status, 0);
2567 vec_add1 (feature_status, 0);
2569 vat_json_init_object (&node);
2570 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2571 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2573 vec_free (gpe_status);
2574 vec_free (feature_status);
2576 vat_json_print (vam->ofp, &node);
2577 vat_json_free (&node);
2579 vam->retval = ntohl (mp->retval);
2580 vam->result_ready = 1;
2584 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2585 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2587 vat_main_t *vam = &vat_main;
2588 i32 retval = ntohl (mp->retval);
2592 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2595 vam->retval = retval;
2596 vam->result_ready = 1;
2600 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2601 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2603 vat_main_t *vam = &vat_main;
2604 vat_json_node_t *node = NULL;
2606 if (VAT_JSON_ARRAY != vam->json_tree.type)
2608 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2609 vat_json_init_array (&vam->json_tree);
2611 node = vat_json_array_add (&vam->json_tree);
2613 vat_json_init_object (node);
2614 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2616 vat_json_print (vam->ofp, node);
2617 vat_json_free (node);
2619 vam->retval = ntohl (mp->retval);
2620 vam->result_ready = 1;
2624 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2626 vat_main_t *vam = &vat_main;
2627 i32 retval = ntohl (mp->retval);
2631 fformat (vam->ofp, "%-20s%-16s\n",
2632 mp->status ? "enabled" : "disabled",
2633 mp->status ? (char *) mp->locator_set_name : "");
2636 vam->retval = retval;
2637 vam->result_ready = 1;
2641 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2644 vat_main_t *vam = &vat_main;
2645 vat_json_node_t node;
2648 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2649 vec_add1 (status, 0);
2651 vat_json_init_object (&node);
2652 vat_json_object_add_string_copy (&node, "status", status);
2655 vat_json_object_add_string_copy (&node, "locator_set",
2656 mp->locator_set_name);
2661 vat_json_print (vam->ofp, &node);
2662 vat_json_free (&node);
2664 vam->retval = ntohl (mp->retval);
2665 vam->result_ready = 1;
2669 format_policer_type (u8 * s, va_list * va)
2671 u32 i = va_arg (*va, u32);
2673 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2674 s = format (s, "1r2c");
2675 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2676 s = format (s, "1r3c");
2677 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2678 s = format (s, "2r3c-2698");
2679 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2680 s = format (s, "2r3c-4115");
2681 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2682 s = format (s, "2r3c-mef5cf1");
2684 s = format (s, "ILLEGAL");
2689 format_policer_rate_type (u8 * s, va_list * va)
2691 u32 i = va_arg (*va, u32);
2693 if (i == SSE2_QOS_RATE_KBPS)
2694 s = format (s, "kbps");
2695 else if (i == SSE2_QOS_RATE_PPS)
2696 s = format (s, "pps");
2698 s = format (s, "ILLEGAL");
2703 format_policer_round_type (u8 * s, va_list * va)
2705 u32 i = va_arg (*va, u32);
2707 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2708 s = format (s, "closest");
2709 else if (i == SSE2_QOS_ROUND_TO_UP)
2710 s = format (s, "up");
2711 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2712 s = format (s, "down");
2714 s = format (s, "ILLEGAL");
2719 format_policer_action_type (u8 * s, va_list * va)
2721 u32 i = va_arg (*va, u32);
2723 if (i == SSE2_QOS_ACTION_DROP)
2724 s = format (s, "drop");
2725 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2726 s = format (s, "transmit");
2727 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2728 s = format (s, "mark-and-transmit");
2730 s = format (s, "ILLEGAL");
2735 format_dscp (u8 * s, va_list * va)
2737 u32 i = va_arg (*va, u32);
2742 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2746 return format (s, "ILLEGAL");
2748 s = format (s, "%s", t);
2753 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2755 vat_main_t *vam = &vat_main;
2756 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2758 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2759 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2761 conform_dscp_str = format (0, "");
2763 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2764 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2766 exceed_dscp_str = format (0, "");
2768 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2769 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2771 violate_dscp_str = format (0, "");
2773 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2774 "rate type %U, round type %U, %s rate, %s color-aware, "
2775 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2776 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2777 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2779 format_policer_type, mp->type,
2782 clib_net_to_host_u64 (mp->cb),
2783 clib_net_to_host_u64 (mp->eb),
2784 format_policer_rate_type, mp->rate_type,
2785 format_policer_round_type, mp->round_type,
2786 mp->single_rate ? "single" : "dual",
2787 mp->color_aware ? "is" : "not",
2788 ntohl (mp->cir_tokens_per_period),
2789 ntohl (mp->pir_tokens_per_period),
2791 ntohl (mp->current_limit),
2792 ntohl (mp->current_bucket),
2793 ntohl (mp->extended_limit),
2794 ntohl (mp->extended_bucket),
2795 clib_net_to_host_u64 (mp->last_update_time),
2796 format_policer_action_type, mp->conform_action_type,
2798 format_policer_action_type, mp->exceed_action_type,
2800 format_policer_action_type, mp->violate_action_type,
2803 vec_free (conform_dscp_str);
2804 vec_free (exceed_dscp_str);
2805 vec_free (violate_dscp_str);
2808 static void vl_api_policer_details_t_handler_json
2809 (vl_api_policer_details_t * mp)
2811 vat_main_t *vam = &vat_main;
2812 vat_json_node_t *node;
2813 u8 *rate_type_str, *round_type_str, *type_str;
2814 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
2816 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
2818 format (0, "%U", format_policer_round_type, mp->round_type);
2819 type_str = format (0, "%U", format_policer_type, mp->type);
2820 conform_action_str = format (0, "%U", format_policer_action_type,
2821 mp->conform_action_type);
2822 exceed_action_str = format (0, "%U", format_policer_action_type,
2823 mp->exceed_action_type);
2824 violate_action_str = format (0, "%U", format_policer_action_type,
2825 mp->violate_action_type);
2827 if (VAT_JSON_ARRAY != vam->json_tree.type)
2829 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2830 vat_json_init_array (&vam->json_tree);
2832 node = vat_json_array_add (&vam->json_tree);
2834 vat_json_init_object (node);
2835 vat_json_object_add_string_copy (node, "name", mp->name);
2836 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
2837 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
2838 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
2839 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
2840 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
2841 vat_json_object_add_string_copy (node, "round_type", round_type_str);
2842 vat_json_object_add_string_copy (node, "type", type_str);
2843 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
2844 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
2845 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
2846 vat_json_object_add_uint (node, "cir_tokens_per_period",
2847 ntohl (mp->cir_tokens_per_period));
2848 vat_json_object_add_uint (node, "eir_tokens_per_period",
2849 ntohl (mp->pir_tokens_per_period));
2850 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
2851 vat_json_object_add_uint (node, "current_bucket",
2852 ntohl (mp->current_bucket));
2853 vat_json_object_add_uint (node, "extended_limit",
2854 ntohl (mp->extended_limit));
2855 vat_json_object_add_uint (node, "extended_bucket",
2856 ntohl (mp->extended_bucket));
2857 vat_json_object_add_uint (node, "last_update_time",
2858 ntohl (mp->last_update_time));
2859 vat_json_object_add_string_copy (node, "conform_action",
2860 conform_action_str);
2861 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2863 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2864 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
2865 vec_free (dscp_str);
2867 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
2868 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2870 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2871 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
2872 vec_free (dscp_str);
2874 vat_json_object_add_string_copy (node, "violate_action",
2875 violate_action_str);
2876 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2878 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2879 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
2880 vec_free (dscp_str);
2883 vec_free (rate_type_str);
2884 vec_free (round_type_str);
2885 vec_free (type_str);
2886 vec_free (conform_action_str);
2887 vec_free (exceed_action_str);
2888 vec_free (violate_action_str);
2892 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
2895 vat_main_t *vam = &vat_main;
2896 int i, count = ntohl (mp->count);
2899 fformat (vam->ofp, "classify table ids (%d) : ", count);
2900 for (i = 0; i < count; i++)
2902 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
2903 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
2905 vam->retval = ntohl (mp->retval);
2906 vam->result_ready = 1;
2910 vl_api_classify_table_ids_reply_t_handler_json
2911 (vl_api_classify_table_ids_reply_t * mp)
2913 vat_main_t *vam = &vat_main;
2914 int i, count = ntohl (mp->count);
2918 vat_json_node_t node;
2920 vat_json_init_object (&node);
2921 for (i = 0; i < count; i++)
2923 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
2925 vat_json_print (vam->ofp, &node);
2926 vat_json_free (&node);
2928 vam->retval = ntohl (mp->retval);
2929 vam->result_ready = 1;
2933 vl_api_classify_table_by_interface_reply_t_handler
2934 (vl_api_classify_table_by_interface_reply_t * mp)
2936 vat_main_t *vam = &vat_main;
2939 table_id = ntohl (mp->l2_table_id);
2941 fformat (vam->ofp, "l2 table id : %d\n", table_id);
2943 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
2944 table_id = ntohl (mp->ip4_table_id);
2946 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
2948 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
2949 table_id = ntohl (mp->ip6_table_id);
2951 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
2953 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
2954 vam->retval = ntohl (mp->retval);
2955 vam->result_ready = 1;
2959 vl_api_classify_table_by_interface_reply_t_handler_json
2960 (vl_api_classify_table_by_interface_reply_t * mp)
2962 vat_main_t *vam = &vat_main;
2963 vat_json_node_t node;
2965 vat_json_init_object (&node);
2967 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
2968 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
2969 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
2971 vat_json_print (vam->ofp, &node);
2972 vat_json_free (&node);
2974 vam->retval = ntohl (mp->retval);
2975 vam->result_ready = 1;
2978 static void vl_api_policer_add_del_reply_t_handler
2979 (vl_api_policer_add_del_reply_t * mp)
2981 vat_main_t *vam = &vat_main;
2982 i32 retval = ntohl (mp->retval);
2983 if (vam->async_mode)
2985 vam->async_errors += (retval < 0);
2989 vam->retval = retval;
2990 vam->result_ready = 1;
2991 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
2993 * Note: this is just barely thread-safe, depends on
2994 * the main thread spinning waiting for an answer...
2996 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3000 static void vl_api_policer_add_del_reply_t_handler_json
3001 (vl_api_policer_add_del_reply_t * mp)
3003 vat_main_t *vam = &vat_main;
3004 vat_json_node_t node;
3006 vat_json_init_object (&node);
3007 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3008 vat_json_object_add_uint (&node, "policer_index",
3009 ntohl (mp->policer_index));
3011 vat_json_print (vam->ofp, &node);
3012 vat_json_free (&node);
3014 vam->retval = ntohl (mp->retval);
3015 vam->result_ready = 1;
3018 /* Format hex dump. */
3020 format_hex_bytes (u8 * s, va_list * va)
3022 u8 *bytes = va_arg (*va, u8 *);
3023 int n_bytes = va_arg (*va, int);
3026 /* Print short or long form depending on byte count. */
3027 uword short_form = n_bytes <= 32;
3028 uword indent = format_get_indent (s);
3033 for (i = 0; i < n_bytes; i++)
3035 if (!short_form && (i % 32) == 0)
3036 s = format (s, "%08x: ", i);
3037 s = format (s, "%02x", bytes[i]);
3038 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3039 s = format (s, "\n%U", format_white_space, indent);
3046 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3049 vat_main_t *vam = &vat_main;
3050 i32 retval = ntohl (mp->retval);
3053 fformat (vam->ofp, "classify table info :\n");
3054 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3055 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3056 ntohl (mp->miss_next_index));
3057 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3058 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3059 ntohl (mp->match_n_vectors));
3060 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3061 ntohl (mp->mask_length));
3063 vam->retval = retval;
3064 vam->result_ready = 1;
3068 vl_api_classify_table_info_reply_t_handler_json
3069 (vl_api_classify_table_info_reply_t * mp)
3071 vat_main_t *vam = &vat_main;
3072 vat_json_node_t node;
3074 i32 retval = ntohl (mp->retval);
3077 vat_json_init_object (&node);
3079 vat_json_object_add_int (&node, "sessions",
3080 ntohl (mp->active_sessions));
3081 vat_json_object_add_int (&node, "nexttbl",
3082 ntohl (mp->next_table_index));
3083 vat_json_object_add_int (&node, "nextnode",
3084 ntohl (mp->miss_next_index));
3085 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3086 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3087 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3088 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3089 ntohl (mp->mask_length), 0);
3090 vat_json_object_add_string_copy (&node, "mask", s);
3092 vat_json_print (vam->ofp, &node);
3093 vat_json_free (&node);
3095 vam->retval = ntohl (mp->retval);
3096 vam->result_ready = 1;
3100 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3103 vat_main_t *vam = &vat_main;
3105 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3106 ntohl (mp->hit_next_index), ntohl (mp->advance),
3107 ntohl (mp->opaque_index));
3108 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3109 ntohl (mp->match_length));
3113 vl_api_classify_session_details_t_handler_json
3114 (vl_api_classify_session_details_t * mp)
3116 vat_main_t *vam = &vat_main;
3117 vat_json_node_t *node = NULL;
3119 if (VAT_JSON_ARRAY != vam->json_tree.type)
3121 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3122 vat_json_init_array (&vam->json_tree);
3124 node = vat_json_array_add (&vam->json_tree);
3126 vat_json_init_object (node);
3127 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3128 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3129 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3131 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3133 vat_json_object_add_string_copy (node, "match", s);
3136 static void vl_api_pg_create_interface_reply_t_handler
3137 (vl_api_pg_create_interface_reply_t * mp)
3139 vat_main_t *vam = &vat_main;
3141 vam->retval = ntohl (mp->retval);
3142 vam->result_ready = 1;
3145 static void vl_api_pg_create_interface_reply_t_handler_json
3146 (vl_api_pg_create_interface_reply_t * mp)
3148 vat_main_t *vam = &vat_main;
3149 vat_json_node_t node;
3151 i32 retval = ntohl (mp->retval);
3154 vat_json_init_object (&node);
3156 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3158 vat_json_print (vam->ofp, &node);
3159 vat_json_free (&node);
3161 vam->retval = ntohl (mp->retval);
3162 vam->result_ready = 1;
3165 static void vl_api_policer_classify_details_t_handler
3166 (vl_api_policer_classify_details_t * mp)
3168 vat_main_t *vam = &vat_main;
3170 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3171 ntohl (mp->table_index));
3174 static void vl_api_policer_classify_details_t_handler_json
3175 (vl_api_policer_classify_details_t * mp)
3177 vat_main_t *vam = &vat_main;
3178 vat_json_node_t *node;
3180 if (VAT_JSON_ARRAY != vam->json_tree.type)
3182 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3183 vat_json_init_array (&vam->json_tree);
3185 node = vat_json_array_add (&vam->json_tree);
3187 vat_json_init_object (node);
3188 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3189 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3193 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3194 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3195 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3196 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3199 * Generate boilerplate reply handlers, which
3200 * dig the return value out of the xxx_reply_t API message,
3201 * stick it into vam->retval, and set vam->result_ready
3203 * Could also do this by pointing N message decode slots at
3204 * a single function, but that could break in subtle ways.
3207 #define foreach_standard_reply_retval_handler \
3208 _(sw_interface_set_flags_reply) \
3209 _(sw_interface_add_del_address_reply) \
3210 _(sw_interface_set_table_reply) \
3211 _(sw_interface_set_vpath_reply) \
3212 _(sw_interface_set_l2_bridge_reply) \
3213 _(bridge_domain_add_del_reply) \
3214 _(sw_interface_set_l2_xconnect_reply) \
3215 _(l2fib_add_del_reply) \
3216 _(ip_add_del_route_reply) \
3217 _(proxy_arp_add_del_reply) \
3218 _(proxy_arp_intfc_enable_disable_reply) \
3219 _(mpls_add_del_encap_reply) \
3220 _(mpls_add_del_decap_reply) \
3221 _(mpls_ethernet_add_del_tunnel_2_reply) \
3222 _(sw_interface_set_unnumbered_reply) \
3223 _(ip_neighbor_add_del_reply) \
3224 _(reset_vrf_reply) \
3225 _(oam_add_del_reply) \
3226 _(reset_fib_reply) \
3227 _(dhcp_proxy_config_reply) \
3228 _(dhcp_proxy_config_2_reply) \
3229 _(dhcp_proxy_set_vss_reply) \
3230 _(dhcp_client_config_reply) \
3231 _(set_ip_flow_hash_reply) \
3232 _(sw_interface_ip6_enable_disable_reply) \
3233 _(sw_interface_ip6_set_link_local_address_reply) \
3234 _(sw_interface_ip6nd_ra_prefix_reply) \
3235 _(sw_interface_ip6nd_ra_config_reply) \
3236 _(set_arp_neighbor_limit_reply) \
3237 _(l2_patch_add_del_reply) \
3238 _(sr_tunnel_add_del_reply) \
3239 _(sr_policy_add_del_reply) \
3240 _(sr_multicast_map_add_del_reply) \
3241 _(classify_add_del_session_reply) \
3242 _(classify_set_interface_ip_table_reply) \
3243 _(classify_set_interface_l2_tables_reply) \
3244 _(l2tpv3_set_tunnel_cookies_reply) \
3245 _(l2tpv3_interface_enable_disable_reply) \
3246 _(l2tpv3_set_lookup_key_reply) \
3247 _(l2_fib_clear_table_reply) \
3248 _(l2_interface_efp_filter_reply) \
3249 _(l2_interface_vlan_tag_rewrite_reply) \
3250 _(modify_vhost_user_if_reply) \
3251 _(delete_vhost_user_if_reply) \
3252 _(want_ip4_arp_events_reply) \
3253 _(input_acl_set_interface_reply) \
3254 _(ipsec_spd_add_del_reply) \
3255 _(ipsec_interface_add_del_spd_reply) \
3256 _(ipsec_spd_add_del_entry_reply) \
3257 _(ipsec_sad_add_del_entry_reply) \
3258 _(ipsec_sa_set_key_reply) \
3259 _(ikev2_profile_add_del_reply) \
3260 _(ikev2_profile_set_auth_reply) \
3261 _(ikev2_profile_set_id_reply) \
3262 _(ikev2_profile_set_ts_reply) \
3263 _(ikev2_set_local_key_reply) \
3264 _(delete_loopback_reply) \
3265 _(bd_ip_mac_add_del_reply) \
3266 _(map_del_domain_reply) \
3267 _(map_add_del_rule_reply) \
3268 _(want_interface_events_reply) \
3269 _(want_stats_reply) \
3270 _(cop_interface_enable_disable_reply) \
3271 _(cop_whitelist_enable_disable_reply) \
3272 _(sw_interface_clear_stats_reply) \
3273 _(trace_profile_add_reply) \
3274 _(trace_profile_apply_reply) \
3275 _(trace_profile_del_reply) \
3276 _(lisp_add_del_locator_set_reply) \
3277 _(lisp_add_del_locator_reply) \
3278 _(lisp_add_del_local_eid_reply) \
3279 _(lisp_add_del_remote_mapping_reply) \
3280 _(lisp_add_del_adjacency_reply) \
3281 _(lisp_gpe_add_del_fwd_entry_reply) \
3282 _(lisp_add_del_map_resolver_reply) \
3283 _(lisp_gpe_enable_disable_reply) \
3284 _(lisp_gpe_add_del_iface_reply) \
3285 _(lisp_enable_disable_reply) \
3286 _(lisp_pitr_set_locator_set_reply) \
3287 _(lisp_add_del_map_request_itr_rlocs_reply) \
3288 _(lisp_eid_table_add_del_map_reply) \
3289 _(vxlan_gpe_add_del_tunnel_reply) \
3290 _(af_packet_delete_reply) \
3291 _(policer_classify_set_interface_reply) \
3292 _(netmap_create_reply) \
3293 _(netmap_delete_reply) \
3294 _(ipfix_enable_reply) \
3295 _(pg_capture_reply) \
3296 _(pg_enable_disable_reply) \
3297 _(ip_source_and_port_range_check_add_del_reply) \
3298 _(ip_source_and_port_range_check_interface_add_del_reply)
3301 static void vl_api_##n##_t_handler \
3302 (vl_api_##n##_t * mp) \
3304 vat_main_t * vam = &vat_main; \
3305 i32 retval = ntohl(mp->retval); \
3306 if (vam->async_mode) { \
3307 vam->async_errors += (retval < 0); \
3309 vam->retval = retval; \
3310 vam->result_ready = 1; \
3313 foreach_standard_reply_retval_handler;
3317 static void vl_api_##n##_t_handler_json \
3318 (vl_api_##n##_t * mp) \
3320 vat_main_t * vam = &vat_main; \
3321 vat_json_node_t node; \
3322 vat_json_init_object(&node); \
3323 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3324 vat_json_print(vam->ofp, &node); \
3325 vam->retval = ntohl(mp->retval); \
3326 vam->result_ready = 1; \
3328 foreach_standard_reply_retval_handler;
3332 * Table of message reply handlers, must include boilerplate handlers
3336 #define foreach_vpe_api_reply_msg \
3337 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3338 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3339 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3340 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3341 _(CONTROL_PING_REPLY, control_ping_reply) \
3342 _(NOPRINT_CONTROL_PING_REPLY, noprint_control_ping_reply) \
3343 _(CLI_REPLY, cli_reply) \
3344 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3345 sw_interface_add_del_address_reply) \
3346 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3347 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3348 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3349 sw_interface_set_l2_xconnect_reply) \
3350 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3351 sw_interface_set_l2_bridge_reply) \
3352 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3353 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3354 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3355 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3356 _(L2_FLAGS_REPLY, l2_flags_reply) \
3357 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3358 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3359 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3360 _(TAP_DELETE_REPLY, tap_delete_reply) \
3361 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3362 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3363 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3364 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3365 proxy_arp_intfc_enable_disable_reply) \
3366 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3367 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
3368 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
3369 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3370 mpls_ethernet_add_del_tunnel_reply) \
3371 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3372 mpls_ethernet_add_del_tunnel_2_reply) \
3373 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3374 sw_interface_set_unnumbered_reply) \
3375 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3376 _(RESET_VRF_REPLY, reset_vrf_reply) \
3377 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3378 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3379 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3380 _(RESET_FIB_REPLY, reset_fib_reply) \
3381 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3382 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3383 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3384 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3385 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3386 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3387 sw_interface_ip6_enable_disable_reply) \
3388 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3389 sw_interface_ip6_set_link_local_address_reply) \
3390 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3391 sw_interface_ip6nd_ra_prefix_reply) \
3392 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3393 sw_interface_ip6nd_ra_config_reply) \
3394 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3395 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3396 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3397 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3398 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3399 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3400 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3401 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3402 classify_set_interface_ip_table_reply) \
3403 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3404 classify_set_interface_l2_tables_reply) \
3405 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3406 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3407 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3408 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3409 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3410 l2tpv3_interface_enable_disable_reply) \
3411 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3412 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3413 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3414 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3415 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3416 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3417 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3418 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3419 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3420 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3421 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3422 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3423 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3424 _(SHOW_VERSION_REPLY, show_version_reply) \
3425 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3426 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3427 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3428 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3429 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3430 _(IP4_ARP_EVENT, ip4_arp_event) \
3431 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3432 _(IP_ADDRESS_DETAILS, ip_address_details) \
3433 _(IP_DETAILS, ip_details) \
3434 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3435 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3436 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3437 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3438 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3439 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3440 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3441 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3442 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3443 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3444 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3445 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3446 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3447 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3448 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3449 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3450 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3451 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3452 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3453 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3454 _(MAP_RULE_DETAILS, map_rule_details) \
3455 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3456 _(WANT_STATS_REPLY, want_stats_reply) \
3457 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3458 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3459 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3460 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3461 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3462 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
3463 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
3464 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
3465 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3466 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3467 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3468 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3469 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3470 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3471 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3472 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3473 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3474 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3475 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3476 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3477 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3478 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3479 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3480 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3481 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3482 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3483 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3484 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3485 lisp_add_del_map_request_itr_rlocs_reply) \
3486 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3487 lisp_get_map_request_itr_rlocs_reply) \
3488 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3489 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3490 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3491 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3492 _(POLICER_DETAILS, policer_details) \
3493 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3494 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3495 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3496 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3497 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
3498 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3499 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3500 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
3501 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3502 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3503 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3504 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3505 _(IPFIX_ENABLE_REPLY, ipfix_enable_reply) \
3506 _(IPFIX_DETAILS, ipfix_details) \
3507 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3508 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3509 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3510 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3511 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3512 ip_source_and_port_range_check_add_del_reply) \
3513 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3514 ip_source_and_port_range_check_interface_add_del_reply)
3516 /* M: construct, but don't yet send a message */
3520 vam->result_ready = 0; \
3521 mp = vl_msg_api_alloc(sizeof(*mp)); \
3522 memset (mp, 0, sizeof (*mp)); \
3523 mp->_vl_msg_id = ntohs (VL_API_##T); \
3524 mp->client_index = vam->my_client_index; \
3529 vam->result_ready = 0; \
3530 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3531 memset (mp, 0, sizeof (*mp)); \
3532 mp->_vl_msg_id = ntohs (VL_API_##T); \
3533 mp->client_index = vam->my_client_index; \
3537 /* S: send a message */
3538 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3540 /* W: wait for results, with timeout */
3543 timeout = vat_time_now (vam) + 1.0; \
3545 while (vat_time_now (vam) < timeout) { \
3546 if (vam->result_ready == 1) { \
3547 return (vam->retval); \
3553 /* W2: wait for results, with timeout */
3556 timeout = vat_time_now (vam) + 1.0; \
3558 while (vat_time_now (vam) < timeout) { \
3559 if (vam->result_ready == 1) { \
3561 return (vam->retval); \
3567 /* W_L: wait for results, with timeout */
3570 timeout = vat_time_now (vam) + 1.0; \
3572 while (vat_time_now (vam) < timeout) { \
3573 if (vam->result_ready == 1) { \
3575 return (vam->retval); \
3578 vam->noprint_msg = 0; \
3589 #define STR_VTR_OP_CASE(op) \
3590 case L2_VTR_ ## op: \
3594 str_vtr_op (u32 vtr_op)
3598 STR_VTR_OP_CASE (DISABLED);
3599 STR_VTR_OP_CASE (PUSH_1);
3600 STR_VTR_OP_CASE (PUSH_2);
3601 STR_VTR_OP_CASE (POP_1);
3602 STR_VTR_OP_CASE (POP_2);
3603 STR_VTR_OP_CASE (TRANSLATE_1_1);
3604 STR_VTR_OP_CASE (TRANSLATE_1_2);
3605 STR_VTR_OP_CASE (TRANSLATE_2_1);
3606 STR_VTR_OP_CASE (TRANSLATE_2_2);
3613 dump_sub_interface_table (vat_main_t * vam)
3615 const sw_interface_subif_t *sub = NULL;
3617 if (vam->json_output)
3620 ("JSON output supported only for VPE API calls and dump_stats_table");
3625 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3626 "Interface", "sw_if_index",
3627 "sub id", "dot1ad", "tags", "outer id",
3628 "inner id", "exact", "default", "outer any", "inner any");
3630 vec_foreach (sub, vam->sw_if_subif_table)
3633 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3634 sub->interface_name,
3636 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3637 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3638 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3639 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3640 if (sub->vtr_op != L2_VTR_DISABLED)
3643 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3644 "tag1: %d tag2: %d ]\n",
3645 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3646 sub->vtr_tag1, sub->vtr_tag2);
3654 name_sort_cmp (void *a1, void *a2)
3656 name_sort_t *n1 = a1;
3657 name_sort_t *n2 = a2;
3659 return strcmp ((char *) n1->name, (char *) n2->name);
3663 dump_interface_table (vat_main_t * vam)
3666 name_sort_t *nses = 0, *ns;
3668 if (vam->json_output)
3671 ("JSON output supported only for VPE API calls and dump_stats_table");
3676 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3678 vec_add2 (nses, ns, 1);
3679 ns->name = (u8 *)(p->key);
3680 ns->value = (u32) p->value[0];
3684 vec_sort_with_function (nses, name_sort_cmp);
3686 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3687 vec_foreach (ns, nses)
3689 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3696 dump_ip_table (vat_main_t * vam, int is_ipv6)
3698 const ip_details_t *det = NULL;
3699 const ip_address_details_t *address = NULL;
3702 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3709 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3716 fformat (vam->ofp, "%-12d\n", i);
3718 " %-30s%-13s\n", "Address", "Prefix length");
3723 vec_foreach (address, det->addr)
3727 is_ipv6 ? format_ip6_address : format_ip4_address,
3728 address->ip, address->prefix_length);
3736 dump_ipv4_table (vat_main_t * vam)
3738 if (vam->json_output)
3741 ("JSON output supported only for VPE API calls and dump_stats_table");
3745 return dump_ip_table (vam, 0);
3749 dump_ipv6_table (vat_main_t * vam)
3751 if (vam->json_output)
3754 ("JSON output supported only for VPE API calls and dump_stats_table");
3758 return dump_ip_table (vam, 1);
3762 counter_type_to_str (u8 counter_type, u8 is_combined)
3766 switch (counter_type)
3768 case VNET_INTERFACE_COUNTER_DROP:
3770 case VNET_INTERFACE_COUNTER_PUNT:
3772 case VNET_INTERFACE_COUNTER_IP4:
3774 case VNET_INTERFACE_COUNTER_IP6:
3776 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3778 case VNET_INTERFACE_COUNTER_RX_MISS:
3780 case VNET_INTERFACE_COUNTER_RX_ERROR:
3782 case VNET_INTERFACE_COUNTER_TX_ERROR:
3785 return "INVALID-COUNTER-TYPE";
3790 switch (counter_type)
3792 case VNET_INTERFACE_COUNTER_RX:
3794 case VNET_INTERFACE_COUNTER_TX:
3797 return "INVALID-COUNTER-TYPE";
3803 dump_stats_table (vat_main_t * vam)
3805 vat_json_node_t node;
3806 vat_json_node_t *msg_array;
3807 vat_json_node_t *msg;
3808 vat_json_node_t *counter_array;
3809 vat_json_node_t *counter;
3810 interface_counter_t c;
3812 ip4_fib_counter_t *c4;
3813 ip6_fib_counter_t *c6;
3816 if (!vam->json_output)
3818 clib_warning ("dump_stats_table supported only in JSON format");
3822 vat_json_init_object (&node);
3824 /* interface counters */
3825 msg_array = vat_json_object_add (&node, "interface_counters");
3826 vat_json_init_array (msg_array);
3827 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
3829 msg = vat_json_array_add (msg_array);
3830 vat_json_init_object (msg);
3831 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3832 (u8 *) counter_type_to_str (i, 0));
3833 vat_json_object_add_int (msg, "is_combined", 0);
3834 counter_array = vat_json_object_add (msg, "data");
3835 vat_json_init_array (counter_array);
3836 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
3838 packets = vam->simple_interface_counters[i][j];
3839 vat_json_array_add_uint (counter_array, packets);
3842 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
3844 msg = vat_json_array_add (msg_array);
3845 vat_json_init_object (msg);
3846 vat_json_object_add_string_copy (msg, "vnet_counter_type",
3847 (u8 *) counter_type_to_str (i, 1));
3848 vat_json_object_add_int (msg, "is_combined", 1);
3849 counter_array = vat_json_object_add (msg, "data");
3850 vat_json_init_array (counter_array);
3851 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
3853 c = vam->combined_interface_counters[i][j];
3854 counter = vat_json_array_add (counter_array);
3855 vat_json_init_object (counter);
3856 vat_json_object_add_uint (counter, "packets", c.packets);
3857 vat_json_object_add_uint (counter, "bytes", c.bytes);
3861 /* ip4 fib counters */
3862 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
3863 vat_json_init_array (msg_array);
3864 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
3866 msg = vat_json_array_add (msg_array);
3867 vat_json_init_object (msg);
3868 vat_json_object_add_uint (msg, "vrf_id",
3869 vam->ip4_fib_counters_vrf_id_by_index[i]);
3870 counter_array = vat_json_object_add (msg, "c");
3871 vat_json_init_array (counter_array);
3872 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
3874 counter = vat_json_array_add (counter_array);
3875 vat_json_init_object (counter);
3876 c4 = &vam->ip4_fib_counters[i][j];
3877 vat_json_object_add_ip4 (counter, "address", c4->address);
3878 vat_json_object_add_uint (counter, "address_length",
3879 c4->address_length);
3880 vat_json_object_add_uint (counter, "packets", c4->packets);
3881 vat_json_object_add_uint (counter, "bytes", c4->bytes);
3885 /* ip6 fib counters */
3886 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
3887 vat_json_init_array (msg_array);
3888 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
3890 msg = vat_json_array_add (msg_array);
3891 vat_json_init_object (msg);
3892 vat_json_object_add_uint (msg, "vrf_id",
3893 vam->ip6_fib_counters_vrf_id_by_index[i]);
3894 counter_array = vat_json_object_add (msg, "c");
3895 vat_json_init_array (counter_array);
3896 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
3898 counter = vat_json_array_add (counter_array);
3899 vat_json_init_object (counter);
3900 c6 = &vam->ip6_fib_counters[i][j];
3901 vat_json_object_add_ip6 (counter, "address", c6->address);
3902 vat_json_object_add_uint (counter, "address_length",
3903 c6->address_length);
3904 vat_json_object_add_uint (counter, "packets", c6->packets);
3905 vat_json_object_add_uint (counter, "bytes", c6->bytes);
3909 vat_json_print (vam->ofp, &node);
3910 vat_json_free (&node);
3916 exec (vat_main_t * vam)
3918 api_main_t *am = &api_main;
3919 vl_api_cli_request_t *mp;
3923 unformat_input_t *i = vam->input;
3925 if (vec_len (i->buffer) == 0)
3928 if (vam->exec_mode == 0 && unformat (i, "mode"))
3933 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
3940 M (CLI_REQUEST, cli_request);
3943 * Copy cmd into shared memory.
3944 * In order for the CLI command to work, it
3945 * must be a vector ending in \n, not a C-string ending
3948 pthread_mutex_lock (&am->vlib_rp->mutex);
3949 oldheap = svm_push_data_heap (am->vlib_rp);
3951 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
3952 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
3954 svm_pop_heap (oldheap);
3955 pthread_mutex_unlock (&am->vlib_rp->mutex);
3957 mp->cmd_in_shmem = (u64) cmd;
3959 timeout = vat_time_now (vam) + 10.0;
3961 while (vat_time_now (vam) < timeout)
3963 if (vam->result_ready == 1)
3966 if (vam->shmem_result != NULL)
3967 fformat (vam->ofp, "%s", vam->shmem_result);
3968 pthread_mutex_lock (&am->vlib_rp->mutex);
3969 oldheap = svm_push_data_heap (am->vlib_rp);
3971 free_me = (u8 *) vam->shmem_result;
3974 svm_pop_heap (oldheap);
3975 pthread_mutex_unlock (&am->vlib_rp->mutex);
3983 api_create_loopback (vat_main_t * vam)
3985 unformat_input_t *i = vam->input;
3986 vl_api_create_loopback_t *mp;
3991 memset (mac_address, 0, sizeof (mac_address));
3993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3995 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4001 /* Construct the API message */
4002 M (CREATE_LOOPBACK, create_loopback);
4004 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4011 api_delete_loopback (vat_main_t * vam)
4013 unformat_input_t *i = vam->input;
4014 vl_api_delete_loopback_t *mp;
4016 u32 sw_if_index = ~0;
4018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4020 if (unformat (i, "sw_if_index %d", &sw_if_index))
4026 if (sw_if_index == ~0)
4028 errmsg ("missing sw_if_index\n");
4032 /* Construct the API message */
4033 M (DELETE_LOOPBACK, delete_loopback);
4034 mp->sw_if_index = ntohl (sw_if_index);
4041 api_want_stats (vat_main_t * vam)
4043 unformat_input_t *i = vam->input;
4044 vl_api_want_stats_t *mp;
4048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4050 if (unformat (i, "enable"))
4052 else if (unformat (i, "disable"))
4060 errmsg ("missing enable|disable\n");
4064 M (WANT_STATS, want_stats);
4065 mp->enable_disable = enable;
4072 api_want_interface_events (vat_main_t * vam)
4074 unformat_input_t *i = vam->input;
4075 vl_api_want_interface_events_t *mp;
4079 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4081 if (unformat (i, "enable"))
4083 else if (unformat (i, "disable"))
4091 errmsg ("missing enable|disable\n");
4095 M (WANT_INTERFACE_EVENTS, want_interface_events);
4096 mp->enable_disable = enable;
4098 vam->interface_event_display = enable;
4105 /* Note: non-static, called once to set up the initial intfc table */
4107 api_sw_interface_dump (vat_main_t * vam)
4109 vl_api_sw_interface_dump_t *mp;
4112 name_sort_t *nses = 0, *ns;
4113 sw_interface_subif_t *sub = NULL;
4115 /* Toss the old name table */
4117 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4119 vec_add2 (nses, ns, 1);
4120 ns->name = (u8 *)(p->key);
4121 ns->value = (u32) p->value[0];
4125 hash_free (vam->sw_if_index_by_interface_name);
4127 vec_foreach (ns, nses) vec_free (ns->name);
4131 vec_foreach (sub, vam->sw_if_subif_table)
4133 vec_free (sub->interface_name);
4135 vec_free (vam->sw_if_subif_table);
4137 /* recreate the interface name hash table */
4138 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4140 /* Get list of ethernets */
4141 M (SW_INTERFACE_DUMP, sw_interface_dump);
4142 mp->name_filter_valid = 1;
4143 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4146 /* and local / loopback interfaces */
4147 M (SW_INTERFACE_DUMP, sw_interface_dump);
4148 mp->name_filter_valid = 1;
4149 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4153 /* and vxlan-gpe tunnel interfaces */
4154 M (SW_INTERFACE_DUMP, sw_interface_dump);
4155 mp->name_filter_valid = 1;
4156 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4157 sizeof (mp->name_filter) - 1);
4160 /* and vxlan tunnel interfaces */
4161 M (SW_INTERFACE_DUMP, sw_interface_dump);
4162 mp->name_filter_valid = 1;
4163 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4166 /* and host (af_packet) interfaces */
4167 M (SW_INTERFACE_DUMP, sw_interface_dump);
4168 mp->name_filter_valid = 1;
4169 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4172 /* and l2tpv3 tunnel interfaces */
4173 M (SW_INTERFACE_DUMP, sw_interface_dump);
4174 mp->name_filter_valid = 1;
4175 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4176 sizeof (mp->name_filter) - 1);
4179 /* and GRE tunnel interfaces */
4180 M (SW_INTERFACE_DUMP, sw_interface_dump);
4181 mp->name_filter_valid = 1;
4182 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4185 /* Use a control ping for synchronization */
4187 vl_api_control_ping_t *mp;
4188 M (CONTROL_PING, control_ping);
4195 api_sw_interface_set_flags (vat_main_t * vam)
4197 unformat_input_t *i = vam->input;
4198 vl_api_sw_interface_set_flags_t *mp;
4201 u8 sw_if_index_set = 0;
4202 u8 admin_up = 0, link_up = 0;
4204 /* Parse args required to build the message */
4205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4207 if (unformat (i, "admin-up"))
4209 else if (unformat (i, "admin-down"))
4211 else if (unformat (i, "link-up"))
4213 else if (unformat (i, "link-down"))
4215 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4216 sw_if_index_set = 1;
4217 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4218 sw_if_index_set = 1;
4223 if (sw_if_index_set == 0)
4225 errmsg ("missing interface name or sw_if_index\n");
4229 /* Construct the API message */
4230 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4231 mp->sw_if_index = ntohl (sw_if_index);
4232 mp->admin_up_down = admin_up;
4233 mp->link_up_down = link_up;
4238 /* Wait for a reply, return the good/bad news... */
4243 api_sw_interface_clear_stats (vat_main_t * vam)
4245 unformat_input_t *i = vam->input;
4246 vl_api_sw_interface_clear_stats_t *mp;
4249 u8 sw_if_index_set = 0;
4251 /* Parse args required to build the message */
4252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4254 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4255 sw_if_index_set = 1;
4256 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4257 sw_if_index_set = 1;
4262 /* Construct the API message */
4263 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4265 if (sw_if_index_set == 1)
4266 mp->sw_if_index = ntohl (sw_if_index);
4268 mp->sw_if_index = ~0;
4273 /* Wait for a reply, return the good/bad news... */
4278 api_sw_interface_add_del_address (vat_main_t * vam)
4280 unformat_input_t *i = vam->input;
4281 vl_api_sw_interface_add_del_address_t *mp;
4284 u8 sw_if_index_set = 0;
4285 u8 is_add = 1, del_all = 0;
4286 u32 address_length = 0;
4287 u8 v4_address_set = 0;
4288 u8 v6_address_set = 0;
4289 ip4_address_t v4address;
4290 ip6_address_t v6address;
4292 /* Parse args required to build the message */
4293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4295 if (unformat (i, "del-all"))
4297 else if (unformat (i, "del"))
4299 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4300 sw_if_index_set = 1;
4301 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4302 sw_if_index_set = 1;
4303 else if (unformat (i, "%U/%d",
4304 unformat_ip4_address, &v4address, &address_length))
4306 else if (unformat (i, "%U/%d",
4307 unformat_ip6_address, &v6address, &address_length))
4313 if (sw_if_index_set == 0)
4315 errmsg ("missing interface name or sw_if_index\n");
4318 if (v4_address_set && v6_address_set)
4320 errmsg ("both v4 and v6 addresses set\n");
4323 if (!v4_address_set && !v6_address_set && !del_all)
4325 errmsg ("no addresses set\n");
4329 /* Construct the API message */
4330 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4332 mp->sw_if_index = ntohl (sw_if_index);
4333 mp->is_add = is_add;
4334 mp->del_all = del_all;
4338 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4342 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4344 mp->address_length = address_length;
4349 /* Wait for a reply, return good/bad news */
4354 api_sw_interface_set_table (vat_main_t * vam)
4356 unformat_input_t *i = vam->input;
4357 vl_api_sw_interface_set_table_t *mp;
4359 u32 sw_if_index, vrf_id = 0;
4360 u8 sw_if_index_set = 0;
4363 /* Parse args required to build the message */
4364 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4366 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4367 sw_if_index_set = 1;
4368 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4369 sw_if_index_set = 1;
4370 else if (unformat (i, "vrf %d", &vrf_id))
4372 else if (unformat (i, "ipv6"))
4378 if (sw_if_index_set == 0)
4380 errmsg ("missing interface name or sw_if_index\n");
4384 /* Construct the API message */
4385 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4387 mp->sw_if_index = ntohl (sw_if_index);
4388 mp->is_ipv6 = is_ipv6;
4389 mp->vrf_id = ntohl (vrf_id);
4394 /* Wait for a reply... */
4399 api_sw_interface_set_vpath (vat_main_t * vam)
4401 unformat_input_t *i = vam->input;
4402 vl_api_sw_interface_set_vpath_t *mp;
4404 u32 sw_if_index = 0;
4405 u8 sw_if_index_set = 0;
4408 /* Parse args required to build the message */
4409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4411 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4412 sw_if_index_set = 1;
4413 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4414 sw_if_index_set = 1;
4415 else if (unformat (i, "enable"))
4417 else if (unformat (i, "disable"))
4423 if (sw_if_index_set == 0)
4425 errmsg ("missing interface name or sw_if_index\n");
4429 /* Construct the API message */
4430 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4432 mp->sw_if_index = ntohl (sw_if_index);
4433 mp->enable = is_enable;
4438 /* Wait for a reply... */
4443 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4445 unformat_input_t *i = vam->input;
4446 vl_api_sw_interface_set_l2_xconnect_t *mp;
4449 u8 rx_sw_if_index_set = 0;
4451 u8 tx_sw_if_index_set = 0;
4454 /* Parse args required to build the message */
4455 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4457 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
4458 rx_sw_if_index_set = 1;
4459 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4460 tx_sw_if_index_set = 1;
4461 else if (unformat (i, "rx"))
4463 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4465 if (unformat (i, "%U", unformat_sw_if_index, vam,
4467 rx_sw_if_index_set = 1;
4472 else if (unformat (i, "tx"))
4474 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4476 if (unformat (i, "%U", unformat_sw_if_index, vam,
4478 tx_sw_if_index_set = 1;
4483 else if (unformat (i, "enable"))
4485 else if (unformat (i, "disable"))
4491 if (rx_sw_if_index_set == 0)
4493 errmsg ("missing rx interface name or rx_sw_if_index\n");
4497 if (enable && (tx_sw_if_index_set == 0))
4499 errmsg ("missing tx interface name or tx_sw_if_index\n");
4503 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
4505 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4506 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
4507 mp->enable = enable;
4516 api_sw_interface_set_l2_bridge (vat_main_t * vam)
4518 unformat_input_t *i = vam->input;
4519 vl_api_sw_interface_set_l2_bridge_t *mp;
4522 u8 rx_sw_if_index_set = 0;
4529 /* Parse args required to build the message */
4530 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4532 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
4533 rx_sw_if_index_set = 1;
4534 else if (unformat (i, "bd_id %d", &bd_id))
4536 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
4537 rx_sw_if_index_set = 1;
4538 else if (unformat (i, "shg %d", &shg))
4540 else if (unformat (i, "bvi"))
4542 else if (unformat (i, "enable"))
4544 else if (unformat (i, "disable"))
4550 if (rx_sw_if_index_set == 0)
4552 errmsg ("missing rx interface name or sw_if_index\n");
4556 if (enable && (bd_id_set == 0))
4558 errmsg ("missing bridge domain\n");
4562 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
4564 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
4565 mp->bd_id = ntohl (bd_id);
4568 mp->enable = enable;
4577 api_bridge_domain_dump (vat_main_t * vam)
4579 unformat_input_t *i = vam->input;
4580 vl_api_bridge_domain_dump_t *mp;
4584 /* Parse args required to build the message */
4585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4587 if (unformat (i, "bd_id %d", &bd_id))
4593 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
4594 mp->bd_id = ntohl (bd_id);
4597 /* Use a control ping for synchronization */
4599 vl_api_control_ping_t *mp;
4600 M (CONTROL_PING, control_ping);
4610 api_bridge_domain_add_del (vat_main_t * vam)
4612 unformat_input_t *i = vam->input;
4613 vl_api_bridge_domain_add_del_t *mp;
4617 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
4619 /* Parse args required to build the message */
4620 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4622 if (unformat (i, "bd_id %d", &bd_id))
4624 else if (unformat (i, "flood %d", &flood))
4626 else if (unformat (i, "uu-flood %d", &uu_flood))
4628 else if (unformat (i, "forward %d", &forward))
4630 else if (unformat (i, "learn %d", &learn))
4632 else if (unformat (i, "arp-term %d", &arp_term))
4634 else if (unformat (i, "del"))
4637 flood = uu_flood = forward = learn = 0;
4645 errmsg ("missing bridge domain\n");
4649 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
4651 mp->bd_id = ntohl (bd_id);
4653 mp->uu_flood = uu_flood;
4654 mp->forward = forward;
4656 mp->arp_term = arp_term;
4657 mp->is_add = is_add;
4666 api_l2fib_add_del (vat_main_t * vam)
4668 unformat_input_t *i = vam->input;
4669 vl_api_l2fib_add_del_t *mp;
4676 u8 sw_if_index_set = 0;
4685 /* Parse args required to build the message */
4686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4688 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
4690 else if (unformat (i, "bd_id %d", &bd_id))
4692 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4693 sw_if_index_set = 1;
4694 else if (unformat (i, "sw_if"))
4696 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4698 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4699 sw_if_index_set = 1;
4704 else if (unformat (i, "static"))
4706 else if (unformat (i, "filter"))
4711 else if (unformat (i, "bvi"))
4716 else if (unformat (i, "del"))
4718 else if (unformat (i, "count %d", &count))
4726 errmsg ("missing mac address\n");
4732 errmsg ("missing bridge domain\n");
4736 if (is_add && (sw_if_index_set == 0))
4738 errmsg ("missing interface name or sw_if_index\n");
4744 /* Turn on async mode */
4745 vam->async_mode = 1;
4746 vam->async_errors = 0;
4747 before = vat_time_now (vam);
4750 for (j = 0; j < count; j++)
4752 M (L2FIB_ADD_DEL, l2fib_add_del);
4755 mp->bd_id = ntohl (bd_id);
4756 mp->is_add = is_add;
4760 mp->sw_if_index = ntohl (sw_if_index);
4761 mp->static_mac = static_mac;
4762 mp->filter_mac = filter_mac;
4763 mp->bvi_mac = bvi_mac;
4765 increment_mac_address (&mac);
4772 vl_api_control_ping_t *mp;
4775 /* Shut off async mode */
4776 vam->async_mode = 0;
4778 M (CONTROL_PING, control_ping);
4781 timeout = vat_time_now (vam) + 1.0;
4782 while (vat_time_now (vam) < timeout)
4783 if (vam->result_ready == 1)
4788 if (vam->retval == -99)
4789 errmsg ("timeout\n");
4791 if (vam->async_errors > 0)
4793 errmsg ("%d asynchronous errors\n", vam->async_errors);
4796 vam->async_errors = 0;
4797 after = vat_time_now (vam);
4799 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4800 count, after - before, count / (after - before));
4804 /* Wait for a reply... */
4807 /* Return the good/bad news */
4808 return (vam->retval);
4812 api_l2_flags (vat_main_t * vam)
4814 unformat_input_t *i = vam->input;
4815 vl_api_l2_flags_t *mp;
4818 u32 feature_bitmap = 0;
4819 u8 sw_if_index_set = 0;
4821 /* Parse args required to build the message */
4822 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4824 if (unformat (i, "sw_if_index %d", &sw_if_index))
4825 sw_if_index_set = 1;
4826 else if (unformat (i, "sw_if"))
4828 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4830 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4831 sw_if_index_set = 1;
4836 else if (unformat (i, "learn"))
4837 feature_bitmap |= L2INPUT_FEAT_LEARN;
4838 else if (unformat (i, "forward"))
4839 feature_bitmap |= L2INPUT_FEAT_FWD;
4840 else if (unformat (i, "flood"))
4841 feature_bitmap |= L2INPUT_FEAT_FLOOD;
4842 else if (unformat (i, "uu-flood"))
4843 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
4848 if (sw_if_index_set == 0)
4850 errmsg ("missing interface name or sw_if_index\n");
4854 M (L2_FLAGS, l2_flags);
4856 mp->sw_if_index = ntohl (sw_if_index);
4857 mp->feature_bitmap = ntohl (feature_bitmap);
4866 api_bridge_flags (vat_main_t * vam)
4868 unformat_input_t *i = vam->input;
4869 vl_api_bridge_flags_t *mp;
4876 /* Parse args required to build the message */
4877 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4879 if (unformat (i, "bd_id %d", &bd_id))
4881 else if (unformat (i, "learn"))
4883 else if (unformat (i, "forward"))
4885 else if (unformat (i, "flood"))
4887 else if (unformat (i, "uu-flood"))
4888 flags |= L2_UU_FLOOD;
4889 else if (unformat (i, "arp-term"))
4890 flags |= L2_ARP_TERM;
4891 else if (unformat (i, "off"))
4893 else if (unformat (i, "disable"))
4901 errmsg ("missing bridge domain\n");
4905 M (BRIDGE_FLAGS, bridge_flags);
4907 mp->bd_id = ntohl (bd_id);
4908 mp->feature_bitmap = ntohl (flags);
4909 mp->is_set = is_set;
4918 api_bd_ip_mac_add_del (vat_main_t * vam)
4920 unformat_input_t *i = vam->input;
4921 vl_api_bd_ip_mac_add_del_t *mp;
4929 ip4_address_t v4addr;
4930 ip6_address_t v6addr;
4934 /* Parse args required to build the message */
4935 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4937 if (unformat (i, "bd_id %d", &bd_id))
4941 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
4945 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
4950 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
4954 else if (unformat (i, "del"))
4962 errmsg ("missing bridge domain\n");
4965 else if (ip_set == 0)
4967 errmsg ("missing IP address\n");
4970 else if (mac_set == 0)
4972 errmsg ("missing MAC address\n");
4976 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
4978 mp->bd_id = ntohl (bd_id);
4979 mp->is_ipv6 = is_ipv6;
4980 mp->is_add = is_add;
4982 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
4984 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
4985 clib_memcpy (mp->mac_address, macaddr, 6);
4993 api_tap_connect (vat_main_t * vam)
4995 unformat_input_t *i = vam->input;
4996 vl_api_tap_connect_t *mp;
5003 memset (mac_address, 0, sizeof (mac_address));
5005 /* Parse args required to build the message */
5006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5008 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5012 else if (unformat (i, "random-mac"))
5014 else if (unformat (i, "tapname %s", &tap_name))
5022 errmsg ("missing tap name\n");
5025 if (vec_len (tap_name) > 63)
5027 errmsg ("tap name too long\n");
5029 vec_add1 (tap_name, 0);
5031 /* Construct the API message */
5032 M (TAP_CONNECT, tap_connect);
5034 mp->use_random_mac = random_mac;
5035 clib_memcpy (mp->mac_address, mac_address, 6);
5036 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5037 vec_free (tap_name);
5042 /* Wait for a reply... */
5047 api_tap_modify (vat_main_t * vam)
5049 unformat_input_t *i = vam->input;
5050 vl_api_tap_modify_t *mp;
5056 u32 sw_if_index = ~0;
5057 u8 sw_if_index_set = 0;
5059 memset (mac_address, 0, sizeof (mac_address));
5061 /* Parse args required to build the message */
5062 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5064 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5065 sw_if_index_set = 1;
5066 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5067 sw_if_index_set = 1;
5068 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5072 else if (unformat (i, "random-mac"))
5074 else if (unformat (i, "tapname %s", &tap_name))
5080 if (sw_if_index_set == 0)
5082 errmsg ("missing vpp interface name");
5087 errmsg ("missing tap name\n");
5090 if (vec_len (tap_name) > 63)
5092 errmsg ("tap name too long\n");
5094 vec_add1 (tap_name, 0);
5096 /* Construct the API message */
5097 M (TAP_MODIFY, tap_modify);
5099 mp->use_random_mac = random_mac;
5100 mp->sw_if_index = ntohl (sw_if_index);
5101 clib_memcpy (mp->mac_address, mac_address, 6);
5102 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5103 vec_free (tap_name);
5108 /* Wait for a reply... */
5113 api_tap_delete (vat_main_t * vam)
5115 unformat_input_t *i = vam->input;
5116 vl_api_tap_delete_t *mp;
5118 u32 sw_if_index = ~0;
5119 u8 sw_if_index_set = 0;
5121 /* Parse args required to build the message */
5122 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5124 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5125 sw_if_index_set = 1;
5126 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5127 sw_if_index_set = 1;
5132 if (sw_if_index_set == 0)
5134 errmsg ("missing vpp interface name");
5138 /* Construct the API message */
5139 M (TAP_DELETE, tap_delete);
5141 mp->sw_if_index = ntohl (sw_if_index);
5146 /* Wait for a reply... */
5151 api_ip_add_del_route (vat_main_t * vam)
5153 unformat_input_t *i = vam->input;
5154 vl_api_ip_add_del_route_t *mp;
5156 u32 sw_if_index = ~0, vrf_id = 0;
5157 u8 sw_if_index_set = 0;
5159 u8 is_local = 0, is_drop = 0;
5160 u8 create_vrf_if_needed = 0;
5162 u8 next_hop_weight = 1;
5164 u8 is_multipath = 0;
5166 u8 address_length_set = 0;
5167 u32 lookup_in_vrf = 0;
5168 u32 resolve_attempts = 0;
5169 u32 dst_address_length = 0;
5170 u8 next_hop_set = 0;
5171 ip4_address_t v4_dst_address, v4_next_hop_address;
5172 ip6_address_t v6_dst_address, v6_next_hop_address;
5176 u32 random_add_del = 0;
5177 u32 *random_vector = 0;
5179 u32 random_seed = 0xdeaddabe;
5180 u32 classify_table_index = ~0;
5183 /* Parse args required to build the message */
5184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5186 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5187 sw_if_index_set = 1;
5188 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5189 sw_if_index_set = 1;
5190 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5195 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5200 else if (unformat (i, "/%d", &dst_address_length))
5202 address_length_set = 1;
5205 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5206 &v4_next_hop_address))
5210 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5211 &v6_next_hop_address))
5215 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5217 else if (unformat (i, "weight %d", &next_hop_weight))
5219 else if (unformat (i, "drop"))
5223 else if (unformat (i, "local"))
5227 else if (unformat (i, "classify %d", &classify_table_index))
5231 else if (unformat (i, "del"))
5233 else if (unformat (i, "add"))
5235 else if (unformat (i, "not-last"))
5237 else if (unformat (i, "multipath"))
5239 else if (unformat (i, "vrf %d", &vrf_id))
5241 else if (unformat (i, "create-vrf"))
5242 create_vrf_if_needed = 1;
5243 else if (unformat (i, "count %d", &count))
5245 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
5247 else if (unformat (i, "random"))
5249 else if (unformat (i, "seed %d", &random_seed))
5253 clib_warning ("parse error '%U'", format_unformat_error, i);
5258 if (resolve_attempts > 0 && sw_if_index_set == 0)
5260 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5264 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5266 errmsg ("next hop / local / drop / classify not set\n");
5270 if (address_set == 0)
5272 errmsg ("missing addresses\n");
5276 if (address_length_set == 0)
5278 errmsg ("missing address length\n");
5282 /* Generate a pile of unique, random routes */
5285 u32 this_random_address;
5286 random_hash = hash_create (count, sizeof (uword));
5288 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5289 for (j = 0; j <= count; j++)
5293 this_random_address = random_u32 (&random_seed);
5294 this_random_address =
5295 clib_host_to_net_u32 (this_random_address);
5297 while (hash_get (random_hash, this_random_address));
5298 vec_add1 (random_vector, this_random_address);
5299 hash_set (random_hash, this_random_address, 1);
5301 hash_free (random_hash);
5302 v4_dst_address.as_u32 = random_vector[0];
5307 /* Turn on async mode */
5308 vam->async_mode = 1;
5309 vam->async_errors = 0;
5310 before = vat_time_now (vam);
5313 for (j = 0; j < count; j++)
5315 /* Construct the API message */
5316 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5318 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5319 mp->vrf_id = ntohl (vrf_id);
5320 if (resolve_attempts > 0)
5322 mp->resolve_attempts = ntohl (resolve_attempts);
5323 mp->resolve_if_needed = 1;
5325 mp->create_vrf_if_needed = create_vrf_if_needed;
5327 mp->is_add = is_add;
5328 mp->is_drop = is_drop;
5329 mp->is_ipv6 = is_ipv6;
5330 mp->is_local = is_local;
5331 mp->is_classify = is_classify;
5332 mp->is_multipath = is_multipath;
5333 mp->not_last = not_last;
5334 mp->next_hop_weight = next_hop_weight;
5335 mp->dst_address_length = dst_address_length;
5336 mp->lookup_in_vrf = ntohl (lookup_in_vrf);
5337 mp->classify_table_index = ntohl (classify_table_index);
5341 clib_memcpy (mp->dst_address, &v6_dst_address,
5342 sizeof (v6_dst_address));
5344 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5345 sizeof (v6_next_hop_address));
5346 increment_v6_address (&v6_dst_address);
5350 clib_memcpy (mp->dst_address, &v4_dst_address,
5351 sizeof (v4_dst_address));
5353 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5354 sizeof (v4_next_hop_address));
5356 v4_dst_address.as_u32 = random_vector[j + 1];
5358 increment_v4_address (&v4_dst_address);
5364 /* When testing multiple add/del ops, use a control-ping to sync */
5367 vl_api_control_ping_t *mp;
5370 /* Shut off async mode */
5371 vam->async_mode = 0;
5373 M (CONTROL_PING, control_ping);
5376 timeout = vat_time_now (vam) + 1.0;
5377 while (vat_time_now (vam) < timeout)
5378 if (vam->result_ready == 1)
5383 if (vam->retval == -99)
5384 errmsg ("timeout\n");
5386 if (vam->async_errors > 0)
5388 errmsg ("%d asynchronous errors\n", vam->async_errors);
5391 vam->async_errors = 0;
5392 after = vat_time_now (vam);
5394 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5395 count, after - before, count / (after - before));
5399 /* Wait for a reply... */
5403 /* Return the good/bad news */
5404 return (vam->retval);
5408 api_proxy_arp_add_del (vat_main_t * vam)
5410 unformat_input_t *i = vam->input;
5411 vl_api_proxy_arp_add_del_t *mp;
5415 ip4_address_t lo, hi;
5418 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5420 if (unformat (i, "vrf %d", &vrf_id))
5422 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
5423 unformat_ip4_address, &hi))
5425 else if (unformat (i, "del"))
5429 clib_warning ("parse error '%U'", format_unformat_error, i);
5436 errmsg ("address range not set\n");
5440 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
5442 mp->vrf_id = ntohl (vrf_id);
5443 mp->is_add = is_add;
5444 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
5445 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
5454 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
5456 unformat_input_t *i = vam->input;
5457 vl_api_proxy_arp_intfc_enable_disable_t *mp;
5461 u8 sw_if_index_set = 0;
5463 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5465 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5466 sw_if_index_set = 1;
5467 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5468 sw_if_index_set = 1;
5469 else if (unformat (i, "enable"))
5471 else if (unformat (i, "disable"))
5475 clib_warning ("parse error '%U'", format_unformat_error, i);
5480 if (sw_if_index_set == 0)
5482 errmsg ("missing interface name or sw_if_index\n");
5486 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
5488 mp->sw_if_index = ntohl (sw_if_index);
5489 mp->enable_disable = enable;
5498 api_mpls_add_del_decap (vat_main_t * vam)
5500 unformat_input_t *i = vam->input;
5501 vl_api_mpls_add_del_decap_t *mp;
5510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5512 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5514 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
5516 else if (unformat (i, "label %d", &label))
5518 else if (unformat (i, "next-index %d", &next_index))
5520 else if (unformat (i, "del"))
5522 else if (unformat (i, "s-bit-clear"))
5526 clib_warning ("parse error '%U'", format_unformat_error, i);
5531 M (MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
5533 mp->rx_vrf_id = ntohl (rx_vrf_id);
5534 mp->tx_vrf_id = ntohl (tx_vrf_id);
5535 mp->label = ntohl (label);
5536 mp->next_index = ntohl (next_index);
5538 mp->is_add = is_add;
5547 api_mpls_add_del_encap (vat_main_t * vam)
5549 unformat_input_t *i = vam->input;
5550 vl_api_mpls_add_del_encap_t *mp;
5555 ip4_address_t dst_address;
5558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5560 if (unformat (i, "vrf %d", &vrf_id))
5562 else if (unformat (i, "label %d", &label))
5563 vec_add1 (labels, ntohl (label));
5564 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5566 else if (unformat (i, "del"))
5570 clib_warning ("parse error '%U'", format_unformat_error, i);
5575 if (vec_len (labels) == 0)
5577 errmsg ("missing encap label stack\n");
5581 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
5582 sizeof (u32) * vec_len (labels));
5584 mp->vrf_id = ntohl (vrf_id);
5585 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5586 mp->is_add = is_add;
5587 mp->nlabels = vec_len (labels);
5588 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
5599 api_mpls_gre_add_del_tunnel (vat_main_t * vam)
5601 unformat_input_t *i = vam->input;
5602 vl_api_mpls_gre_add_del_tunnel_t *mp;
5604 u32 inner_vrf_id = 0;
5605 u32 outer_vrf_id = 0;
5606 ip4_address_t src_address;
5607 ip4_address_t dst_address;
5608 ip4_address_t intfc_address;
5610 u8 intfc_address_length = 0;
5614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5616 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5618 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5620 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
5622 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
5624 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5625 &intfc_address, &tmp))
5626 intfc_address_length = tmp;
5627 else if (unformat (i, "l2-only"))
5629 else if (unformat (i, "del"))
5633 clib_warning ("parse error '%U'", format_unformat_error, i);
5638 M (MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
5640 mp->inner_vrf_id = ntohl (inner_vrf_id);
5641 mp->outer_vrf_id = ntohl (outer_vrf_id);
5642 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
5643 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
5644 clib_memcpy (mp->intfc_address, &intfc_address, sizeof (intfc_address));
5645 mp->intfc_address_length = intfc_address_length;
5646 mp->l2_only = l2_only;
5647 mp->is_add = is_add;
5656 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
5658 unformat_input_t *i = vam->input;
5659 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
5661 u32 inner_vrf_id = 0;
5662 ip4_address_t intfc_address;
5663 u8 dst_mac_address[6];
5666 u8 intfc_address_length = 0;
5670 int tx_sw_if_index_set = 0;
5672 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5674 if (unformat (i, "vrf %d", &inner_vrf_id))
5676 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5677 &intfc_address, &tmp))
5678 intfc_address_length = tmp;
5679 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
5680 tx_sw_if_index_set = 1;
5681 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5682 tx_sw_if_index_set = 1;
5683 else if (unformat (i, "dst %U", unformat_ethernet_address,
5686 else if (unformat (i, "l2-only"))
5688 else if (unformat (i, "del"))
5692 clib_warning ("parse error '%U'", format_unformat_error, i);
5699 errmsg ("dst (mac address) not set\n");
5702 if (!tx_sw_if_index_set)
5704 errmsg ("tx-intfc not set\n");
5708 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
5710 mp->vrf_id = ntohl (inner_vrf_id);
5711 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
5712 mp->adj_address_length = intfc_address_length;
5713 clib_memcpy (mp->dst_mac_address, dst_mac_address,
5714 sizeof (dst_mac_address));
5715 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5716 mp->l2_only = l2_only;
5717 mp->is_add = is_add;
5726 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
5728 unformat_input_t *i = vam->input;
5729 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
5731 u32 inner_vrf_id = 0;
5732 u32 outer_vrf_id = 0;
5733 ip4_address_t adj_address;
5734 int adj_address_set = 0;
5735 ip4_address_t next_hop_address;
5736 int next_hop_address_set = 0;
5738 u8 adj_address_length = 0;
5741 u32 resolve_attempts = 5;
5742 u8 resolve_if_needed = 1;
5744 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5746 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
5748 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
5750 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
5751 &adj_address, &tmp))
5753 adj_address_length = tmp;
5754 adj_address_set = 1;
5756 else if (unformat (i, "next-hop %U", unformat_ip4_address,
5758 next_hop_address_set = 1;
5759 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5761 else if (unformat (i, "resolve-if-needed %d", &tmp))
5762 resolve_if_needed = tmp;
5763 else if (unformat (i, "l2-only"))
5765 else if (unformat (i, "del"))
5769 clib_warning ("parse error '%U'", format_unformat_error, i);
5774 if (!adj_address_set)
5776 errmsg ("adjacency address/mask not set\n");
5779 if (!next_hop_address_set)
5781 errmsg ("ip4 next hop address (in outer fib) not set\n");
5785 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
5787 mp->inner_vrf_id = ntohl (inner_vrf_id);
5788 mp->outer_vrf_id = ntohl (outer_vrf_id);
5789 mp->resolve_attempts = ntohl (resolve_attempts);
5790 mp->resolve_if_needed = resolve_if_needed;
5791 mp->is_add = is_add;
5792 mp->l2_only = l2_only;
5793 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
5794 mp->adj_address_length = adj_address_length;
5795 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
5796 sizeof (next_hop_address));
5805 api_sw_interface_set_unnumbered (vat_main_t * vam)
5807 unformat_input_t *i = vam->input;
5808 vl_api_sw_interface_set_unnumbered_t *mp;
5813 u8 sw_if_index_set = 0;
5815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5817 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5818 sw_if_index_set = 1;
5819 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5820 sw_if_index_set = 1;
5821 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
5823 else if (unformat (i, "del"))
5827 clib_warning ("parse error '%U'", format_unformat_error, i);
5832 if (sw_if_index_set == 0)
5834 errmsg ("missing interface name or sw_if_index\n");
5838 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
5840 mp->sw_if_index = ntohl (sw_if_index);
5841 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
5842 mp->is_add = is_add;
5851 api_ip_neighbor_add_del (vat_main_t * vam)
5853 unformat_input_t *i = vam->input;
5854 vl_api_ip_neighbor_add_del_t *mp;
5857 u8 sw_if_index_set = 0;
5863 u8 v4_address_set = 0;
5864 u8 v6_address_set = 0;
5865 ip4_address_t v4address;
5866 ip6_address_t v6address;
5868 memset (mac_address, 0, sizeof (mac_address));
5870 /* Parse args required to build the message */
5871 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5873 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5877 else if (unformat (i, "del"))
5879 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5880 sw_if_index_set = 1;
5881 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5882 sw_if_index_set = 1;
5883 else if (unformat (i, "is_static"))
5885 else if (unformat (i, "vrf %d", &vrf_id))
5887 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
5889 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
5893 clib_warning ("parse error '%U'", format_unformat_error, i);
5898 if (sw_if_index_set == 0)
5900 errmsg ("missing interface name or sw_if_index\n");
5903 if (v4_address_set && v6_address_set)
5905 errmsg ("both v4 and v6 addresses set\n");
5908 if (!v4_address_set && !v6_address_set)
5910 errmsg ("no address set\n");
5914 /* Construct the API message */
5915 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
5917 mp->sw_if_index = ntohl (sw_if_index);
5918 mp->is_add = is_add;
5919 mp->vrf_id = ntohl (vrf_id);
5920 mp->is_static = is_static;
5922 clib_memcpy (mp->mac_address, mac_address, 6);
5926 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
5930 /* mp->is_ipv6 = 0; via memset in M macro above */
5931 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
5937 /* Wait for a reply, return good/bad news */
5945 api_reset_vrf (vat_main_t * vam)
5947 unformat_input_t *i = vam->input;
5948 vl_api_reset_vrf_t *mp;
5954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5956 if (unformat (i, "vrf %d", &vrf_id))
5958 else if (unformat (i, "ipv6"))
5962 clib_warning ("parse error '%U'", format_unformat_error, i);
5967 if (vrf_id_set == 0)
5969 errmsg ("missing vrf id\n");
5973 M (RESET_VRF, reset_vrf);
5975 mp->vrf_id = ntohl (vrf_id);
5976 mp->is_ipv6 = is_ipv6;
5985 api_create_vlan_subif (vat_main_t * vam)
5987 unformat_input_t *i = vam->input;
5988 vl_api_create_vlan_subif_t *mp;
5991 u8 sw_if_index_set = 0;
5995 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5997 if (unformat (i, "sw_if_index %d", &sw_if_index))
5998 sw_if_index_set = 1;
5999 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6000 sw_if_index_set = 1;
6001 else if (unformat (i, "vlan %d", &vlan_id))
6005 clib_warning ("parse error '%U'", format_unformat_error, i);
6010 if (sw_if_index_set == 0)
6012 errmsg ("missing interface name or sw_if_index\n");
6016 if (vlan_id_set == 0)
6018 errmsg ("missing vlan_id\n");
6021 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6023 mp->sw_if_index = ntohl (sw_if_index);
6024 mp->vlan_id = ntohl (vlan_id);
6032 #define foreach_create_subif_bit \
6039 _(outer_vlan_id_any) \
6040 _(inner_vlan_id_any)
6043 api_create_subif (vat_main_t * vam)
6045 unformat_input_t *i = vam->input;
6046 vl_api_create_subif_t *mp;
6049 u8 sw_if_index_set = 0;
6056 u32 exact_match = 0;
6057 u32 default_sub = 0;
6058 u32 outer_vlan_id_any = 0;
6059 u32 inner_vlan_id_any = 0;
6061 u16 outer_vlan_id = 0;
6062 u16 inner_vlan_id = 0;
6064 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6066 if (unformat (i, "sw_if_index %d", &sw_if_index))
6067 sw_if_index_set = 1;
6068 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6069 sw_if_index_set = 1;
6070 else if (unformat (i, "sub_id %d", &sub_id))
6072 else if (unformat (i, "outer_vlan_id %d", &tmp))
6073 outer_vlan_id = tmp;
6074 else if (unformat (i, "inner_vlan_id %d", &tmp))
6075 inner_vlan_id = tmp;
6077 #define _(a) else if (unformat (i, #a)) a = 1 ;
6078 foreach_create_subif_bit
6082 clib_warning ("parse error '%U'", format_unformat_error, i);
6087 if (sw_if_index_set == 0)
6089 errmsg ("missing interface name or sw_if_index\n");
6093 if (sub_id_set == 0)
6095 errmsg ("missing sub_id\n");
6098 M (CREATE_SUBIF, create_subif);
6100 mp->sw_if_index = ntohl (sw_if_index);
6101 mp->sub_id = ntohl (sub_id);
6103 #define _(a) mp->a = a;
6104 foreach_create_subif_bit;
6107 mp->outer_vlan_id = ntohs (outer_vlan_id);
6108 mp->inner_vlan_id = ntohs (inner_vlan_id);
6117 api_oam_add_del (vat_main_t * vam)
6119 unformat_input_t *i = vam->input;
6120 vl_api_oam_add_del_t *mp;
6124 ip4_address_t src, dst;
6128 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6130 if (unformat (i, "vrf %d", &vrf_id))
6132 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6134 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6136 else if (unformat (i, "del"))
6140 clib_warning ("parse error '%U'", format_unformat_error, i);
6147 errmsg ("missing src addr\n");
6153 errmsg ("missing dst addr\n");
6157 M (OAM_ADD_DEL, oam_add_del);
6159 mp->vrf_id = ntohl (vrf_id);
6160 mp->is_add = is_add;
6161 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6162 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6171 api_reset_fib (vat_main_t * vam)
6173 unformat_input_t *i = vam->input;
6174 vl_api_reset_fib_t *mp;
6180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6182 if (unformat (i, "vrf %d", &vrf_id))
6184 else if (unformat (i, "ipv6"))
6188 clib_warning ("parse error '%U'", format_unformat_error, i);
6193 if (vrf_id_set == 0)
6195 errmsg ("missing vrf id\n");
6199 M (RESET_FIB, reset_fib);
6201 mp->vrf_id = ntohl (vrf_id);
6202 mp->is_ipv6 = is_ipv6;
6211 api_dhcp_proxy_config (vat_main_t * vam)
6213 unformat_input_t *i = vam->input;
6214 vl_api_dhcp_proxy_config_t *mp;
6219 u8 v4_address_set = 0;
6220 u8 v6_address_set = 0;
6221 ip4_address_t v4address;
6222 ip6_address_t v6address;
6223 u8 v4_src_address_set = 0;
6224 u8 v6_src_address_set = 0;
6225 ip4_address_t v4srcaddress;
6226 ip6_address_t v6srcaddress;
6228 /* Parse args required to build the message */
6229 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6231 if (unformat (i, "del"))
6233 else if (unformat (i, "vrf %d", &vrf_id))
6235 else if (unformat (i, "insert-cid %d", &insert_cid))
6237 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6239 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6241 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6242 v4_src_address_set = 1;
6243 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6244 v6_src_address_set = 1;
6249 if (v4_address_set && v6_address_set)
6251 errmsg ("both v4 and v6 server addresses set\n");
6254 if (!v4_address_set && !v6_address_set)
6256 errmsg ("no server addresses set\n");
6260 if (v4_src_address_set && v6_src_address_set)
6262 errmsg ("both v4 and v6 src addresses set\n");
6265 if (!v4_src_address_set && !v6_src_address_set)
6267 errmsg ("no src addresses set\n");
6271 if (!(v4_src_address_set && v4_address_set) &&
6272 !(v6_src_address_set && v6_address_set))
6274 errmsg ("no matching server and src addresses set\n");
6278 /* Construct the API message */
6279 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
6281 mp->insert_circuit_id = insert_cid;
6282 mp->is_add = is_add;
6283 mp->vrf_id = ntohl (vrf_id);
6287 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6288 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6292 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6293 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6299 /* Wait for a reply, return good/bad news */
6306 api_dhcp_proxy_config_2 (vat_main_t * vam)
6308 unformat_input_t *i = vam->input;
6309 vl_api_dhcp_proxy_config_2_t *mp;
6312 u32 server_vrf_id = 0;
6315 u8 v4_address_set = 0;
6316 u8 v6_address_set = 0;
6317 ip4_address_t v4address;
6318 ip6_address_t v6address;
6319 u8 v4_src_address_set = 0;
6320 u8 v6_src_address_set = 0;
6321 ip4_address_t v4srcaddress;
6322 ip6_address_t v6srcaddress;
6324 /* Parse args required to build the message */
6325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6327 if (unformat (i, "del"))
6329 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
6331 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
6333 else if (unformat (i, "insert-cid %d", &insert_cid))
6335 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
6337 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
6339 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
6340 v4_src_address_set = 1;
6341 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
6342 v6_src_address_set = 1;
6347 if (v4_address_set && v6_address_set)
6349 errmsg ("both v4 and v6 server addresses set\n");
6352 if (!v4_address_set && !v6_address_set)
6354 errmsg ("no server addresses set\n");
6358 if (v4_src_address_set && v6_src_address_set)
6360 errmsg ("both v4 and v6 src addresses set\n");
6363 if (!v4_src_address_set && !v6_src_address_set)
6365 errmsg ("no src addresses set\n");
6369 if (!(v4_src_address_set && v4_address_set) &&
6370 !(v6_src_address_set && v6_address_set))
6372 errmsg ("no matching server and src addresses set\n");
6376 /* Construct the API message */
6377 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
6379 mp->insert_circuit_id = insert_cid;
6380 mp->is_add = is_add;
6381 mp->rx_vrf_id = ntohl (rx_vrf_id);
6382 mp->server_vrf_id = ntohl (server_vrf_id);
6386 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
6387 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
6391 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
6392 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
6398 /* Wait for a reply, return good/bad news */
6405 api_dhcp_proxy_set_vss (vat_main_t * vam)
6407 unformat_input_t *i = vam->input;
6408 vl_api_dhcp_proxy_set_vss_t *mp;
6419 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6421 if (unformat (i, "tbl_id %d", &tbl_id))
6423 if (unformat (i, "fib_id %d", &fib_id))
6425 if (unformat (i, "oui %d", &oui))
6427 else if (unformat (i, "ipv6"))
6429 else if (unformat (i, "del"))
6433 clib_warning ("parse error '%U'", format_unformat_error, i);
6438 if (tbl_id_set == 0)
6440 errmsg ("missing tbl id\n");
6444 if (fib_id_set == 0)
6446 errmsg ("missing fib id\n");
6451 errmsg ("missing oui\n");
6455 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
6456 mp->tbl_id = ntohl (tbl_id);
6457 mp->fib_id = ntohl (fib_id);
6458 mp->oui = ntohl (oui);
6459 mp->is_ipv6 = is_ipv6;
6460 mp->is_add = is_add;
6469 api_dhcp_client_config (vat_main_t * vam)
6471 unformat_input_t *i = vam->input;
6472 vl_api_dhcp_client_config_t *mp;
6475 u8 sw_if_index_set = 0;
6478 u8 disable_event = 0;
6480 /* Parse args required to build the message */
6481 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6483 if (unformat (i, "del"))
6485 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6486 sw_if_index_set = 1;
6487 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6488 sw_if_index_set = 1;
6489 else if (unformat (i, "hostname %s", &hostname))
6491 else if (unformat (i, "disable_event"))
6497 if (sw_if_index_set == 0)
6499 errmsg ("missing interface name or sw_if_index\n");
6503 if (vec_len (hostname) > 63)
6505 errmsg ("hostname too long\n");
6507 vec_add1 (hostname, 0);
6509 /* Construct the API message */
6510 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
6512 mp->sw_if_index = ntohl (sw_if_index);
6513 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
6514 vec_free (hostname);
6515 mp->is_add = is_add;
6516 mp->want_dhcp_event = disable_event ? 0 : 1;
6517 mp->pid = getpid ();
6522 /* Wait for a reply, return good/bad news */
6529 api_set_ip_flow_hash (vat_main_t * vam)
6531 unformat_input_t *i = vam->input;
6532 vl_api_set_ip_flow_hash_t *mp;
6544 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6546 if (unformat (i, "vrf %d", &vrf_id))
6548 else if (unformat (i, "ipv6"))
6550 else if (unformat (i, "src"))
6552 else if (unformat (i, "dst"))
6554 else if (unformat (i, "sport"))
6556 else if (unformat (i, "dport"))
6558 else if (unformat (i, "proto"))
6560 else if (unformat (i, "reverse"))
6565 clib_warning ("parse error '%U'", format_unformat_error, i);
6570 if (vrf_id_set == 0)
6572 errmsg ("missing vrf id\n");
6576 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
6582 mp->reverse = reverse;
6583 mp->vrf_id = ntohl (vrf_id);
6584 mp->is_ipv6 = is_ipv6;
6593 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
6595 unformat_input_t *i = vam->input;
6596 vl_api_sw_interface_ip6_enable_disable_t *mp;
6599 u8 sw_if_index_set = 0;
6602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6604 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6605 sw_if_index_set = 1;
6606 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6607 sw_if_index_set = 1;
6608 else if (unformat (i, "enable"))
6610 else if (unformat (i, "disable"))
6614 clib_warning ("parse error '%U'", format_unformat_error, i);
6619 if (sw_if_index_set == 0)
6621 errmsg ("missing interface name or sw_if_index\n");
6625 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
6627 mp->sw_if_index = ntohl (sw_if_index);
6628 mp->enable = enable;
6637 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
6639 unformat_input_t *i = vam->input;
6640 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
6643 u8 sw_if_index_set = 0;
6644 u32 address_length = 0;
6645 u8 v6_address_set = 0;
6646 ip6_address_t v6address;
6648 /* Parse args required to build the message */
6649 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6651 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6652 sw_if_index_set = 1;
6653 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6654 sw_if_index_set = 1;
6655 else if (unformat (i, "%U/%d",
6656 unformat_ip6_address, &v6address, &address_length))
6662 if (sw_if_index_set == 0)
6664 errmsg ("missing interface name or sw_if_index\n");
6667 if (!v6_address_set)
6669 errmsg ("no address set\n");
6673 /* Construct the API message */
6674 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
6675 sw_interface_ip6_set_link_local_address);
6677 mp->sw_if_index = ntohl (sw_if_index);
6678 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6679 mp->address_length = address_length;
6684 /* Wait for a reply, return good/bad news */
6693 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
6695 unformat_input_t *i = vam->input;
6696 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
6699 u8 sw_if_index_set = 0;
6700 u32 address_length = 0;
6701 u8 v6_address_set = 0;
6702 ip6_address_t v6address;
6704 u8 no_advertise = 0;
6706 u8 no_autoconfig = 0;
6709 u32 val_lifetime = 0;
6710 u32 pref_lifetime = 0;
6712 /* Parse args required to build the message */
6713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6715 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6716 sw_if_index_set = 1;
6717 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6718 sw_if_index_set = 1;
6719 else if (unformat (i, "%U/%d",
6720 unformat_ip6_address, &v6address, &address_length))
6722 else if (unformat (i, "val_life %d", &val_lifetime))
6724 else if (unformat (i, "pref_life %d", &pref_lifetime))
6726 else if (unformat (i, "def"))
6728 else if (unformat (i, "noadv"))
6730 else if (unformat (i, "offl"))
6732 else if (unformat (i, "noauto"))
6734 else if (unformat (i, "nolink"))
6736 else if (unformat (i, "isno"))
6740 clib_warning ("parse error '%U'", format_unformat_error, i);
6745 if (sw_if_index_set == 0)
6747 errmsg ("missing interface name or sw_if_index\n");
6750 if (!v6_address_set)
6752 errmsg ("no address set\n");
6756 /* Construct the API message */
6757 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
6759 mp->sw_if_index = ntohl (sw_if_index);
6760 clib_memcpy (mp->address, &v6address, sizeof (v6address));
6761 mp->address_length = address_length;
6762 mp->use_default = use_default;
6763 mp->no_advertise = no_advertise;
6764 mp->off_link = off_link;
6765 mp->no_autoconfig = no_autoconfig;
6766 mp->no_onlink = no_onlink;
6768 mp->val_lifetime = ntohl (val_lifetime);
6769 mp->pref_lifetime = ntohl (pref_lifetime);
6774 /* Wait for a reply, return good/bad news */
6782 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
6784 unformat_input_t *i = vam->input;
6785 vl_api_sw_interface_ip6nd_ra_config_t *mp;
6788 u8 sw_if_index_set = 0;
6793 u8 send_unicast = 0;
6796 u8 default_router = 0;
6797 u32 max_interval = 0;
6798 u32 min_interval = 0;
6800 u32 initial_count = 0;
6801 u32 initial_interval = 0;
6804 /* Parse args required to build the message */
6805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6807 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6808 sw_if_index_set = 1;
6809 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6810 sw_if_index_set = 1;
6811 else if (unformat (i, "maxint %d", &max_interval))
6813 else if (unformat (i, "minint %d", &min_interval))
6815 else if (unformat (i, "life %d", &lifetime))
6817 else if (unformat (i, "count %d", &initial_count))
6819 else if (unformat (i, "interval %d", &initial_interval))
6821 else if (unformat (i, "suppress") || unformat (i, "surpress"))
6823 else if (unformat (i, "managed"))
6825 else if (unformat (i, "other"))
6827 else if (unformat (i, "ll"))
6829 else if (unformat (i, "send"))
6831 else if (unformat (i, "cease"))
6833 else if (unformat (i, "isno"))
6835 else if (unformat (i, "def"))
6839 clib_warning ("parse error '%U'", format_unformat_error, i);
6844 if (sw_if_index_set == 0)
6846 errmsg ("missing interface name or sw_if_index\n");
6850 /* Construct the API message */
6851 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
6853 mp->sw_if_index = ntohl (sw_if_index);
6854 mp->max_interval = ntohl (max_interval);
6855 mp->min_interval = ntohl (min_interval);
6856 mp->lifetime = ntohl (lifetime);
6857 mp->initial_count = ntohl (initial_count);
6858 mp->initial_interval = ntohl (initial_interval);
6859 mp->suppress = suppress;
6860 mp->managed = managed;
6862 mp->ll_option = ll_option;
6863 mp->send_unicast = send_unicast;
6866 mp->default_router = default_router;
6871 /* Wait for a reply, return good/bad news */
6879 api_set_arp_neighbor_limit (vat_main_t * vam)
6881 unformat_input_t *i = vam->input;
6882 vl_api_set_arp_neighbor_limit_t *mp;
6888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6890 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
6892 else if (unformat (i, "ipv6"))
6896 clib_warning ("parse error '%U'", format_unformat_error, i);
6903 errmsg ("missing limit value\n");
6907 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
6909 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
6910 mp->is_ipv6 = is_ipv6;
6919 api_l2_patch_add_del (vat_main_t * vam)
6921 unformat_input_t *i = vam->input;
6922 vl_api_l2_patch_add_del_t *mp;
6925 u8 rx_sw_if_index_set = 0;
6927 u8 tx_sw_if_index_set = 0;
6930 /* Parse args required to build the message */
6931 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6933 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
6934 rx_sw_if_index_set = 1;
6935 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6936 tx_sw_if_index_set = 1;
6937 else if (unformat (i, "rx"))
6939 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6941 if (unformat (i, "%U", unformat_sw_if_index, vam,
6943 rx_sw_if_index_set = 1;
6948 else if (unformat (i, "tx"))
6950 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6952 if (unformat (i, "%U", unformat_sw_if_index, vam,
6954 tx_sw_if_index_set = 1;
6959 else if (unformat (i, "del"))
6965 if (rx_sw_if_index_set == 0)
6967 errmsg ("missing rx interface name or rx_sw_if_index\n");
6971 if (tx_sw_if_index_set == 0)
6973 errmsg ("missing tx interface name or tx_sw_if_index\n");
6977 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
6979 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
6980 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6981 mp->is_add = is_add;
6990 api_trace_profile_add (vat_main_t * vam)
6992 unformat_input_t *input = vam->input;
6993 vl_api_trace_profile_add_t *mp;
6996 u32 trace_option_elts = 0;
6997 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
6998 int has_pow_option = 0;
6999 int has_ppc_option = 0;
7001 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7003 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
7004 "trace-tsp %d node-id 0x%x app-data 0x%x",
7005 &id, &trace_type, &trace_option_elts, &trace_tsp,
7006 &node_id, &app_data))
7008 else if (unformat (input, "pow"))
7010 else if (unformat (input, "ppc encap"))
7011 has_ppc_option = PPC_ENCAP;
7012 else if (unformat (input, "ppc decap"))
7013 has_ppc_option = PPC_DECAP;
7014 else if (unformat (input, "ppc none"))
7015 has_ppc_option = PPC_NONE;
7019 M (TRACE_PROFILE_ADD, trace_profile_add);
7020 mp->id = htons (id);
7021 mp->trace_type = trace_type;
7022 mp->trace_num_elt = trace_option_elts;
7023 mp->trace_ppc = has_ppc_option;
7024 mp->trace_app_data = htonl (app_data);
7025 mp->pow_enable = has_pow_option;
7026 mp->trace_tsp = trace_tsp;
7027 mp->node_id = htonl (node_id);
7037 api_trace_profile_apply (vat_main_t * vam)
7039 unformat_input_t *input = vam->input;
7040 vl_api_trace_profile_apply_t *mp;
7043 u32 mask_width = ~0;
7050 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7052 if (unformat (input, "%U/%d", unformat_ip6_address, &addr, &mask_width))
7054 else if (unformat (input, "id %d", &id))
7056 else if (unformat (input, "vrf-id %d", &vrf_id))
7058 else if (unformat (input, "add"))
7060 else if (unformat (input, "pop"))
7062 else if (unformat (input, "none"))
7068 if ((is_add + is_pop + is_none) != 1)
7070 errmsg ("One of (add, pop, none) required");
7073 if (mask_width == ~0)
7075 errmsg ("<address>/<mask-width> required");
7078 M (TRACE_PROFILE_APPLY, trace_profile_apply);
7079 clib_memcpy (mp->dest_ipv6, &addr, sizeof (mp->dest_ipv6));
7080 mp->id = htons (id);
7081 mp->prefix_length = htonl (mask_width);
7082 mp->vrf_id = htonl (vrf_id);
7084 mp->trace_op = IOAM_HBYH_ADD;
7086 mp->trace_op = IOAM_HBYH_POP;
7088 mp->trace_op = IOAM_HBYH_MOD;
7102 api_trace_profile_del (vat_main_t * vam)
7104 vl_api_trace_profile_del_t *mp;
7107 M (TRACE_PROFILE_DEL, trace_profile_del);
7114 api_sr_tunnel_add_del (vat_main_t * vam)
7116 unformat_input_t *i = vam->input;
7117 vl_api_sr_tunnel_add_del_t *mp;
7121 ip6_address_t src_address;
7122 int src_address_set = 0;
7123 ip6_address_t dst_address;
7125 int dst_address_set = 0;
7127 u32 rx_table_id = 0;
7128 u32 tx_table_id = 0;
7129 ip6_address_t *segments = 0;
7130 ip6_address_t *this_seg;
7131 ip6_address_t *tags = 0;
7132 ip6_address_t *this_tag;
7133 ip6_address_t next_address, tag;
7135 u8 *policy_name = 0;
7137 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7139 if (unformat (i, "del"))
7141 else if (unformat (i, "name %s", &name))
7143 else if (unformat (i, "policy %s", &policy_name))
7145 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7147 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7149 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7150 src_address_set = 1;
7151 else if (unformat (i, "dst %U/%d",
7152 unformat_ip6_address, &dst_address, &dst_mask_width))
7153 dst_address_set = 1;
7154 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7156 vec_add2 (segments, this_seg, 1);
7157 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7158 sizeof (*this_seg));
7160 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7162 vec_add2 (tags, this_tag, 1);
7163 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7165 else if (unformat (i, "clean"))
7166 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7167 else if (unformat (i, "protected"))
7168 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7169 else if (unformat (i, "InPE %d", &pl_index))
7171 if (pl_index <= 0 || pl_index > 4)
7173 pl_index_range_error:
7174 errmsg ("pl index %d out of range\n", pl_index);
7178 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7180 else if (unformat (i, "EgPE %d", &pl_index))
7182 if (pl_index <= 0 || pl_index > 4)
7183 goto pl_index_range_error;
7185 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7187 else if (unformat (i, "OrgSrc %d", &pl_index))
7189 if (pl_index <= 0 || pl_index > 4)
7190 goto pl_index_range_error;
7192 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7198 if (!src_address_set)
7200 errmsg ("src address required\n");
7204 if (!dst_address_set)
7206 errmsg ("dst address required\n");
7212 errmsg ("at least one sr segment required\n");
7216 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7217 vec_len (segments) * sizeof (ip6_address_t)
7218 + vec_len (tags) * sizeof (ip6_address_t));
7220 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7221 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7222 mp->dst_mask_width = dst_mask_width;
7223 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7224 mp->n_segments = vec_len (segments);
7225 mp->n_tags = vec_len (tags);
7226 mp->is_add = is_del == 0;
7227 clib_memcpy (mp->segs_and_tags, segments,
7228 vec_len (segments) * sizeof (ip6_address_t));
7229 clib_memcpy (mp->segs_and_tags +
7230 vec_len (segments) * sizeof (ip6_address_t), tags,
7231 vec_len (tags) * sizeof (ip6_address_t));
7233 mp->outer_vrf_id = ntohl (rx_table_id);
7234 mp->inner_vrf_id = ntohl (tx_table_id);
7235 memcpy (mp->name, name, vec_len (name));
7236 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7238 vec_free (segments);
7247 api_sr_policy_add_del (vat_main_t * vam)
7249 unformat_input_t *input = vam->input;
7250 vl_api_sr_policy_add_del_t *mp;
7254 u8 *tunnel_name = 0;
7255 u8 **tunnel_names = 0;
7260 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7261 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7265 if (unformat (input, "del"))
7267 else if (unformat (input, "name %s", &name))
7269 else if (unformat (input, "tunnel %s", &tunnel_name))
7273 vec_add1 (tunnel_names, tunnel_name);
7275 - length = #bytes to store in serial vector
7276 - +1 = byte to store that length
7278 tunnel_names_length += (vec_len (tunnel_name) + 1);
7289 errmsg ("policy name required\n");
7293 if ((!tunnel_set) && (!is_del))
7295 errmsg ("tunnel name required\n");
7299 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7303 mp->is_add = !is_del;
7305 memcpy (mp->name, name, vec_len (name));
7306 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7307 u8 *serial_orig = 0;
7308 vec_validate (serial_orig, tunnel_names_length);
7309 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7310 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
7312 for (j = 0; j < vec_len (tunnel_names); j++)
7314 tun_name_len = vec_len (tunnel_names[j]);
7315 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
7316 serial_orig += 1; // Move along one byte to store the actual tunnel name
7317 memcpy (serial_orig, tunnel_names[j], tun_name_len);
7318 serial_orig += tun_name_len; // Advance past the copy
7320 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
7322 vec_free (tunnel_names);
7323 vec_free (tunnel_name);
7331 api_sr_multicast_map_add_del (vat_main_t * vam)
7333 unformat_input_t *input = vam->input;
7334 vl_api_sr_multicast_map_add_del_t *mp;
7337 ip6_address_t multicast_address;
7338 u8 *policy_name = 0;
7339 int multicast_address_set = 0;
7341 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7343 if (unformat (input, "del"))
7347 (input, "address %U", unformat_ip6_address, &multicast_address))
7348 multicast_address_set = 1;
7349 else if (unformat (input, "sr-policy %s", &policy_name))
7355 if (!is_del && !policy_name)
7357 errmsg ("sr-policy name required\n");
7362 if (!multicast_address_set)
7364 errmsg ("address required\n");
7368 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
7370 mp->is_add = !is_del;
7371 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7372 clib_memcpy (mp->multicast_address, &multicast_address,
7373 sizeof (mp->multicast_address));
7376 vec_free (policy_name);
7384 #define foreach_ip4_proto_field \
7395 unformat_ip4_mask (unformat_input_t * input, va_list * args)
7397 u8 **maskp = va_arg (*args, u8 **);
7399 u8 found_something = 0;
7402 #define _(a) u8 a=0;
7403 foreach_ip4_proto_field;
7409 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7411 if (unformat (input, "version"))
7413 else if (unformat (input, "hdr_length"))
7415 else if (unformat (input, "src"))
7417 else if (unformat (input, "dst"))
7419 else if (unformat (input, "proto"))
7422 #define _(a) else if (unformat (input, #a)) a=1;
7423 foreach_ip4_proto_field
7429 #define _(a) found_something += a;
7430 foreach_ip4_proto_field;
7433 if (found_something == 0)
7436 vec_validate (mask, sizeof (*ip) - 1);
7438 ip = (ip4_header_t *) mask;
7440 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7441 foreach_ip4_proto_field;
7444 ip->ip_version_and_header_length = 0;
7447 ip->ip_version_and_header_length |= 0xF0;
7450 ip->ip_version_and_header_length |= 0x0F;
7456 #define foreach_ip6_proto_field \
7464 unformat_ip6_mask (unformat_input_t * input, va_list * args)
7466 u8 **maskp = va_arg (*args, u8 **);
7468 u8 found_something = 0;
7470 u32 ip_version_traffic_class_and_flow_label;
7472 #define _(a) u8 a=0;
7473 foreach_ip6_proto_field;
7476 u8 traffic_class = 0;
7479 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7481 if (unformat (input, "version"))
7483 else if (unformat (input, "traffic-class"))
7485 else if (unformat (input, "flow-label"))
7487 else if (unformat (input, "src"))
7489 else if (unformat (input, "dst"))
7491 else if (unformat (input, "proto"))
7494 #define _(a) else if (unformat (input, #a)) a=1;
7495 foreach_ip6_proto_field
7501 #define _(a) found_something += a;
7502 foreach_ip6_proto_field;
7505 if (found_something == 0)
7508 vec_validate (mask, sizeof (*ip) - 1);
7510 ip = (ip6_header_t *) mask;
7512 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
7513 foreach_ip6_proto_field;
7516 ip_version_traffic_class_and_flow_label = 0;
7519 ip_version_traffic_class_and_flow_label |= 0xF0000000;
7522 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
7525 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
7527 ip->ip_version_traffic_class_and_flow_label =
7528 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7535 unformat_l3_mask (unformat_input_t * input, va_list * args)
7537 u8 **maskp = va_arg (*args, u8 **);
7539 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7541 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
7543 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
7552 unformat_l2_mask (unformat_input_t * input, va_list * args)
7554 u8 **maskp = va_arg (*args, u8 **);
7569 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7571 if (unformat (input, "src"))
7573 else if (unformat (input, "dst"))
7575 else if (unformat (input, "proto"))
7577 else if (unformat (input, "tag1"))
7579 else if (unformat (input, "tag2"))
7581 else if (unformat (input, "ignore-tag1"))
7583 else if (unformat (input, "ignore-tag2"))
7585 else if (unformat (input, "cos1"))
7587 else if (unformat (input, "cos2"))
7589 else if (unformat (input, "dot1q"))
7591 else if (unformat (input, "dot1ad"))
7596 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
7597 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7600 if (tag1 || ignore_tag1 || cos1 || dot1q)
7602 if (tag2 || ignore_tag2 || cos2 || dot1ad)
7605 vec_validate (mask, len - 1);
7608 memset (mask, 0xff, 6);
7611 memset (mask + 6, 0xff, 6);
7615 /* inner vlan tag */
7624 mask[21] = mask[20] = 0xff;
7645 mask[16] = mask[17] = 0xff;
7655 mask[12] = mask[13] = 0xff;
7662 unformat_classify_mask (unformat_input_t * input, va_list * args)
7664 u8 **maskp = va_arg (*args, u8 **);
7665 u32 *skipp = va_arg (*args, u32 *);
7666 u32 *matchp = va_arg (*args, u32 *);
7673 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7675 if (unformat (input, "hex %U", unformat_hex_string, &mask))
7677 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
7679 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
7685 if (mask || l2 || l3)
7689 /* "With a free Ethernet header in every package" */
7691 vec_validate (l2, 13);
7693 vec_append (mask, l3);
7697 /* Scan forward looking for the first significant mask octet */
7698 for (i = 0; i < vec_len (mask); i++)
7702 /* compute (skip, match) params */
7703 *skipp = i / sizeof (u32x4);
7704 vec_delete (mask, *skipp * sizeof (u32x4), 0);
7706 /* Pad mask to an even multiple of the vector size */
7707 while (vec_len (mask) % sizeof (u32x4))
7710 match = vec_len (mask) / sizeof (u32x4);
7712 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
7714 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
7715 if (*tmp || *(tmp + 1))
7720 clib_warning ("BUG: match 0");
7722 _vec_len (mask) = match * sizeof (u32x4);
7733 #define foreach_l2_next \
7735 _(ethernet, ETHERNET_INPUT) \
7740 unformat_l2_next_index (unformat_input_t * input, va_list * args)
7742 u32 *miss_next_indexp = va_arg (*args, u32 *);
7747 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
7751 if (unformat (input, "%d", &tmp))
7760 *miss_next_indexp = next_index;
7764 #define foreach_ip_next \
7771 unformat_ip_next_index (unformat_input_t * input, va_list * args)
7773 u32 *miss_next_indexp = va_arg (*args, u32 *);
7778 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
7782 if (unformat (input, "%d", &tmp))
7791 *miss_next_indexp = next_index;
7795 #define foreach_acl_next \
7799 unformat_acl_next_index (unformat_input_t * input, va_list * args)
7801 u32 *miss_next_indexp = va_arg (*args, u32 *);
7806 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
7810 if (unformat (input, "permit"))
7815 else if (unformat (input, "%d", &tmp))
7824 *miss_next_indexp = next_index;
7829 unformat_policer_precolor (unformat_input_t * input, va_list * args)
7831 u32 *r = va_arg (*args, u32 *);
7833 if (unformat (input, "conform-color"))
7834 *r = POLICE_CONFORM;
7835 else if (unformat (input, "exceed-color"))
7844 api_classify_add_del_table (vat_main_t * vam)
7846 unformat_input_t *i = vam->input;
7847 vl_api_classify_add_del_table_t *mp;
7853 u32 table_index = ~0;
7854 u32 next_table_index = ~0;
7855 u32 miss_next_index = ~0;
7856 u32 memory_size = 32 << 20;
7860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7862 if (unformat (i, "del"))
7864 else if (unformat (i, "buckets %d", &nbuckets))
7866 else if (unformat (i, "memory_size %d", &memory_size))
7868 else if (unformat (i, "skip %d", &skip))
7870 else if (unformat (i, "match %d", &match))
7872 else if (unformat (i, "table %d", &table_index))
7874 else if (unformat (i, "mask %U", unformat_classify_mask,
7875 &mask, &skip, &match))
7877 else if (unformat (i, "next-table %d", &next_table_index))
7879 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
7882 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
7885 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
7892 if (is_add && mask == 0)
7894 errmsg ("Mask required\n");
7898 if (is_add && skip == ~0)
7900 errmsg ("skip count required\n");
7904 if (is_add && match == ~0)
7906 errmsg ("match count required\n");
7910 if (!is_add && table_index == ~0)
7912 errmsg ("table index required for delete\n");
7916 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
7918 mp->is_add = is_add;
7919 mp->table_index = ntohl (table_index);
7920 mp->nbuckets = ntohl (nbuckets);
7921 mp->memory_size = ntohl (memory_size);
7922 mp->skip_n_vectors = ntohl (skip);
7923 mp->match_n_vectors = ntohl (match);
7924 mp->next_table_index = ntohl (next_table_index);
7925 mp->miss_next_index = ntohl (miss_next_index);
7926 clib_memcpy (mp->mask, mask, vec_len (mask));
7936 unformat_ip4_match (unformat_input_t * input, va_list * args)
7938 u8 **matchp = va_arg (*args, u8 **);
7945 int src = 0, dst = 0;
7946 ip4_address_t src_val, dst_val;
7953 int fragment_id = 0;
7954 u32 fragment_id_val;
7960 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7962 if (unformat (input, "version %d", &version_val))
7964 else if (unformat (input, "hdr_length %d", &hdr_length_val))
7966 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
7968 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
7970 else if (unformat (input, "proto %d", &proto_val))
7972 else if (unformat (input, "tos %d", &tos_val))
7974 else if (unformat (input, "length %d", &length_val))
7976 else if (unformat (input, "fragment_id %d", &fragment_id_val))
7978 else if (unformat (input, "ttl %d", &ttl_val))
7980 else if (unformat (input, "checksum %d", &checksum_val))
7986 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
7987 + ttl + checksum == 0)
7991 * Aligned because we use the real comparison functions
7993 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
7995 ip = (ip4_header_t *) match;
7997 /* These are realistically matched in practice */
7999 ip->src_address.as_u32 = src_val.as_u32;
8002 ip->dst_address.as_u32 = dst_val.as_u32;
8005 ip->protocol = proto_val;
8008 /* These are not, but they're included for completeness */
8010 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8013 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8019 ip->length = length_val;
8025 ip->checksum = checksum_val;
8032 unformat_ip6_match (unformat_input_t * input, va_list * args)
8034 u8 **matchp = va_arg (*args, u8 **);
8040 u32 traffic_class_val;
8043 int src = 0, dst = 0;
8044 ip6_address_t src_val, dst_val;
8047 int payload_length = 0;
8048 u32 payload_length_val;
8051 u32 ip_version_traffic_class_and_flow_label;
8053 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8055 if (unformat (input, "version %d", &version_val))
8057 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8059 else if (unformat (input, "flow_label %d", &flow_label_val))
8061 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8063 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8065 else if (unformat (input, "proto %d", &proto_val))
8067 else if (unformat (input, "payload_length %d", &payload_length_val))
8069 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8075 if (version + traffic_class + flow_label + src + dst + proto +
8076 payload_length + hop_limit == 0)
8080 * Aligned because we use the real comparison functions
8082 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8084 ip = (ip6_header_t *) match;
8087 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8090 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8093 ip->protocol = proto_val;
8095 ip_version_traffic_class_and_flow_label = 0;
8098 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8101 ip_version_traffic_class_and_flow_label |=
8102 (traffic_class_val & 0xFF) << 20;
8105 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8107 ip->ip_version_traffic_class_and_flow_label =
8108 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8111 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8114 ip->hop_limit = hop_limit_val;
8121 unformat_l3_match (unformat_input_t * input, va_list * args)
8123 u8 **matchp = va_arg (*args, u8 **);
8125 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8127 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8129 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
8138 unformat_vlan_tag (unformat_input_t * input, va_list * args)
8140 u8 *tagp = va_arg (*args, u8 *);
8143 if (unformat (input, "%d", &tag))
8145 tagp[0] = (tag >> 8) & 0x0F;
8146 tagp[1] = tag & 0xFF;
8154 unformat_l2_match (unformat_input_t * input, va_list * args)
8156 u8 **matchp = va_arg (*args, u8 **);
8176 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8178 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
8181 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
8183 else if (unformat (input, "proto %U",
8184 unformat_ethernet_type_host_byte_order, &proto_val))
8186 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
8188 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
8190 else if (unformat (input, "ignore-tag1"))
8192 else if (unformat (input, "ignore-tag2"))
8194 else if (unformat (input, "cos1 %d", &cos1_val))
8196 else if (unformat (input, "cos2 %d", &cos2_val))
8201 if ((src + dst + proto + tag1 + tag2 +
8202 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8205 if (tag1 || ignore_tag1 || cos1)
8207 if (tag2 || ignore_tag2 || cos2)
8210 vec_validate_aligned (match, len - 1, sizeof (u32x4));
8213 clib_memcpy (match, dst_val, 6);
8216 clib_memcpy (match + 6, src_val, 6);
8220 /* inner vlan tag */
8221 match[19] = tag2_val[1];
8222 match[18] = tag2_val[0];
8224 match[18] |= (cos2_val & 0x7) << 5;
8227 match[21] = proto_val & 0xff;
8228 match[20] = proto_val >> 8;
8232 match[15] = tag1_val[1];
8233 match[14] = tag1_val[0];
8236 match[14] |= (cos1_val & 0x7) << 5;
8242 match[15] = tag1_val[1];
8243 match[14] = tag1_val[0];
8246 match[17] = proto_val & 0xff;
8247 match[16] = proto_val >> 8;
8250 match[14] |= (cos1_val & 0x7) << 5;
8256 match[18] |= (cos2_val & 0x7) << 5;
8258 match[14] |= (cos1_val & 0x7) << 5;
8261 match[13] = proto_val & 0xff;
8262 match[12] = proto_val >> 8;
8271 unformat_classify_match (unformat_input_t * input, va_list * args)
8273 u8 **matchp = va_arg (*args, u8 **);
8274 u32 skip_n_vectors = va_arg (*args, u32);
8275 u32 match_n_vectors = va_arg (*args, u32);
8281 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8283 if (unformat (input, "hex %U", unformat_hex_string, &match))
8285 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
8287 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
8293 if (match || l2 || l3)
8297 /* "Win a free Ethernet header in every packet" */
8299 vec_validate_aligned (l2, 13, sizeof (u32x4));
8301 vec_append_aligned (match, l3, sizeof (u32x4));
8305 /* Make sure the vector is big enough even if key is all 0's */
8306 vec_validate_aligned
8307 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
8310 /* Set size, include skipped vectors */
8311 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
8322 api_classify_add_del_session (vat_main_t * vam)
8324 unformat_input_t *i = vam->input;
8325 vl_api_classify_add_del_session_t *mp;
8327 u32 table_index = ~0;
8328 u32 hit_next_index = ~0;
8329 u32 opaque_index = ~0;
8333 u32 skip_n_vectors = 0;
8334 u32 match_n_vectors = 0;
8337 * Warning: you have to supply skip_n and match_n
8338 * because the API client cant simply look at the classify
8342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8344 if (unformat (i, "del"))
8346 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
8349 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
8352 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
8355 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
8357 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
8359 else if (unformat (i, "opaque-index %d", &opaque_index))
8361 else if (unformat (i, "skip_n %d", &skip_n_vectors))
8363 else if (unformat (i, "match_n %d", &match_n_vectors))
8365 else if (unformat (i, "match %U", unformat_classify_match,
8366 &match, skip_n_vectors, match_n_vectors))
8368 else if (unformat (i, "advance %d", &advance))
8370 else if (unformat (i, "table-index %d", &table_index))
8376 if (table_index == ~0)
8378 errmsg ("Table index required\n");
8382 if (is_add && match == 0)
8384 errmsg ("Match value required\n");
8388 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
8390 mp->is_add = is_add;
8391 mp->table_index = ntohl (table_index);
8392 mp->hit_next_index = ntohl (hit_next_index);
8393 mp->opaque_index = ntohl (opaque_index);
8394 mp->advance = ntohl (advance);
8395 clib_memcpy (mp->match, match, vec_len (match));
8404 api_classify_set_interface_ip_table (vat_main_t * vam)
8406 unformat_input_t *i = vam->input;
8407 vl_api_classify_set_interface_ip_table_t *mp;
8410 int sw_if_index_set;
8411 u32 table_index = ~0;
8414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8416 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8417 sw_if_index_set = 1;
8418 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8419 sw_if_index_set = 1;
8420 else if (unformat (i, "table %d", &table_index))
8424 clib_warning ("parse error '%U'", format_unformat_error, i);
8429 if (sw_if_index_set == 0)
8431 errmsg ("missing interface name or sw_if_index\n");
8436 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
8438 mp->sw_if_index = ntohl (sw_if_index);
8439 mp->table_index = ntohl (table_index);
8440 mp->is_ipv6 = is_ipv6;
8449 api_classify_set_interface_l2_tables (vat_main_t * vam)
8451 unformat_input_t *i = vam->input;
8452 vl_api_classify_set_interface_l2_tables_t *mp;
8455 int sw_if_index_set;
8456 u32 ip4_table_index = ~0;
8457 u32 ip6_table_index = ~0;
8458 u32 other_table_index = ~0;
8460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8462 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8463 sw_if_index_set = 1;
8464 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8465 sw_if_index_set = 1;
8466 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8468 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8470 else if (unformat (i, "other-table %d", &other_table_index))
8474 clib_warning ("parse error '%U'", format_unformat_error, i);
8479 if (sw_if_index_set == 0)
8481 errmsg ("missing interface name or sw_if_index\n");
8486 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
8488 mp->sw_if_index = ntohl (sw_if_index);
8489 mp->ip4_table_index = ntohl (ip4_table_index);
8490 mp->ip6_table_index = ntohl (ip6_table_index);
8491 mp->other_table_index = ntohl (other_table_index);
8501 api_ipfix_enable (vat_main_t * vam)
8503 unformat_input_t *i = vam->input;
8504 vl_api_ipfix_enable_t *mp;
8505 ip4_address_t collector_address;
8506 u8 collector_address_set = 0;
8507 u32 collector_port = ~0;
8508 ip4_address_t src_address;
8509 u8 src_address_set = 0;
8512 u32 template_interval = ~0;
8515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8517 if (unformat (i, "collector_address %U", unformat_ip4_address,
8518 &collector_address))
8519 collector_address_set = 1;
8520 else if (unformat (i, "collector_port %d", &collector_port))
8522 else if (unformat (i, "src_address %U", unformat_ip4_address,
8524 src_address_set = 1;
8525 else if (unformat (i, "vrf_id %d", &vrf_id))
8527 else if (unformat (i, "path_mtu %d", &path_mtu))
8529 else if (unformat (i, "template_interval %d", &template_interval))
8535 if (collector_address_set == 0)
8537 errmsg ("collector_address required\n");
8541 if (src_address_set == 0)
8543 errmsg ("src_address required\n");
8547 M (IPFIX_ENABLE, ipfix_enable);
8549 memcpy (mp->collector_address, collector_address.data,
8550 sizeof (collector_address.data));
8551 mp->collector_port = htons ((u16) collector_port);
8552 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
8553 mp->vrf_id = htonl (vrf_id);
8554 mp->path_mtu = htonl (path_mtu);
8555 mp->template_interval = htonl (template_interval);
8563 api_get_node_index (vat_main_t * vam)
8565 unformat_input_t *i = vam->input;
8566 vl_api_get_node_index_t *mp;
8570 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8572 if (unformat (i, "node %s", &name))
8579 errmsg ("node name required\n");
8582 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8584 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8588 M (GET_NODE_INDEX, get_node_index);
8589 clib_memcpy (mp->node_name, name, vec_len (name));
8599 api_get_next_index (vat_main_t * vam)
8601 unformat_input_t *i = vam->input;
8602 vl_api_get_next_index_t *mp;
8604 u8 *node_name = 0, *next_node_name = 0;
8606 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8608 if (unformat (i, "node-name %s", &node_name))
8610 else if (unformat (i, "next-node-name %s", &next_node_name))
8616 errmsg ("node name required\n");
8619 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
8621 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8625 if (next_node_name == 0)
8627 errmsg ("next node name required\n");
8630 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
8632 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
8636 M (GET_NEXT_INDEX, get_next_index);
8637 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
8638 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
8639 vec_free (node_name);
8640 vec_free (next_node_name);
8649 api_add_node_next (vat_main_t * vam)
8651 unformat_input_t *i = vam->input;
8652 vl_api_add_node_next_t *mp;
8657 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8659 if (unformat (i, "node %s", &name))
8661 else if (unformat (i, "next %s", &next))
8668 errmsg ("node name required\n");
8671 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
8673 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
8678 errmsg ("next node required\n");
8681 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
8683 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
8687 M (ADD_NODE_NEXT, add_node_next);
8688 clib_memcpy (mp->node_name, name, vec_len (name));
8689 clib_memcpy (mp->next_name, next, vec_len (next));
8700 api_l2tpv3_create_tunnel (vat_main_t * vam)
8702 unformat_input_t *i = vam->input;
8703 ip6_address_t client_address, our_address;
8704 int client_address_set = 0;
8705 int our_address_set = 0;
8706 u32 local_session_id = 0;
8707 u32 remote_session_id = 0;
8708 u64 local_cookie = 0;
8709 u64 remote_cookie = 0;
8710 u8 l2_sublayer_present = 0;
8711 vl_api_l2tpv3_create_tunnel_t *mp;
8714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8716 if (unformat (i, "client_address %U", unformat_ip6_address,
8718 client_address_set = 1;
8719 else if (unformat (i, "our_address %U", unformat_ip6_address,
8721 our_address_set = 1;
8722 else if (unformat (i, "local_session_id %d", &local_session_id))
8724 else if (unformat (i, "remote_session_id %d", &remote_session_id))
8726 else if (unformat (i, "local_cookie %lld", &local_cookie))
8728 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
8730 else if (unformat (i, "l2-sublayer-present"))
8731 l2_sublayer_present = 1;
8736 if (client_address_set == 0)
8738 errmsg ("client_address required\n");
8742 if (our_address_set == 0)
8744 errmsg ("our_address required\n");
8748 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
8750 clib_memcpy (mp->client_address, client_address.as_u8,
8751 sizeof (mp->client_address));
8753 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
8755 mp->local_session_id = ntohl (local_session_id);
8756 mp->remote_session_id = ntohl (remote_session_id);
8757 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
8758 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
8759 mp->l2_sublayer_present = l2_sublayer_present;
8769 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
8771 unformat_input_t *i = vam->input;
8773 u8 sw_if_index_set = 0;
8774 u64 new_local_cookie = 0;
8775 u64 new_remote_cookie = 0;
8776 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
8779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8781 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8782 sw_if_index_set = 1;
8783 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8784 sw_if_index_set = 1;
8785 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
8787 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
8793 if (sw_if_index_set == 0)
8795 errmsg ("missing interface name or sw_if_index\n");
8799 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
8801 mp->sw_if_index = ntohl (sw_if_index);
8802 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
8803 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
8812 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
8814 unformat_input_t *i = vam->input;
8815 vl_api_l2tpv3_interface_enable_disable_t *mp;
8818 u8 sw_if_index_set = 0;
8819 u8 enable_disable = 1;
8821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8823 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8824 sw_if_index_set = 1;
8825 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8826 sw_if_index_set = 1;
8827 else if (unformat (i, "enable"))
8829 else if (unformat (i, "disable"))
8835 if (sw_if_index_set == 0)
8837 errmsg ("missing interface name or sw_if_index\n");
8841 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
8843 mp->sw_if_index = ntohl (sw_if_index);
8844 mp->enable_disable = enable_disable;
8853 api_l2tpv3_set_lookup_key (vat_main_t * vam)
8855 unformat_input_t *i = vam->input;
8856 vl_api_l2tpv3_set_lookup_key_t *mp;
8860 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8862 if (unformat (i, "lookup_v6_src"))
8863 key = L2T_LOOKUP_SRC_ADDRESS;
8864 else if (unformat (i, "lookup_v6_dst"))
8865 key = L2T_LOOKUP_DST_ADDRESS;
8866 else if (unformat (i, "lookup_session_id"))
8867 key = L2T_LOOKUP_SESSION_ID;
8872 if (key == (u8) ~ 0)
8874 errmsg ("l2tp session lookup key unset\n");
8878 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
8888 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
8889 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8891 vat_main_t *vam = &vat_main;
8893 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
8894 format_ip6_address, mp->our_address,
8895 format_ip6_address, mp->client_address,
8896 clib_net_to_host_u32 (mp->sw_if_index));
8899 " local cookies %016llx %016llx remote cookie %016llx\n",
8900 clib_net_to_host_u64 (mp->local_cookie[0]),
8901 clib_net_to_host_u64 (mp->local_cookie[1]),
8902 clib_net_to_host_u64 (mp->remote_cookie));
8904 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
8905 clib_net_to_host_u32 (mp->local_session_id),
8906 clib_net_to_host_u32 (mp->remote_session_id));
8908 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
8909 mp->l2_sublayer_present ? "preset" : "absent");
8913 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
8914 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
8916 vat_main_t *vam = &vat_main;
8917 vat_json_node_t *node = NULL;
8918 struct in6_addr addr;
8920 if (VAT_JSON_ARRAY != vam->json_tree.type)
8922 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8923 vat_json_init_array (&vam->json_tree);
8925 node = vat_json_array_add (&vam->json_tree);
8927 vat_json_init_object (node);
8929 clib_memcpy (&addr, mp->our_address, sizeof (addr));
8930 vat_json_object_add_ip6 (node, "our_address", addr);
8931 clib_memcpy (&addr, mp->client_address, sizeof (addr));
8932 vat_json_object_add_ip6 (node, "client_address", addr);
8934 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
8935 vat_json_init_array (lc);
8936 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
8937 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
8938 vat_json_object_add_uint (node, "remote_cookie",
8939 clib_net_to_host_u64 (mp->remote_cookie));
8941 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
8942 vat_json_object_add_uint (node, "local_session_id",
8943 clib_net_to_host_u32 (mp->local_session_id));
8944 vat_json_object_add_uint (node, "remote_session_id",
8945 clib_net_to_host_u32 (mp->remote_session_id));
8946 vat_json_object_add_string_copy (node, "l2_sublayer",
8947 mp->l2_sublayer_present ? (u8 *) "present"
8952 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
8954 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
8957 /* Get list of l2tpv3-tunnel interfaces */
8958 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
8961 /* Use a control ping for synchronization */
8963 vl_api_control_ping_t *mp;
8964 M (CONTROL_PING, control_ping);
8971 static void vl_api_sw_interface_tap_details_t_handler
8972 (vl_api_sw_interface_tap_details_t * mp)
8974 vat_main_t *vam = &vat_main;
8976 fformat (vam->ofp, "%-16s %d\n",
8977 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
8980 static void vl_api_sw_interface_tap_details_t_handler_json
8981 (vl_api_sw_interface_tap_details_t * mp)
8983 vat_main_t *vam = &vat_main;
8984 vat_json_node_t *node = NULL;
8986 if (VAT_JSON_ARRAY != vam->json_tree.type)
8988 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
8989 vat_json_init_array (&vam->json_tree);
8991 node = vat_json_array_add (&vam->json_tree);
8993 vat_json_init_object (node);
8994 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
8995 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
8999 api_sw_interface_tap_dump (vat_main_t * vam)
9001 vl_api_sw_interface_tap_dump_t *mp;
9004 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9005 /* Get list of tap interfaces */
9006 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9009 /* Use a control ping for synchronization */
9011 vl_api_control_ping_t *mp;
9012 M (CONTROL_PING, control_ping);
9018 static uword unformat_vxlan_decap_next
9019 (unformat_input_t * input, va_list * args)
9021 u32 *result = va_arg (*args, u32 *);
9024 if (unformat (input, "drop"))
9025 *result = VXLAN_INPUT_NEXT_DROP;
9026 else if (unformat (input, "ip4"))
9027 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
9028 else if (unformat (input, "ip6"))
9029 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
9030 else if (unformat (input, "l2"))
9031 *result = VXLAN_INPUT_NEXT_L2_INPUT;
9032 else if (unformat (input, "%d", &tmp))
9040 api_vxlan_add_del_tunnel (vat_main_t * vam)
9042 unformat_input_t *line_input = vam->input;
9043 vl_api_vxlan_add_del_tunnel_t *mp;
9045 ip4_address_t src4, dst4;
9046 ip6_address_t src6, dst6;
9048 u8 ipv4_set = 0, ipv6_set = 0;
9051 u32 encap_vrf_id = 0;
9052 u32 decap_next_index = ~0;
9055 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9057 if (unformat (line_input, "del"))
9059 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9064 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9069 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
9074 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
9079 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9081 else if (unformat (line_input, "decap-next %U",
9082 unformat_vxlan_decap_next, &decap_next_index))
9084 else if (unformat (line_input, "vni %d", &vni))
9088 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9095 errmsg ("tunnel src address not specified\n");
9100 errmsg ("tunnel dst address not specified\n");
9104 if (ipv4_set && ipv6_set)
9106 errmsg ("both IPv4 and IPv6 addresses specified");
9110 if ((vni == 0) || (vni >> 24))
9112 errmsg ("vni not specified or out of range\n");
9116 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
9120 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
9121 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
9125 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9126 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9128 mp->encap_vrf_id = ntohl (encap_vrf_id);
9129 mp->decap_next_index = ntohl (decap_next_index);
9130 mp->vni = ntohl (vni);
9131 mp->is_add = is_add;
9132 mp->is_ipv6 = ipv6_set;
9140 static void vl_api_vxlan_tunnel_details_t_handler
9141 (vl_api_vxlan_tunnel_details_t * mp)
9143 vat_main_t *vam = &vat_main;
9145 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
9146 ntohl (mp->sw_if_index),
9147 format_ip46_address, &(mp->src_address[0]),
9149 format_ip46_address, &(mp->dst_address[0]),
9151 ntohl (mp->encap_vrf_id),
9152 ntohl (mp->decap_next_index), ntohl (mp->vni));
9155 static void vl_api_vxlan_tunnel_details_t_handler_json
9156 (vl_api_vxlan_tunnel_details_t * mp)
9158 vat_main_t *vam = &vat_main;
9159 vat_json_node_t *node = NULL;
9161 struct in6_addr ip6;
9163 if (VAT_JSON_ARRAY != vam->json_tree.type)
9165 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9166 vat_json_init_array (&vam->json_tree);
9168 node = vat_json_array_add (&vam->json_tree);
9170 vat_json_init_object (node);
9171 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9174 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
9175 vat_json_object_add_ip6 (node, "src_address", ip6);
9176 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
9177 vat_json_object_add_ip6 (node, "dst_address", ip6);
9181 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
9182 vat_json_object_add_ip4 (node, "src_address", ip4);
9183 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
9184 vat_json_object_add_ip4 (node, "dst_address", ip4);
9186 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9187 vat_json_object_add_uint (node, "decap_next_index",
9188 ntohl (mp->decap_next_index));
9189 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9190 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9194 api_vxlan_tunnel_dump (vat_main_t * vam)
9196 unformat_input_t *i = vam->input;
9197 vl_api_vxlan_tunnel_dump_t *mp;
9200 u8 sw_if_index_set = 0;
9202 /* Parse args required to build the message */
9203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9205 if (unformat (i, "sw_if_index %d", &sw_if_index))
9206 sw_if_index_set = 1;
9211 if (sw_if_index_set == 0)
9216 if (!vam->json_output)
9218 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
9219 "sw_if_index", "src_address", "dst_address",
9220 "encap_vrf_id", "decap_next_index", "vni");
9223 /* Get list of vxlan-tunnel interfaces */
9224 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
9226 mp->sw_if_index = htonl (sw_if_index);
9230 /* Use a control ping for synchronization */
9232 vl_api_control_ping_t *mp;
9233 M (CONTROL_PING, control_ping);
9240 api_gre_add_del_tunnel (vat_main_t * vam)
9242 unformat_input_t *line_input = vam->input;
9243 vl_api_gre_add_del_tunnel_t *mp;
9245 ip4_address_t src4, dst4;
9249 u32 outer_fib_id = 0;
9251 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9253 if (unformat (line_input, "del"))
9255 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
9257 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
9259 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
9263 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9270 errmsg ("tunnel src address not specified\n");
9275 errmsg ("tunnel dst address not specified\n");
9280 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
9282 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
9283 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
9284 mp->outer_fib_id = ntohl (outer_fib_id);
9285 mp->is_add = is_add;
9293 static void vl_api_gre_tunnel_details_t_handler
9294 (vl_api_gre_tunnel_details_t * mp)
9296 vat_main_t *vam = &vat_main;
9298 fformat (vam->ofp, "%11d%15U%15U%14d\n",
9299 ntohl (mp->sw_if_index),
9300 format_ip4_address, &mp->src_address,
9301 format_ip4_address, &mp->dst_address, ntohl (mp->outer_fib_id));
9304 static void vl_api_gre_tunnel_details_t_handler_json
9305 (vl_api_gre_tunnel_details_t * mp)
9307 vat_main_t *vam = &vat_main;
9308 vat_json_node_t *node = NULL;
9311 if (VAT_JSON_ARRAY != vam->json_tree.type)
9313 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9314 vat_json_init_array (&vam->json_tree);
9316 node = vat_json_array_add (&vam->json_tree);
9318 vat_json_init_object (node);
9319 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9320 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
9321 vat_json_object_add_ip4 (node, "src_address", ip4);
9322 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
9323 vat_json_object_add_ip4 (node, "dst_address", ip4);
9324 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
9328 api_gre_tunnel_dump (vat_main_t * vam)
9330 unformat_input_t *i = vam->input;
9331 vl_api_gre_tunnel_dump_t *mp;
9334 u8 sw_if_index_set = 0;
9336 /* Parse args required to build the message */
9337 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9339 if (unformat (i, "sw_if_index %d", &sw_if_index))
9340 sw_if_index_set = 1;
9345 if (sw_if_index_set == 0)
9350 if (!vam->json_output)
9352 fformat (vam->ofp, "%11s%15s%15s%14s\n",
9353 "sw_if_index", "src_address", "dst_address", "outer_fib_id");
9356 /* Get list of gre-tunnel interfaces */
9357 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
9359 mp->sw_if_index = htonl (sw_if_index);
9363 /* Use a control ping for synchronization */
9365 vl_api_control_ping_t *mp;
9366 M (CONTROL_PING, control_ping);
9373 api_l2_fib_clear_table (vat_main_t * vam)
9375 // unformat_input_t * i = vam->input;
9376 vl_api_l2_fib_clear_table_t *mp;
9379 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
9388 api_l2_interface_efp_filter (vat_main_t * vam)
9390 unformat_input_t *i = vam->input;
9391 vl_api_l2_interface_efp_filter_t *mp;
9395 u8 sw_if_index_set = 0;
9397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9399 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9400 sw_if_index_set = 1;
9401 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9402 sw_if_index_set = 1;
9403 else if (unformat (i, "enable"))
9405 else if (unformat (i, "disable"))
9409 clib_warning ("parse error '%U'", format_unformat_error, i);
9414 if (sw_if_index_set == 0)
9416 errmsg ("missing sw_if_index\n");
9420 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
9422 mp->sw_if_index = ntohl (sw_if_index);
9423 mp->enable_disable = enable;
9431 #define foreach_vtr_op \
9432 _("disable", L2_VTR_DISABLED) \
9433 _("push-1", L2_VTR_PUSH_1) \
9434 _("push-2", L2_VTR_PUSH_2) \
9435 _("pop-1", L2_VTR_POP_1) \
9436 _("pop-2", L2_VTR_POP_2) \
9437 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
9438 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
9439 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
9440 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
9443 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
9445 unformat_input_t *i = vam->input;
9446 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
9449 u8 sw_if_index_set = 0;
9456 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9458 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9459 sw_if_index_set = 1;
9460 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9461 sw_if_index_set = 1;
9462 else if (unformat (i, "vtr_op %d", &vtr_op))
9464 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
9467 else if (unformat (i, "push_dot1q %d", &push_dot1q))
9469 else if (unformat (i, "tag1 %d", &tag1))
9471 else if (unformat (i, "tag2 %d", &tag2))
9475 clib_warning ("parse error '%U'", format_unformat_error, i);
9480 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
9482 errmsg ("missing vtr operation or sw_if_index\n");
9486 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
9487 mp->sw_if_index = ntohl (sw_if_index);
9488 mp->vtr_op = ntohl (vtr_op);
9489 mp->push_dot1q = ntohl (push_dot1q);
9490 mp->tag1 = ntohl (tag1);
9491 mp->tag2 = ntohl (tag2);
9500 api_create_vhost_user_if (vat_main_t * vam)
9502 unformat_input_t *i = vam->input;
9503 vl_api_create_vhost_user_if_t *mp;
9507 u8 file_name_set = 0;
9508 u32 custom_dev_instance = ~0;
9510 u8 use_custom_mac = 0;
9512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9514 if (unformat (i, "socket %s", &file_name))
9518 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9520 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
9522 else if (unformat (i, "server"))
9528 if (file_name_set == 0)
9530 errmsg ("missing socket file name\n");
9534 if (vec_len (file_name) > 255)
9536 errmsg ("socket file name too long\n");
9539 vec_add1 (file_name, 0);
9541 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
9543 mp->is_server = is_server;
9544 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9545 vec_free (file_name);
9546 if (custom_dev_instance != ~0)
9549 mp->custom_dev_instance = ntohl (custom_dev_instance);
9551 mp->use_custom_mac = use_custom_mac;
9552 clib_memcpy (mp->mac_address, hwaddr, 6);
9561 api_modify_vhost_user_if (vat_main_t * vam)
9563 unformat_input_t *i = vam->input;
9564 vl_api_modify_vhost_user_if_t *mp;
9568 u8 file_name_set = 0;
9569 u32 custom_dev_instance = ~0;
9570 u8 sw_if_index_set = 0;
9571 u32 sw_if_index = (u32) ~ 0;
9573 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9575 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9576 sw_if_index_set = 1;
9577 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9578 sw_if_index_set = 1;
9579 else if (unformat (i, "socket %s", &file_name))
9583 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
9585 else if (unformat (i, "server"))
9591 if (sw_if_index_set == 0)
9593 errmsg ("missing sw_if_index or interface name\n");
9597 if (file_name_set == 0)
9599 errmsg ("missing socket file name\n");
9603 if (vec_len (file_name) > 255)
9605 errmsg ("socket file name too long\n");
9608 vec_add1 (file_name, 0);
9610 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
9612 mp->sw_if_index = ntohl (sw_if_index);
9613 mp->is_server = is_server;
9614 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
9615 vec_free (file_name);
9616 if (custom_dev_instance != ~0)
9619 mp->custom_dev_instance = ntohl (custom_dev_instance);
9629 api_delete_vhost_user_if (vat_main_t * vam)
9631 unformat_input_t *i = vam->input;
9632 vl_api_delete_vhost_user_if_t *mp;
9634 u32 sw_if_index = ~0;
9635 u8 sw_if_index_set = 0;
9637 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9639 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9640 sw_if_index_set = 1;
9641 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9642 sw_if_index_set = 1;
9647 if (sw_if_index_set == 0)
9649 errmsg ("missing sw_if_index or interface name\n");
9654 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
9656 mp->sw_if_index = ntohl (sw_if_index);
9664 static void vl_api_sw_interface_vhost_user_details_t_handler
9665 (vl_api_sw_interface_vhost_user_details_t * mp)
9667 vat_main_t *vam = &vat_main;
9669 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
9670 (char *) mp->interface_name,
9671 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
9672 clib_net_to_host_u64 (mp->features), mp->is_server,
9673 ntohl (mp->num_regions), (char *) mp->sock_filename);
9674 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
9677 static void vl_api_sw_interface_vhost_user_details_t_handler_json
9678 (vl_api_sw_interface_vhost_user_details_t * mp)
9680 vat_main_t *vam = &vat_main;
9681 vat_json_node_t *node = NULL;
9683 if (VAT_JSON_ARRAY != vam->json_tree.type)
9685 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9686 vat_json_init_array (&vam->json_tree);
9688 node = vat_json_array_add (&vam->json_tree);
9690 vat_json_init_object (node);
9691 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9692 vat_json_object_add_string_copy (node, "interface_name",
9693 mp->interface_name);
9694 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
9695 ntohl (mp->virtio_net_hdr_sz));
9696 vat_json_object_add_uint (node, "features",
9697 clib_net_to_host_u64 (mp->features));
9698 vat_json_object_add_uint (node, "is_server", mp->is_server);
9699 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
9700 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
9701 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
9705 api_sw_interface_vhost_user_dump (vat_main_t * vam)
9707 vl_api_sw_interface_vhost_user_dump_t *mp;
9710 "Interface name idx hdr_sz features server regions filename\n");
9712 /* Get list of vhost-user interfaces */
9713 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
9716 /* Use a control ping for synchronization */
9718 vl_api_control_ping_t *mp;
9719 M (CONTROL_PING, control_ping);
9726 api_show_version (vat_main_t * vam)
9728 vl_api_show_version_t *mp;
9731 M (SHOW_VERSION, show_version);
9741 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
9743 unformat_input_t *line_input = vam->input;
9744 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
9746 ip4_address_t local4, remote4;
9747 ip6_address_t local6, remote6;
9749 u8 ipv4_set = 0, ipv6_set = 0;
9752 u32 encap_vrf_id = 0;
9753 u32 decap_vrf_id = 0;
9758 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
9760 if (unformat (line_input, "del"))
9762 else if (unformat (line_input, "local %U",
9763 unformat_ip4_address, &local4))
9768 else if (unformat (line_input, "remote %U",
9769 unformat_ip4_address, &remote4))
9774 else if (unformat (line_input, "local %U",
9775 unformat_ip6_address, &local6))
9780 else if (unformat (line_input, "remote %U",
9781 unformat_ip6_address, &remote6))
9786 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
9788 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
9790 else if (unformat (line_input, "vni %d", &vni))
9792 else if (unformat (line_input, "next-ip4"))
9794 else if (unformat (line_input, "next-ip6"))
9796 else if (unformat (line_input, "next-ethernet"))
9798 else if (unformat (line_input, "next-nsh"))
9802 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
9809 errmsg ("tunnel local address not specified\n");
9812 if (remote_set == 0)
9814 errmsg ("tunnel remote address not specified\n");
9817 if (ipv4_set && ipv6_set)
9819 errmsg ("both IPv4 and IPv6 addresses specified");
9825 errmsg ("vni not specified\n");
9829 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
9834 clib_memcpy (&mp->local, &local6, sizeof (local6));
9835 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
9839 clib_memcpy (&mp->local, &local4, sizeof (local4));
9840 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
9843 mp->encap_vrf_id = ntohl (encap_vrf_id);
9844 mp->decap_vrf_id = ntohl (decap_vrf_id);
9845 mp->protocol = ntohl (protocol);
9846 mp->vni = ntohl (vni);
9847 mp->is_add = is_add;
9848 mp->is_ipv6 = ipv6_set;
9856 static void vl_api_vxlan_gpe_tunnel_details_t_handler
9857 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9859 vat_main_t *vam = &vat_main;
9861 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
9862 ntohl (mp->sw_if_index),
9863 format_ip46_address, &(mp->local[0]),
9864 format_ip46_address, &(mp->remote[0]),
9866 ntohl (mp->protocol),
9867 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
9870 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
9871 (vl_api_vxlan_gpe_tunnel_details_t * mp)
9873 vat_main_t *vam = &vat_main;
9874 vat_json_node_t *node = NULL;
9876 struct in6_addr ip6;
9878 if (VAT_JSON_ARRAY != vam->json_tree.type)
9880 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9881 vat_json_init_array (&vam->json_tree);
9883 node = vat_json_array_add (&vam->json_tree);
9885 vat_json_init_object (node);
9886 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9889 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
9890 vat_json_object_add_ip6 (node, "local", ip6);
9891 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
9892 vat_json_object_add_ip6 (node, "remote", ip6);
9896 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
9897 vat_json_object_add_ip4 (node, "local", ip4);
9898 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
9899 vat_json_object_add_ip4 (node, "remote", ip4);
9901 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
9902 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
9903 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
9904 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
9905 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
9909 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
9911 unformat_input_t *i = vam->input;
9912 vl_api_vxlan_gpe_tunnel_dump_t *mp;
9915 u8 sw_if_index_set = 0;
9917 /* Parse args required to build the message */
9918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9920 if (unformat (i, "sw_if_index %d", &sw_if_index))
9921 sw_if_index_set = 1;
9926 if (sw_if_index_set == 0)
9931 if (!vam->json_output)
9933 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
9934 "sw_if_index", "local", "remote", "vni",
9935 "protocol", "encap_vrf_id", "decap_vrf_id");
9938 /* Get list of vxlan-tunnel interfaces */
9939 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
9941 mp->sw_if_index = htonl (sw_if_index);
9945 /* Use a control ping for synchronization */
9947 vl_api_control_ping_t *mp;
9948 M (CONTROL_PING, control_ping);
9955 format_l2_fib_mac_address (u8 * s, va_list * args)
9957 u8 *a = va_arg (*args, u8 *);
9959 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
9960 a[2], a[3], a[4], a[5], a[6], a[7]);
9963 static void vl_api_l2_fib_table_entry_t_handler
9964 (vl_api_l2_fib_table_entry_t * mp)
9966 vat_main_t *vam = &vat_main;
9968 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
9970 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
9971 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
9975 static void vl_api_l2_fib_table_entry_t_handler_json
9976 (vl_api_l2_fib_table_entry_t * mp)
9978 vat_main_t *vam = &vat_main;
9979 vat_json_node_t *node = NULL;
9981 if (VAT_JSON_ARRAY != vam->json_tree.type)
9983 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9984 vat_json_init_array (&vam->json_tree);
9986 node = vat_json_array_add (&vam->json_tree);
9988 vat_json_init_object (node);
9989 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
9990 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
9991 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9992 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
9993 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
9994 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
9998 api_l2_fib_table_dump (vat_main_t * vam)
10000 unformat_input_t *i = vam->input;
10001 vl_api_l2_fib_table_dump_t *mp;
10006 /* Parse args required to build the message */
10007 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10009 if (unformat (i, "bd_id %d", &bd_id))
10015 if (bd_id_set == 0)
10017 errmsg ("missing bridge domain\n");
10022 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
10024 /* Get list of l2 fib entries */
10025 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
10027 mp->bd_id = ntohl (bd_id);
10030 /* Use a control ping for synchronization */
10032 vl_api_control_ping_t *mp;
10033 M (CONTROL_PING, control_ping);
10041 api_interface_name_renumber (vat_main_t * vam)
10043 unformat_input_t *line_input = vam->input;
10044 vl_api_interface_name_renumber_t *mp;
10045 u32 sw_if_index = ~0;
10047 u32 new_show_dev_instance = ~0;
10049 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10051 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
10054 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
10056 else if (unformat (line_input, "new_show_dev_instance %d",
10057 &new_show_dev_instance))
10063 if (sw_if_index == ~0)
10065 errmsg ("missing interface name or sw_if_index\n");
10069 if (new_show_dev_instance == ~0)
10071 errmsg ("missing new_show_dev_instance\n");
10075 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
10077 mp->sw_if_index = ntohl (sw_if_index);
10078 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
10085 api_want_ip4_arp_events (vat_main_t * vam)
10087 unformat_input_t *line_input = vam->input;
10088 vl_api_want_ip4_arp_events_t *mp;
10090 ip4_address_t address;
10091 int address_set = 0;
10092 u32 enable_disable = 1;
10094 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10096 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
10098 else if (unformat (line_input, "del"))
10099 enable_disable = 0;
10104 if (address_set == 0)
10106 errmsg ("missing addresses\n");
10110 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
10111 mp->enable_disable = enable_disable;
10112 mp->pid = getpid ();
10113 mp->address = address.as_u32;
10120 api_input_acl_set_interface (vat_main_t * vam)
10122 unformat_input_t *i = vam->input;
10123 vl_api_input_acl_set_interface_t *mp;
10126 int sw_if_index_set;
10127 u32 ip4_table_index = ~0;
10128 u32 ip6_table_index = ~0;
10129 u32 l2_table_index = ~0;
10132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10134 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10135 sw_if_index_set = 1;
10136 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10137 sw_if_index_set = 1;
10138 else if (unformat (i, "del"))
10140 else if (unformat (i, "ip4-table %d", &ip4_table_index))
10142 else if (unformat (i, "ip6-table %d", &ip6_table_index))
10144 else if (unformat (i, "l2-table %d", &l2_table_index))
10148 clib_warning ("parse error '%U'", format_unformat_error, i);
10153 if (sw_if_index_set == 0)
10155 errmsg ("missing interface name or sw_if_index\n");
10159 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
10161 mp->sw_if_index = ntohl (sw_if_index);
10162 mp->ip4_table_index = ntohl (ip4_table_index);
10163 mp->ip6_table_index = ntohl (ip6_table_index);
10164 mp->l2_table_index = ntohl (l2_table_index);
10165 mp->is_add = is_add;
10174 api_ip_address_dump (vat_main_t * vam)
10176 unformat_input_t *i = vam->input;
10177 vl_api_ip_address_dump_t *mp;
10178 u32 sw_if_index = ~0;
10179 u8 sw_if_index_set = 0;
10184 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10186 if (unformat (i, "sw_if_index %d", &sw_if_index))
10187 sw_if_index_set = 1;
10188 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10189 sw_if_index_set = 1;
10190 else if (unformat (i, "ipv4"))
10192 else if (unformat (i, "ipv6"))
10198 if (ipv4_set && ipv6_set)
10200 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10204 if ((!ipv4_set) && (!ipv6_set))
10206 errmsg ("no ipv4 nor ipv6 flag set\n");
10210 if (sw_if_index_set == 0)
10212 errmsg ("missing interface name or sw_if_index\n");
10216 vam->current_sw_if_index = sw_if_index;
10217 vam->is_ipv6 = ipv6_set;
10219 M (IP_ADDRESS_DUMP, ip_address_dump);
10220 mp->sw_if_index = ntohl (sw_if_index);
10221 mp->is_ipv6 = ipv6_set;
10224 /* Use a control ping for synchronization */
10226 vl_api_control_ping_t *mp;
10227 M (CONTROL_PING, control_ping);
10234 api_ip_dump (vat_main_t * vam)
10236 vl_api_ip_dump_t *mp;
10237 unformat_input_t *in = vam->input;
10244 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
10246 if (unformat (in, "ipv4"))
10248 else if (unformat (in, "ipv6"))
10254 if (ipv4_set && ipv6_set)
10256 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
10260 if ((!ipv4_set) && (!ipv6_set))
10262 errmsg ("no ipv4 nor ipv6 flag set\n");
10266 is_ipv6 = ipv6_set;
10267 vam->is_ipv6 = is_ipv6;
10269 /* free old data */
10270 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
10272 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
10274 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
10276 M (IP_DUMP, ip_dump);
10277 mp->is_ipv6 = ipv6_set;
10280 /* Use a control ping for synchronization */
10282 vl_api_control_ping_t *mp;
10283 M (CONTROL_PING, control_ping);
10290 api_ipsec_spd_add_del (vat_main_t * vam)
10293 unformat_input_t *i = vam->input;
10294 vl_api_ipsec_spd_add_del_t *mp;
10299 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10301 if (unformat (i, "spd_id %d", &spd_id))
10303 else if (unformat (i, "del"))
10307 clib_warning ("parse error '%U'", format_unformat_error, i);
10313 errmsg ("spd_id must be set\n");
10317 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
10319 mp->spd_id = ntohl (spd_id);
10320 mp->is_add = is_add;
10327 clib_warning ("unsupported (no dpdk)");
10333 api_ipsec_interface_add_del_spd (vat_main_t * vam)
10336 unformat_input_t *i = vam->input;
10337 vl_api_ipsec_interface_add_del_spd_t *mp;
10340 u8 sw_if_index_set = 0;
10341 u32 spd_id = (u32) ~ 0;
10344 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10346 if (unformat (i, "del"))
10348 else if (unformat (i, "spd_id %d", &spd_id))
10350 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10351 sw_if_index_set = 1;
10352 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10353 sw_if_index_set = 1;
10356 clib_warning ("parse error '%U'", format_unformat_error, i);
10362 if (spd_id == (u32) ~ 0)
10364 errmsg ("spd_id must be set\n");
10368 if (sw_if_index_set == 0)
10370 errmsg ("missing interface name or sw_if_index\n");
10374 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
10376 mp->spd_id = ntohl (spd_id);
10377 mp->sw_if_index = ntohl (sw_if_index);
10378 mp->is_add = is_add;
10385 clib_warning ("unsupported (no dpdk)");
10391 api_ipsec_spd_add_del_entry (vat_main_t * vam)
10394 unformat_input_t *i = vam->input;
10395 vl_api_ipsec_spd_add_del_entry_t *mp;
10397 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
10398 u32 spd_id, sa_id, protocol = 0, policy = 0;
10400 u32 rport_start = 0, rport_stop = (u32) ~ 0;
10401 u32 lport_start = 0, lport_stop = (u32) ~ 0;
10402 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
10403 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
10405 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
10406 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
10407 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
10408 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
10409 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
10410 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
10412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10414 if (unformat (i, "del"))
10416 if (unformat (i, "outbound"))
10418 if (unformat (i, "inbound"))
10420 else if (unformat (i, "spd_id %d", &spd_id))
10422 else if (unformat (i, "sa_id %d", &sa_id))
10424 else if (unformat (i, "priority %d", &priority))
10426 else if (unformat (i, "protocol %d", &protocol))
10428 else if (unformat (i, "lport_start %d", &lport_start))
10430 else if (unformat (i, "lport_stop %d", &lport_stop))
10432 else if (unformat (i, "rport_start %d", &rport_start))
10434 else if (unformat (i, "rport_stop %d", &rport_stop))
10438 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
10444 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
10451 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
10457 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
10464 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
10470 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
10477 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
10483 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
10489 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
10491 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
10493 clib_warning ("unsupported action: 'resolve'");
10499 clib_warning ("parse error '%U'", format_unformat_error, i);
10505 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
10507 mp->spd_id = ntohl (spd_id);
10508 mp->priority = ntohl (priority);
10509 mp->is_outbound = is_outbound;
10511 mp->is_ipv6 = is_ipv6;
10512 if (is_ipv6 || is_ip_any)
10514 clib_memcpy (mp->remote_address_start, &raddr6_start,
10515 sizeof (ip6_address_t));
10516 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
10517 sizeof (ip6_address_t));
10518 clib_memcpy (mp->local_address_start, &laddr6_start,
10519 sizeof (ip6_address_t));
10520 clib_memcpy (mp->local_address_stop, &laddr6_stop,
10521 sizeof (ip6_address_t));
10525 clib_memcpy (mp->remote_address_start, &raddr4_start,
10526 sizeof (ip4_address_t));
10527 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
10528 sizeof (ip4_address_t));
10529 clib_memcpy (mp->local_address_start, &laddr4_start,
10530 sizeof (ip4_address_t));
10531 clib_memcpy (mp->local_address_stop, &laddr4_stop,
10532 sizeof (ip4_address_t));
10534 mp->protocol = (u8) protocol;
10535 mp->local_port_start = ntohs ((u16) lport_start);
10536 mp->local_port_stop = ntohs ((u16) lport_stop);
10537 mp->remote_port_start = ntohs ((u16) rport_start);
10538 mp->remote_port_stop = ntohs ((u16) rport_stop);
10539 mp->policy = (u8) policy;
10540 mp->sa_id = ntohl (sa_id);
10541 mp->is_add = is_add;
10542 mp->is_ip_any = is_ip_any;
10548 clib_warning ("unsupported (no dpdk)");
10554 api_ipsec_sad_add_del_entry (vat_main_t * vam)
10557 unformat_input_t *i = vam->input;
10558 vl_api_ipsec_sad_add_del_entry_t *mp;
10561 u8 *ck = 0, *ik = 0;
10564 u8 protocol = IPSEC_PROTOCOL_AH;
10565 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
10566 u32 crypto_alg = 0, integ_alg = 0;
10567 ip4_address_t tun_src4;
10568 ip4_address_t tun_dst4;
10569 ip6_address_t tun_src6;
10570 ip6_address_t tun_dst6;
10572 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10574 if (unformat (i, "del"))
10576 else if (unformat (i, "sad_id %d", &sad_id))
10578 else if (unformat (i, "spi %d", &spi))
10580 else if (unformat (i, "esp"))
10581 protocol = IPSEC_PROTOCOL_ESP;
10582 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
10585 is_tunnel_ipv6 = 0;
10587 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
10590 is_tunnel_ipv6 = 0;
10592 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
10595 is_tunnel_ipv6 = 1;
10597 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
10600 is_tunnel_ipv6 = 1;
10604 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
10606 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
10607 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
10609 clib_warning ("unsupported crypto-alg: '%U'",
10610 format_ipsec_crypto_alg, crypto_alg);
10614 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10618 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
10620 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
10621 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
10623 clib_warning ("unsupported integ-alg: '%U'",
10624 format_ipsec_integ_alg, integ_alg);
10628 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10632 clib_warning ("parse error '%U'", format_unformat_error, i);
10638 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
10640 mp->sad_id = ntohl (sad_id);
10641 mp->is_add = is_add;
10642 mp->protocol = protocol;
10643 mp->spi = ntohl (spi);
10644 mp->is_tunnel = is_tunnel;
10645 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
10646 mp->crypto_algorithm = crypto_alg;
10647 mp->integrity_algorithm = integ_alg;
10648 mp->crypto_key_length = vec_len (ck);
10649 mp->integrity_key_length = vec_len (ik);
10651 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10652 mp->crypto_key_length = sizeof (mp->crypto_key);
10654 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10655 mp->integrity_key_length = sizeof (mp->integrity_key);
10657 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10658 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10662 if (is_tunnel_ipv6)
10664 clib_memcpy (mp->tunnel_src_address, &tun_src6,
10665 sizeof (ip6_address_t));
10666 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
10667 sizeof (ip6_address_t));
10671 clib_memcpy (mp->tunnel_src_address, &tun_src4,
10672 sizeof (ip4_address_t));
10673 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
10674 sizeof (ip4_address_t));
10683 clib_warning ("unsupported (no dpdk)");
10689 api_ipsec_sa_set_key (vat_main_t * vam)
10692 unformat_input_t *i = vam->input;
10693 vl_api_ipsec_sa_set_key_t *mp;
10696 u8 *ck = 0, *ik = 0;
10698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10700 if (unformat (i, "sa_id %d", &sa_id))
10702 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
10704 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
10708 clib_warning ("parse error '%U'", format_unformat_error, i);
10713 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
10715 mp->sa_id = ntohl (sa_id);
10716 mp->crypto_key_length = vec_len (ck);
10717 mp->integrity_key_length = vec_len (ik);
10719 if (mp->crypto_key_length > sizeof (mp->crypto_key))
10720 mp->crypto_key_length = sizeof (mp->crypto_key);
10722 if (mp->integrity_key_length > sizeof (mp->integrity_key))
10723 mp->integrity_key_length = sizeof (mp->integrity_key);
10725 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
10726 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
10733 clib_warning ("unsupported (no dpdk)");
10739 api_ikev2_profile_add_del (vat_main_t * vam)
10742 unformat_input_t *i = vam->input;
10743 vl_api_ikev2_profile_add_del_t *mp;
10748 const char *valid_chars = "a-zA-Z0-9_";
10750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10752 if (unformat (i, "del"))
10754 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10755 vec_add1 (name, 0);
10758 errmsg ("parse error '%U'", format_unformat_error, i);
10763 if (!vec_len (name))
10765 errmsg ("profile name must be specified");
10769 if (vec_len (name) > 64)
10771 errmsg ("profile name too long");
10775 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
10777 clib_memcpy (mp->name, name, vec_len (name));
10778 mp->is_add = is_add;
10786 clib_warning ("unsupported (no dpdk)");
10792 api_ikev2_profile_set_auth (vat_main_t * vam)
10795 unformat_input_t *i = vam->input;
10796 vl_api_ikev2_profile_set_auth_t *mp;
10800 u32 auth_method = 0;
10803 const char *valid_chars = "a-zA-Z0-9_";
10805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10807 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10808 vec_add1 (name, 0);
10809 else if (unformat (i, "auth_method %U",
10810 unformat_ikev2_auth_method, &auth_method))
10812 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
10814 else if (unformat (i, "auth_data %v", &data))
10818 errmsg ("parse error '%U'", format_unformat_error, i);
10823 if (!vec_len (name))
10825 errmsg ("profile name must be specified");
10829 if (vec_len (name) > 64)
10831 errmsg ("profile name too long");
10835 if (!vec_len (data))
10837 errmsg ("auth_data must be specified");
10843 errmsg ("auth_method must be specified");
10847 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
10849 mp->is_hex = is_hex;
10850 mp->auth_method = (u8) auth_method;
10851 mp->data_len = vec_len (data);
10852 clib_memcpy (mp->name, name, vec_len (name));
10853 clib_memcpy (mp->data, data, vec_len (data));
10862 clib_warning ("unsupported (no dpdk)");
10868 api_ikev2_profile_set_id (vat_main_t * vam)
10871 unformat_input_t *i = vam->input;
10872 vl_api_ikev2_profile_set_id_t *mp;
10880 const char *valid_chars = "a-zA-Z0-9_";
10882 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10884 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10885 vec_add1 (name, 0);
10886 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
10888 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
10890 data = vec_new (u8, 4);
10891 clib_memcpy (data, ip4.as_u8, 4);
10893 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
10895 else if (unformat (i, "id_data %v", &data))
10897 else if (unformat (i, "local"))
10899 else if (unformat (i, "remote"))
10903 errmsg ("parse error '%U'", format_unformat_error, i);
10908 if (!vec_len (name))
10910 errmsg ("profile name must be specified");
10914 if (vec_len (name) > 64)
10916 errmsg ("profile name too long");
10920 if (!vec_len (data))
10922 errmsg ("id_data must be specified");
10928 errmsg ("id_type must be specified");
10932 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
10934 mp->is_local = is_local;
10935 mp->id_type = (u8) id_type;
10936 mp->data_len = vec_len (data);
10937 clib_memcpy (mp->name, name, vec_len (name));
10938 clib_memcpy (mp->data, data, vec_len (data));
10947 clib_warning ("unsupported (no dpdk)");
10953 api_ikev2_profile_set_ts (vat_main_t * vam)
10956 unformat_input_t *i = vam->input;
10957 vl_api_ikev2_profile_set_ts_t *mp;
10961 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
10962 ip4_address_t start_addr, end_addr;
10964 const char *valid_chars = "a-zA-Z0-9_";
10966 start_addr.as_u32 = 0;
10967 end_addr.as_u32 = (u32) ~ 0;
10969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10971 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
10972 vec_add1 (name, 0);
10973 else if (unformat (i, "protocol %d", &proto))
10975 else if (unformat (i, "start_port %d", &start_port))
10977 else if (unformat (i, "end_port %d", &end_port))
10980 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
10982 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
10984 else if (unformat (i, "local"))
10986 else if (unformat (i, "remote"))
10990 errmsg ("parse error '%U'", format_unformat_error, i);
10995 if (!vec_len (name))
10997 errmsg ("profile name must be specified");
11001 if (vec_len (name) > 64)
11003 errmsg ("profile name too long");
11007 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
11009 mp->is_local = is_local;
11010 mp->proto = (u8) proto;
11011 mp->start_port = (u16) start_port;
11012 mp->end_port = (u16) end_port;
11013 mp->start_addr = start_addr.as_u32;
11014 mp->end_addr = end_addr.as_u32;
11015 clib_memcpy (mp->name, name, vec_len (name));
11023 clib_warning ("unsupported (no dpdk)");
11029 api_ikev2_set_local_key (vat_main_t * vam)
11032 unformat_input_t *i = vam->input;
11033 vl_api_ikev2_set_local_key_t *mp;
11037 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11039 if (unformat (i, "file %v", &file))
11040 vec_add1 (file, 0);
11043 errmsg ("parse error '%U'", format_unformat_error, i);
11048 if (!vec_len (file))
11050 errmsg ("RSA key file must be specified");
11054 if (vec_len (file) > 256)
11056 errmsg ("file name too long");
11060 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
11062 clib_memcpy (mp->key_file, file, vec_len (file));
11070 clib_warning ("unsupported (no dpdk)");
11079 api_map_add_domain (vat_main_t * vam)
11081 unformat_input_t *i = vam->input;
11082 vl_api_map_add_domain_t *mp;
11085 ip4_address_t ip4_prefix;
11086 ip6_address_t ip6_prefix;
11087 ip6_address_t ip6_src;
11088 u32 num_m_args = 0;
11089 u32 ip6_prefix_len, ip4_prefix_len, ea_bits_len, psid_offset, psid_length;
11090 u8 is_translation = 0;
11092 u8 ip6_src_len = 128;
11094 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11096 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
11097 &ip4_prefix, &ip4_prefix_len))
11099 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
11100 &ip6_prefix, &ip6_prefix_len))
11104 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
11107 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
11109 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
11111 else if (unformat (i, "psid-offset %d", &psid_offset))
11113 else if (unformat (i, "psid-len %d", &psid_length))
11115 else if (unformat (i, "mtu %d", &mtu))
11117 else if (unformat (i, "map-t"))
11118 is_translation = 1;
11121 clib_warning ("parse error '%U'", format_unformat_error, i);
11126 if (num_m_args != 6)
11128 errmsg ("mandatory argument(s) missing\n");
11132 /* Construct the API message */
11133 M (MAP_ADD_DOMAIN, map_add_domain);
11135 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
11136 mp->ip4_prefix_len = ip4_prefix_len;
11138 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
11139 mp->ip6_prefix_len = ip6_prefix_len;
11141 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
11142 mp->ip6_src_prefix_len = ip6_src_len;
11144 mp->ea_bits_len = ea_bits_len;
11145 mp->psid_offset = psid_offset;
11146 mp->psid_length = psid_length;
11147 mp->is_translation = is_translation;
11148 mp->mtu = htons (mtu);
11153 /* Wait for a reply, return good/bad news */
11158 api_map_del_domain (vat_main_t * vam)
11160 unformat_input_t *i = vam->input;
11161 vl_api_map_del_domain_t *mp;
11164 u32 num_m_args = 0;
11167 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11169 if (unformat (i, "index %d", &index))
11173 clib_warning ("parse error '%U'", format_unformat_error, i);
11178 if (num_m_args != 1)
11180 errmsg ("mandatory argument(s) missing\n");
11184 /* Construct the API message */
11185 M (MAP_DEL_DOMAIN, map_del_domain);
11187 mp->index = ntohl (index);
11192 /* Wait for a reply, return good/bad news */
11197 api_map_add_del_rule (vat_main_t * vam)
11199 unformat_input_t *i = vam->input;
11200 vl_api_map_add_del_rule_t *mp;
11203 ip6_address_t ip6_dst;
11204 u32 num_m_args = 0, index, psid;
11206 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11208 if (unformat (i, "index %d", &index))
11210 else if (unformat (i, "psid %d", &psid))
11212 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
11214 else if (unformat (i, "del"))
11220 clib_warning ("parse error '%U'", format_unformat_error, i);
11225 /* Construct the API message */
11226 M (MAP_ADD_DEL_RULE, map_add_del_rule);
11228 mp->index = ntohl (index);
11229 mp->is_add = is_add;
11230 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
11231 mp->psid = ntohs (psid);
11236 /* Wait for a reply, return good/bad news */
11241 api_map_domain_dump (vat_main_t * vam)
11243 vl_api_map_domain_dump_t *mp;
11246 /* Construct the API message */
11247 M (MAP_DOMAIN_DUMP, map_domain_dump);
11252 /* Use a control ping for synchronization */
11254 vl_api_control_ping_t *mp;
11255 M (CONTROL_PING, control_ping);
11262 api_map_rule_dump (vat_main_t * vam)
11264 unformat_input_t *i = vam->input;
11265 vl_api_map_rule_dump_t *mp;
11267 u32 domain_index = ~0;
11269 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11271 if (unformat (i, "index %u", &domain_index))
11277 if (domain_index == ~0)
11279 clib_warning ("parse error: domain index expected");
11283 /* Construct the API message */
11284 M (MAP_RULE_DUMP, map_rule_dump);
11286 mp->domain_index = htonl (domain_index);
11291 /* Use a control ping for synchronization */
11293 vl_api_control_ping_t *mp;
11294 M (CONTROL_PING, control_ping);
11300 static void vl_api_map_add_domain_reply_t_handler
11301 (vl_api_map_add_domain_reply_t * mp)
11303 vat_main_t *vam = &vat_main;
11304 i32 retval = ntohl (mp->retval);
11306 if (vam->async_mode)
11308 vam->async_errors += (retval < 0);
11312 vam->retval = retval;
11313 vam->result_ready = 1;
11317 static void vl_api_map_add_domain_reply_t_handler_json
11318 (vl_api_map_add_domain_reply_t * mp)
11320 vat_main_t *vam = &vat_main;
11321 vat_json_node_t node;
11323 vat_json_init_object (&node);
11324 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
11325 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
11327 vat_json_print (vam->ofp, &node);
11328 vat_json_free (&node);
11330 vam->retval = ntohl (mp->retval);
11331 vam->result_ready = 1;
11335 api_get_first_msg_id (vat_main_t * vam)
11337 vl_api_get_first_msg_id_t *mp;
11339 unformat_input_t *i = vam->input;
11343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11345 if (unformat (i, "client %s", &name))
11353 errmsg ("missing client name\n");
11356 vec_add1 (name, 0);
11358 if (vec_len (name) > 63)
11360 errmsg ("client name too long\n");
11364 M (GET_FIRST_MSG_ID, get_first_msg_id);
11365 clib_memcpy (mp->name, name, vec_len (name));
11373 api_cop_interface_enable_disable (vat_main_t * vam)
11375 unformat_input_t *line_input = vam->input;
11376 vl_api_cop_interface_enable_disable_t *mp;
11378 u32 sw_if_index = ~0;
11379 u8 enable_disable = 1;
11381 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11383 if (unformat (line_input, "disable"))
11384 enable_disable = 0;
11385 if (unformat (line_input, "enable"))
11386 enable_disable = 1;
11387 else if (unformat (line_input, "%U", unformat_sw_if_index,
11388 vam, &sw_if_index))
11390 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11396 if (sw_if_index == ~0)
11398 errmsg ("missing interface name or sw_if_index\n");
11402 /* Construct the API message */
11403 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
11404 mp->sw_if_index = ntohl (sw_if_index);
11405 mp->enable_disable = enable_disable;
11409 /* Wait for the reply */
11414 api_cop_whitelist_enable_disable (vat_main_t * vam)
11416 unformat_input_t *line_input = vam->input;
11417 vl_api_cop_whitelist_enable_disable_t *mp;
11419 u32 sw_if_index = ~0;
11420 u8 ip4 = 0, ip6 = 0, default_cop = 0;
11423 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11425 if (unformat (line_input, "ip4"))
11427 else if (unformat (line_input, "ip6"))
11429 else if (unformat (line_input, "default"))
11431 else if (unformat (line_input, "%U", unformat_sw_if_index,
11432 vam, &sw_if_index))
11434 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11436 else if (unformat (line_input, "fib-id %d", &fib_id))
11442 if (sw_if_index == ~0)
11444 errmsg ("missing interface name or sw_if_index\n");
11448 /* Construct the API message */
11449 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
11450 mp->sw_if_index = ntohl (sw_if_index);
11451 mp->fib_id = ntohl (fib_id);
11454 mp->default_cop = default_cop;
11458 /* Wait for the reply */
11463 api_get_node_graph (vat_main_t * vam)
11465 vl_api_get_node_graph_t *mp;
11468 M (GET_NODE_GRAPH, get_node_graph);
11472 /* Wait for the reply */
11477 /** Used for parsing LISP eids */
11478 typedef CLIB_PACKED(struct{
11479 u8 addr[16]; /**< eid address */
11480 u32 len; /**< prefix length if IP */
11481 u8 type; /**< type of eid */
11486 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
11488 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
11490 memset (a, 0, sizeof (a[0]));
11492 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
11494 a->type = 0; /* ipv4 type */
11496 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
11498 a->type = 1; /* ipv6 type */
11500 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
11502 a->type = 2; /* mac type */
11509 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
11518 lisp_eid_size_vat (u8 type)
11533 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
11535 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
11539 /** Used for transferring locators via VPP API */
11540 typedef CLIB_PACKED(struct
11542 u32 sw_if_index; /**< locator sw_if_index */
11543 u8 priority; /**< locator priority */
11544 u8 weight; /**< locator weight */
11549 api_lisp_add_del_locator_set (vat_main_t * vam)
11551 unformat_input_t *input = vam->input;
11552 vl_api_lisp_add_del_locator_set_t *mp;
11555 u8 *locator_set_name = NULL;
11556 u8 locator_set_name_set = 0;
11557 ls_locator_t locator, *locators = 0;
11558 u32 sw_if_index, priority, weight;
11560 /* Parse args required to build the message */
11561 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11563 if (unformat (input, "del"))
11567 else if (unformat (input, "locator-set %s", &locator_set_name))
11569 locator_set_name_set = 1;
11571 else if (unformat (input, "sw_if_index %u p %u w %u",
11572 &sw_if_index, &priority, &weight))
11574 locator.sw_if_index = htonl (sw_if_index);
11575 locator.priority = priority;
11576 locator.weight = weight;
11577 vec_add1 (locators, locator);
11579 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
11580 vam, &sw_if_index, &priority, &weight))
11582 locator.sw_if_index = htonl (sw_if_index);
11583 locator.priority = priority;
11584 locator.weight = weight;
11585 vec_add1 (locators, locator);
11591 if (locator_set_name_set == 0)
11593 errmsg ("missing locator-set name");
11594 vec_free (locators);
11598 if (vec_len (locator_set_name) > 64)
11600 errmsg ("locator-set name too long\n");
11601 vec_free (locator_set_name);
11602 vec_free (locators);
11605 vec_add1 (locator_set_name, 0);
11607 /* Construct the API message */
11608 M (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
11610 mp->is_add = is_add;
11611 clib_memcpy (mp->locator_set_name, locator_set_name,
11612 vec_len (locator_set_name));
11613 vec_free (locator_set_name);
11615 mp->locator_num = vec_len (locators);
11616 clib_memcpy (mp->locators, locators,
11617 (sizeof (ls_locator_t) * vec_len (locators)));
11618 vec_free (locators);
11623 /* Wait for a reply... */
11631 api_lisp_add_del_locator (vat_main_t * vam)
11633 unformat_input_t *input = vam->input;
11634 vl_api_lisp_add_del_locator_t *mp;
11636 u32 tmp_if_index = ~0;
11637 u32 sw_if_index = ~0;
11638 u8 sw_if_index_set = 0;
11639 u8 sw_if_index_if_name_set = 0;
11641 u8 priority_set = 0;
11645 u8 *locator_set_name = NULL;
11646 u8 locator_set_name_set = 0;
11648 /* Parse args required to build the message */
11649 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11651 if (unformat (input, "del"))
11655 else if (unformat (input, "locator-set %s", &locator_set_name))
11657 locator_set_name_set = 1;
11659 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
11662 sw_if_index_if_name_set = 1;
11663 sw_if_index = tmp_if_index;
11665 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
11667 sw_if_index_set = 1;
11668 sw_if_index = tmp_if_index;
11670 else if (unformat (input, "p %d", &priority))
11674 else if (unformat (input, "w %d", &weight))
11682 if (locator_set_name_set == 0)
11684 errmsg ("missing locator-set name");
11688 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
11690 errmsg ("missing sw_if_index");
11691 vec_free (locator_set_name);
11695 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
11697 errmsg ("cannot use both params interface name and sw_if_index");
11698 vec_free (locator_set_name);
11702 if (priority_set == 0)
11704 errmsg ("missing locator-set priority\n");
11705 vec_free (locator_set_name);
11709 if (weight_set == 0)
11711 errmsg ("missing locator-set weight\n");
11712 vec_free (locator_set_name);
11716 if (vec_len (locator_set_name) > 64)
11718 errmsg ("locator-set name too long\n");
11719 vec_free (locator_set_name);
11722 vec_add1 (locator_set_name, 0);
11724 /* Construct the API message */
11725 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
11727 mp->is_add = is_add;
11728 mp->sw_if_index = ntohl (sw_if_index);
11729 mp->priority = priority;
11730 mp->weight = weight;
11731 clib_memcpy (mp->locator_set_name, locator_set_name,
11732 vec_len (locator_set_name));
11733 vec_free (locator_set_name);
11738 /* Wait for a reply... */
11746 api_lisp_add_del_local_eid (vat_main_t * vam)
11748 unformat_input_t *input = vam->input;
11749 vl_api_lisp_add_del_local_eid_t *mp;
11753 lisp_eid_vat_t _eid, *eid = &_eid;
11754 u8 *locator_set_name = 0;
11755 u8 locator_set_name_set = 0;
11758 /* Parse args required to build the message */
11759 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11761 if (unformat (input, "del"))
11765 else if (unformat (input, "vni %d", &vni))
11769 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
11773 else if (unformat (input, "locator-set %s", &locator_set_name))
11775 locator_set_name_set = 1;
11781 if (locator_set_name_set == 0)
11783 errmsg ("missing locator-set name\n");
11789 errmsg ("EID address not set!");
11790 vec_free (locator_set_name);
11794 if (vec_len (locator_set_name) > 64)
11796 errmsg ("locator-set name too long\n");
11797 vec_free (locator_set_name);
11800 vec_add1 (locator_set_name, 0);
11802 /* Construct the API message */
11803 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
11805 mp->is_add = is_add;
11806 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
11807 mp->eid_type = eid->type;
11808 mp->prefix_len = eid->len;
11809 mp->vni = clib_host_to_net_u32 (vni);
11810 clib_memcpy (mp->locator_set_name, locator_set_name,
11811 vec_len (locator_set_name));
11813 vec_free (locator_set_name);
11818 /* Wait for a reply... */
11826 /** Used for transferring locators via VPP API */
11827 typedef CLIB_PACKED(struct
11829 u8 is_ip4; /**< is locator an IPv4 address? */
11830 u8 priority; /**< locator priority */
11831 u8 weight; /**< locator weight */
11832 u8 addr[16]; /**< IPv4/IPv6 address */
11837 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
11839 unformat_input_t *input = vam->input;
11840 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
11843 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
11844 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
11845 u8 rmt_eid_set = 0, lcl_eid_set = 0;
11846 u32 action = ~0, p, w;
11847 ip4_address_t rmt_rloc4, lcl_rloc4;
11848 ip6_address_t rmt_rloc6, lcl_rloc6;
11849 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
11851 /* Parse args required to build the message */
11852 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11854 if (unformat (input, "del"))
11858 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
11862 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
11866 else if (unformat (input, "p %d w %d", &p, &w))
11870 errmsg ("No RLOC configured for setting priority/weight!");
11873 curr_rloc->priority = p;
11874 curr_rloc->weight = w;
11876 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
11877 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
11880 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
11881 vec_add1 (lcl_locs, rloc);
11882 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
11883 vec_add1 (rmt_locs, rloc);
11884 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11886 else if (unformat (input, "loc-pair %U", unformat_ip6_address,
11887 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
11890 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
11891 vec_add1 (lcl_locs, rloc);
11892 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
11893 vec_add1 (rmt_locs, rloc);
11894 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11896 else if (unformat (input, "action %d", &action))
11902 clib_warning ("parse error '%U'", format_unformat_error, input);
11909 errmsg ("remote eid addresses not set\n");
11913 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
11915 errmsg ("eid types don't match\n");
11919 /* Construct the API message */
11920 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
11922 mp->is_add = is_add;
11923 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
11924 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
11925 mp->eid_type = rmt_eid->type;
11926 mp->rmt_len = rmt_eid->len;
11927 mp->lcl_len = lcl_eid->len;
11928 mp->action = action;
11930 mp->loc_num = vec_len (rmt_locs);
11931 clib_memcpy (mp->lcl_locs, lcl_locs,
11932 (sizeof (rloc_t) * vec_len (lcl_locs)));
11933 clib_memcpy (mp->rmt_locs, rmt_locs,
11934 (sizeof (rloc_t) * vec_len (rmt_locs)));
11935 vec_free (lcl_locs);
11936 vec_free (rmt_locs);
11941 /* Wait for a reply... */
11949 api_lisp_add_del_map_resolver (vat_main_t * vam)
11951 unformat_input_t *input = vam->input;
11952 vl_api_lisp_add_del_map_resolver_t *mp;
11957 ip4_address_t ipv4;
11958 ip6_address_t ipv6;
11960 /* Parse args required to build the message */
11961 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11963 if (unformat (input, "del"))
11967 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
11971 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
11979 if (ipv4_set && ipv6_set)
11981 errmsg ("both eid v4 and v6 addresses set\n");
11985 if (!ipv4_set && !ipv6_set)
11987 errmsg ("eid addresses not set\n");
11991 /* Construct the API message */
11992 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
11994 mp->is_add = is_add;
11998 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12003 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12009 /* Wait for a reply... */
12017 api_lisp_gpe_enable_disable (vat_main_t * vam)
12019 unformat_input_t *input = vam->input;
12020 vl_api_lisp_gpe_enable_disable_t *mp;
12025 /* Parse args required to build the message */
12026 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12028 if (unformat (input, "enable"))
12033 else if (unformat (input, "disable"))
12044 errmsg ("Value not set\n");
12048 /* Construct the API message */
12049 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12056 /* Wait for a reply... */
12064 api_lisp_enable_disable (vat_main_t * vam)
12066 unformat_input_t *input = vam->input;
12067 vl_api_lisp_enable_disable_t *mp;
12072 /* Parse args required to build the message */
12073 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12075 if (unformat (input, "enable"))
12080 else if (unformat (input, "disable"))
12090 errmsg ("Value not set\n");
12094 /* Construct the API message */
12095 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12102 /* Wait for a reply... */
12110 * Enable/disable LISP proxy ITR.
12112 * @param vam vpp API test context
12113 * @return return code
12116 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12119 u8 ls_name_set = 0;
12120 unformat_input_t *input = vam->input;
12121 vl_api_lisp_pitr_set_locator_set_t *mp;
12125 /* Parse args required to build the message */
12126 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12128 if (unformat (input, "del"))
12130 else if (unformat (input, "locator-set %s", &ls_name))
12134 errmsg ("parse error '%U'", format_unformat_error, input);
12141 errmsg ("locator-set name not set!");
12145 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12147 mp->is_add = is_add;
12148 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12149 vec_free (ls_name);
12154 /* wait for reply */
12162 api_show_lisp_pitr (vat_main_t * vam)
12164 vl_api_show_lisp_pitr_t *mp;
12167 if (!vam->json_output)
12169 fformat (vam->ofp, "%=20s\n", "lisp status:");
12172 M (SHOW_LISP_PITR, show_lisp_pitr);
12176 /* Wait for a reply... */
12184 * Add/delete mapping between vni and vrf
12187 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12190 unformat_input_t *input = vam->input;
12191 vl_api_lisp_eid_table_add_del_map_t *mp;
12192 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12193 u32 vni, vrf, bd_index;
12195 /* Parse args required to build the message */
12196 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12198 if (unformat (input, "del"))
12200 else if (unformat (input, "vrf %d", &vrf))
12202 else if (unformat (input, "bd_index %d", &bd_index))
12204 else if (unformat (input, "vni %d", &vni))
12210 if (!vni_set || (!vrf_set && !bd_index_set))
12212 errmsg ("missing arguments!");
12216 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12218 mp->is_add = is_add;
12219 mp->vni = htonl (vni);
12220 mp->dp_table = htonl (vrf);
12221 mp->is_l2 = bd_index_set;
12226 /* wait for reply */
12234 * Add/del remote mapping to/from LISP control plane
12236 * @param vam vpp API test context
12237 * @return return code
12240 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12242 unformat_input_t *input = vam->input;
12243 vl_api_lisp_add_del_remote_mapping_t *mp;
12246 //TODO: seid need remove
12247 lisp_eid_vat_t _eid, *eid = &_eid;
12248 lisp_eid_vat_t _seid, *seid = &_seid;
12249 u8 is_add = 1, del_all = 0, eid_set = 0;
12250 u32 action = ~0, p, w;
12251 ip4_address_t rloc4;
12252 ip6_address_t rloc6;
12253 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12255 /* Parse args required to build the message */
12256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12258 if (unformat (input, "del-all"))
12262 else if (unformat (input, "del"))
12266 else if (unformat (input, "add"))
12270 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12274 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12276 //TODO: Need remove, but first must be remove from CSIT test
12278 else if (unformat (input, "vni %d", &vni))
12282 else if (unformat (input, "p %d w %d", &p, &w))
12286 errmsg ("No RLOC configured for setting priority/weight!");
12289 curr_rloc->priority = p;
12290 curr_rloc->weight = w;
12292 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12295 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12296 vec_add1 (rlocs, rloc);
12297 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12299 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12302 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12303 vec_add1 (rlocs, rloc);
12304 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12306 else if (unformat (input, "action %d", &action))
12312 clib_warning ("parse error '%U'", format_unformat_error, input);
12319 errmsg ("missing params!");
12323 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12325 errmsg ("no action set for negative map-reply!");
12329 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12330 mp->is_add = is_add;
12331 mp->vni = htonl (vni);
12332 mp->action = (u8) action;
12333 mp->eid_len = eid->len;
12334 mp->del_all = del_all;
12335 mp->eid_type = eid->type;
12336 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12338 mp->rloc_num = vec_len (rlocs);
12339 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12345 /* Wait for a reply... */
12353 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12354 * forwarding entries in data-plane accordingly.
12356 * @param vam vpp API test context
12357 * @return return code
12360 api_lisp_add_del_adjacency (vat_main_t * vam)
12362 unformat_input_t *input = vam->input;
12363 vl_api_lisp_add_del_adjacency_t *mp;
12366 ip4_address_t seid4, deid4;
12367 ip6_address_t seid6, deid6;
12368 u8 deid_mac[6] = { 0 };
12369 u8 seid_mac[6] = { 0 };
12370 u8 deid_type, seid_type;
12371 u32 seid_len = 0, deid_len = 0, len;
12374 seid_type = deid_type = (u8) ~ 0;
12376 /* Parse args required to build the message */
12377 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12379 if (unformat (input, "del"))
12383 else if (unformat (input, "add"))
12387 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12390 deid_type = 0; /* ipv4 */
12393 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12396 deid_type = 1; /* ipv6 */
12399 else if (unformat (input, "deid %U", unformat_ethernet_address,
12402 deid_type = 2; /* mac */
12404 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12407 seid_type = 0; /* ipv4 */
12410 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12413 seid_type = 1; /* ipv6 */
12416 else if (unformat (input, "seid %U", unformat_ethernet_address,
12419 seid_type = 2; /* mac */
12421 else if (unformat (input, "vni %d", &vni))
12427 errmsg ("parse error '%U'", format_unformat_error, input);
12432 if ((u8) ~ 0 == deid_type)
12434 errmsg ("missing params!");
12438 if (seid_type != deid_type)
12440 errmsg ("source and destination EIDs are of different types!");
12444 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12445 mp->is_add = is_add;
12446 mp->vni = htonl (vni);
12447 mp->seid_len = seid_len;
12448 mp->deid_len = deid_len;
12449 mp->eid_type = deid_type;
12451 switch (mp->eid_type)
12454 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12455 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12458 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12459 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12462 clib_memcpy (mp->seid, seid_mac, 6);
12463 clib_memcpy (mp->deid, deid_mac, 6);
12466 errmsg ("unknown EID type %d!", mp->eid_type);
12473 /* Wait for a reply... */
12481 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12483 unformat_input_t *input = vam->input;
12484 vl_api_lisp_gpe_add_del_iface_t *mp;
12486 u8 is_set = 0, is_add = 1, is_l2 = 0;
12489 /* Parse args required to build the message */
12490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12492 if (unformat (input, "up"))
12497 else if (unformat (input, "down"))
12502 else if (unformat (input, "table_id %d", &dp_table))
12506 else if (unformat (input, "bd_id %d", &dp_table))
12510 else if (unformat (input, "vni %d", &vni))
12520 errmsg ("Value not set\n");
12524 /* Construct the API message */
12525 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12527 mp->is_add = is_add;
12528 mp->dp_table = dp_table;
12535 /* Wait for a reply... */
12543 * Add/del map request itr rlocs from LISP control plane and updates
12545 * @param vam vpp API test context
12546 * @return return code
12549 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12551 unformat_input_t *input = vam->input;
12552 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12554 u8 *locator_set_name = 0;
12555 u8 locator_set_name_set = 0;
12558 /* Parse args required to build the message */
12559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12561 if (unformat (input, "del"))
12565 else if (unformat (input, "%_%v%_", &locator_set_name))
12567 locator_set_name_set = 1;
12571 clib_warning ("parse error '%U'", format_unformat_error, input);
12576 if (is_add && !locator_set_name_set)
12578 errmsg ("itr-rloc is not set!");
12582 if (is_add && vec_len (locator_set_name) > 64)
12584 errmsg ("itr-rloc locator-set name too long\n");
12585 vec_free (locator_set_name);
12589 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12590 mp->is_add = is_add;
12593 clib_memcpy (mp->locator_set_name, locator_set_name,
12594 vec_len (locator_set_name));
12598 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12600 vec_free (locator_set_name);
12605 /* Wait for a reply... */
12613 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12616 vl_api_lisp_locator_dump_t *mp;
12619 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12621 mp->locator_set_index = htonl (locator_set_index);
12622 mp->filter = filter;
12627 /* Use a control ping for synchronization */
12629 vl_api_noprint_control_ping_t *mp;
12630 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12633 /* Wait for a reply... */
12638 clean_locator_set_message (vat_main_t * vam)
12640 locator_set_msg_t *ls = 0;
12642 vec_foreach (ls, vam->locator_set_msg)
12644 vec_free (ls->locator_set_name);
12647 vec_free (vam->locator_set_msg);
12651 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12653 locator_set_msg_t *ls;
12654 locator_msg_t *loc;
12656 int i = 0, ret = 0;
12658 vec_foreach (ls, vam->locator_set_msg)
12660 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12663 vec_free (vam->locator_msg);
12664 clean_locator_set_message (vam);
12668 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12669 ls->locator_set_index,
12670 vec_len (vam->locator_msg) ? "" : "\n");
12672 vec_foreach (loc, vam->locator_msg)
12676 tmp_str = format (tmp_str, "%=37s", " ");
12680 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12681 loc->sw_if_index, loc->priority, loc->weight);
12685 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12686 loc->is_ipv6 ? format_ip6_address :
12687 format_ip4_address,
12688 loc->ip_address, loc->priority, loc->weight);
12693 fformat (vam->ofp, "%s", tmp_str);
12694 vec_free (tmp_str);
12695 vec_free (vam->locator_msg);
12698 clean_locator_set_message (vam);
12704 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
12706 locator_set_msg_t *ls;
12707 locator_msg_t *loc;
12708 vat_json_node_t *node = NULL;
12709 vat_json_node_t *locator_array;
12710 vat_json_node_t *locator;
12711 struct in6_addr ip6;
12712 struct in_addr ip4;
12715 if (!vec_len (vam->locator_set_msg))
12717 /* just print [] */
12718 vat_json_init_array (&vam->json_tree);
12719 vat_json_print (vam->ofp, &vam->json_tree);
12720 vam->json_tree.type = VAT_JSON_NONE;
12724 if (VAT_JSON_ARRAY != vam->json_tree.type)
12726 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12727 vat_json_init_array (&vam->json_tree);
12730 vec_foreach (ls, vam->locator_set_msg)
12732 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12735 vec_free (ls->locator_set_name);
12736 vec_free (vam->locator_msg);
12737 vec_free (vam->locator_set_msg);
12738 vat_json_free (&vam->json_tree);
12739 vam->json_tree.type = VAT_JSON_NONE;
12743 node = vat_json_array_add (&vam->json_tree);
12744 vat_json_init_object (node);
12746 vat_json_object_add_uint (node, "locator-set-index",
12747 ls->locator_set_index);
12748 vat_json_object_add_string_copy (node, "locator-set",
12749 ls->locator_set_name);
12750 locator_array = vat_json_object_add_list (node, "locator");
12751 vec_foreach (loc, vam->locator_msg)
12753 locator = vat_json_array_add (locator_array);
12754 vat_json_init_object (locator);
12757 vat_json_object_add_uint (locator, "locator-index",
12764 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
12765 vat_json_object_add_ip6 (locator, "locator", ip6);
12769 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
12770 vat_json_object_add_ip4 (locator, "locator", ip4);
12773 vat_json_object_add_uint (locator, "priority", loc->priority);
12774 vat_json_object_add_uint (locator, "weight", loc->weight);
12777 vec_free (ls->locator_set_name);
12778 vec_free (vam->locator_msg);
12781 vat_json_print (vam->ofp, &vam->json_tree);
12782 vat_json_free (&vam->json_tree);
12783 vam->json_tree.type = VAT_JSON_NONE;
12785 vec_free (vam->locator_set_msg);
12791 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
12792 u32 * locator_set_index)
12794 locator_set_msg_t *ls;
12797 *locator_set_index = ~0;
12799 if (!vec_len (vam->locator_set_msg))
12804 vec_foreach (ls, vam->locator_set_msg)
12806 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
12808 *locator_set_index = ls->locator_set_index;
12809 vec_free (vam->locator_set_msg);
12814 vec_free (vam->locator_set_msg);
12820 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
12821 u32 * locator_set_index)
12823 vl_api_lisp_locator_set_dump_t *mp;
12826 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12830 /* Use a control ping for synchronization */
12832 vl_api_noprint_control_ping_t *mp;
12833 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12837 vam->noprint_msg = 1;
12838 /* Wait for a reply... */
12842 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
12843 vam->noprint_msg = 0;
12852 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
12859 if (!vam->json_output)
12861 fformat (vam->ofp, "%=20s%=16s%=16s\n",
12862 "locator", "priority", "weight");
12867 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
12870 if (!ret && ~0 == locator_set_index)
12875 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
12881 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
12883 vl_api_lisp_locator_set_dump_t *mp;
12886 if (!vam->json_output)
12888 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
12889 "locator-set", "locator-set-index", "locator", "priority",
12893 vam->noprint_msg = 1;
12895 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12897 mp->filter = filter;
12902 /* Use a control ping for synchronization */
12904 vl_api_noprint_control_ping_t *mp;
12905 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12909 /* Wait for a reply... */
12913 if (vam->noprint_msg)
12915 if (!vam->json_output)
12917 print_locator_in_locator_set(vam, filter);
12921 json_locator_in_locator_set(vam, filter);
12924 vam->noprint_msg = 0;
12933 api_lisp_locator_set_dump (vat_main_t * vam)
12935 unformat_input_t *input = vam->input;
12936 vam->noprint_msg = 0;
12937 u32 locator_set_index = ~0;
12938 u8 locator_set_index_set = 0;
12939 u8 *locator_set = 0;
12940 u8 locator_set_set = 0;
12944 /* Parse args required to build the message */
12945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12947 if (unformat (input, "locator-set-index %u", &locator_set_index))
12949 locator_set_index_set = 1;
12951 else if (unformat (input, "locator-set %s", &locator_set))
12953 locator_set_set = 1;
12955 else if (unformat (input, "local"))
12959 else if (unformat (input, "remote"))
12969 if (locator_set_index_set && locator_set_set)
12971 errmsg ("use only input parameter!\n");
12975 if (locator_set_index_set || locator_set_set)
12977 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
12981 ret = lisp_locator_set_dump (vam, filter);
12984 vec_free (locator_set);
12990 api_lisp_eid_table_map_dump (vat_main_t * vam)
12992 vl_api_lisp_eid_table_map_dump_t *mp;
12995 if (!vam->json_output)
12997 fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
13000 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13005 /* Use a control ping for synchronization */
13007 vl_api_control_ping_t *mp;
13008 M (CONTROL_PING, control_ping);
13011 /* Wait for a reply... */
13019 get_locator_set (vat_main_t * vam)
13021 vl_api_lisp_locator_set_dump_t *mp;
13024 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13028 /* Use a control ping for synchronization */
13030 vl_api_noprint_control_ping_t *mp;
13031 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13035 /* Wait for a reply... */
13043 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13046 u8 *(*format_eid) (u8 *, va_list *) = 0;
13048 ASSERT (vam != NULL);
13049 ASSERT (eid_table != NULL);
13056 switch (eid_table->eid_type)
13060 format_eid = (eid_table->eid_type ? format_ip6_address :
13061 format_ip4_address);
13062 str = format (0, "[%d] %U/%d",
13063 clib_net_to_host_u32 (eid_table->vni),
13064 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13067 str = format (0, "[%d] %U",
13068 clib_net_to_host_u32 (eid_table->vni),
13069 format_ethernet_address, eid_table->eid);
13072 errmsg ("unknown EID type %d!", eid_table->eid_type);
13084 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13085 eid_table_t * eid_table)
13087 locator_set_msg_t *ls = 0;
13089 ASSERT (vam != NULL);
13090 ASSERT (eid_table != NULL);
13092 if (eid_table->is_local)
13094 vec_foreach (ls, vam->locator_set_msg)
13096 if (ls->locator_set_index == eid_table->locator_set_index)
13098 str = format (0, "local(%s)", ls->locator_set_name);
13103 str = format (0, "local(N/A)");
13107 str = format (0, "remote");
13114 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13115 eid_table_t * eid_table)
13117 locator_msg_t *loc = 0;
13118 int first_line = 1;
13120 ASSERT (vam != NULL);
13121 ASSERT (eid_table != NULL);
13123 vec_foreach (loc, vam->locator_msg)
13129 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13133 str = format (str, "%=55s%-U\n", " ",
13134 loc->is_ipv6 ? format_ip6_address :
13135 format_ip4_address, loc->ip_address);
13143 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13144 eid_table->ttl, eid_table->authoritative);
13148 str = format (str, "%-30U%-20u%-u\n",
13149 loc->is_ipv6 ? format_ip6_address :
13150 format_ip4_address,
13151 loc->ip_address, eid_table->ttl,
13152 eid_table->authoritative);
13161 print_lisp_eid_table_dump (vat_main_t * vam)
13163 eid_table_t *eid_table = 0;
13164 u8 *tmp_str = 0, *tmp_str2 = 0;
13167 ASSERT (vam != NULL);
13169 ret = get_locator_set (vam);
13172 vec_free (vam->eid_tables);
13176 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13177 "ttl", "authoritative");
13179 vec_foreach (eid_table, vam->eid_tables)
13181 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13184 vec_free (vam->locator_msg);
13185 clean_locator_set_message (vam);
13186 vec_free (vam->eid_tables);
13190 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13193 vec_free (vam->locator_msg);
13194 clean_locator_set_message (vam);
13195 vec_free (vam->eid_tables);
13199 tmp_str = format (0, "%-35s", tmp_str2);
13200 vec_free (tmp_str2);
13202 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13203 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13204 vec_free (tmp_str2);
13206 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13207 tmp_str = format (tmp_str, "%-s", tmp_str2);
13208 vec_free (tmp_str2);
13210 fformat (vam->ofp, "%s", tmp_str);
13211 vec_free (tmp_str);
13212 vec_free (vam->locator_msg);
13215 clean_locator_set_message (vam);
13216 vec_free (vam->eid_tables);
13222 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13223 eid_table_t * eid_table)
13225 locator_set_msg_t *ls = 0;
13228 ASSERT (vam != NULL);
13229 ASSERT (node != NULL);
13230 ASSERT (eid_table != NULL);
13232 if (eid_table->is_local)
13234 vec_foreach (ls, vam->locator_set_msg)
13236 if (ls->locator_set_index == eid_table->locator_set_index)
13238 vat_json_object_add_string_copy (node, "locator-set",
13239 ls->locator_set_name);
13244 s = format (0, "N/A");
13246 vat_json_object_add_string_copy (node, "locator-set", s);
13251 s = format (0, "remote");
13253 vat_json_object_add_string_copy (node, "locator-set", s);
13259 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13260 eid_table_t * eid_table)
13263 struct in6_addr ip6;
13264 struct in_addr ip4;
13266 ASSERT (vam != NULL);
13267 ASSERT (node != NULL);
13268 ASSERT (eid_table != NULL);
13270 switch (eid_table->eid_type)
13273 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13274 vat_json_object_add_ip4 (node, "eid", ip4);
13275 vat_json_object_add_uint (node, "eid-prefix-len",
13276 eid_table->eid_prefix_len);
13279 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13280 vat_json_object_add_ip6 (node, "eid", ip6);
13281 vat_json_object_add_uint (node, "eid-prefix-len",
13282 eid_table->eid_prefix_len);
13285 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13287 vat_json_object_add_string_copy (node, "eid", s);
13291 errmsg ("unknown EID type %d!", eid_table->eid_type);
13299 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13300 eid_table_t * eid_table)
13302 locator_msg_t *loc = 0;
13303 vat_json_node_t *locator_array = 0;
13304 vat_json_node_t *locator = 0;
13305 struct in6_addr ip6;
13306 struct in_addr ip4;
13308 ASSERT (vam != NULL);
13309 ASSERT (node != NULL);
13310 ASSERT (eid_table != NULL);
13312 locator_array = vat_json_object_add_list (node, "locator");
13313 vec_foreach (loc, vam->locator_msg)
13315 locator = vat_json_array_add (locator_array);
13316 vat_json_init_object (locator);
13319 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13325 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13326 vat_json_object_add_ip6 (locator, "locator", ip6);
13330 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13331 vat_json_object_add_ip4 (locator, "locator", ip4);
13338 json_lisp_eid_table_dump (vat_main_t * vam)
13340 eid_table_t *eid_table;
13341 vat_json_node_t *node = 0;
13344 ASSERT (vam != NULL);
13346 ret = get_locator_set (vam);
13349 vec_free (vam->eid_tables);
13353 if (!vec_len (vam->eid_tables))
13355 /* just print [] */
13356 vat_json_init_array (&vam->json_tree);
13357 vat_json_print (vam->ofp, &vam->json_tree);
13358 vam->json_tree.type = VAT_JSON_NONE;
13362 if (VAT_JSON_ARRAY != vam->json_tree.type)
13364 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13365 vat_json_init_array (&vam->json_tree);
13368 vec_foreach (eid_table, vam->eid_tables)
13370 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13373 vec_free (vam->locator_msg);
13374 vec_free (vam->eid_tables);
13375 clean_locator_set_message (vam);
13376 vat_json_free (&vam->json_tree);
13377 vam->json_tree.type = VAT_JSON_NONE;
13381 node = vat_json_array_add (&vam->json_tree);
13382 vat_json_init_object (node);
13384 vat_json_object_add_uint (node, "vni", eid_table->vni);
13386 json_locator_set_for_eid_table (vam, node, eid_table);
13387 ret = json_eid_for_eid_table (vam, node, eid_table);
13390 vec_free (vam->locator_msg);
13391 vec_free (vam->eid_tables);
13392 clean_locator_set_message (vam);
13393 vat_json_free (&vam->json_tree);
13394 vam->json_tree.type = VAT_JSON_NONE;
13398 json_locator_for_eid_table (vam, node, eid_table);
13400 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13401 vat_json_object_add_uint (node, "authoritative",
13402 eid_table->authoritative);
13404 vec_free (vam->locator_msg);
13407 vat_json_print (vam->ofp, &vam->json_tree);
13408 vat_json_free (&vam->json_tree);
13409 vam->json_tree.type = VAT_JSON_NONE;
13411 clean_locator_set_message (vam);
13412 vec_free (vam->eid_tables);
13418 api_lisp_eid_table_dump (vat_main_t * vam)
13420 unformat_input_t *i = vam->input;
13421 vl_api_lisp_eid_table_dump_t *mp;
13423 struct in_addr ip4;
13424 struct in6_addr ip6;
13426 u8 eid_type = ~0, eid_set = 0;
13427 u32 prefix_length = ~0, t, vni = 0;
13430 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13432 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13438 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13444 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13449 else if (unformat (i, "vni %d", &t))
13453 else if (unformat (i, "local"))
13457 else if (unformat (i, "remote"))
13463 errmsg ("parse error '%U'", format_unformat_error, i);
13468 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13470 mp->filter = filter;
13474 mp->vni = htonl (vni);
13475 mp->eid_type = eid_type;
13479 mp->prefix_length = prefix_length;
13480 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13483 mp->prefix_length = prefix_length;
13484 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13487 clib_memcpy (mp->eid, mac, sizeof (mac));
13490 errmsg ("unknown EID type %d!", eid_type);
13495 vam->noprint_msg = 1;
13500 /* Use a control ping for synchronization */
13502 vl_api_noprint_control_ping_t *mp;
13503 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13507 /* Wait for a reply... */
13511 if (vam->noprint_msg)
13513 if (!vam->json_output)
13515 vam->retval = print_lisp_eid_table_dump(vam);
13519 vam->retval = json_lisp_eid_table_dump(vam);
13522 vam->noprint_msg = 0;
13531 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13533 vl_api_lisp_gpe_tunnel_dump_t *mp;
13536 if (!vam->json_output)
13538 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13539 "%=16s%=16s%=16s%=16s%=16s\n",
13540 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13541 "Decap next", "Lisp version", "Flags", "Next protocol",
13542 "ver_res", "res", "iid");
13545 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13549 /* Use a control ping for synchronization */
13551 vl_api_control_ping_t *mp;
13552 M (CONTROL_PING, control_ping);
13555 /* Wait for a reply... */
13563 api_lisp_map_resolver_dump (vat_main_t * vam)
13565 vl_api_lisp_map_resolver_dump_t *mp;
13568 if (!vam->json_output)
13570 fformat (vam->ofp, "%=20s\n", "Map resolver");
13573 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13577 /* Use a control ping for synchronization */
13579 vl_api_control_ping_t *mp;
13580 M (CONTROL_PING, control_ping);
13583 /* Wait for a reply... */
13591 api_show_lisp_status (vat_main_t * vam)
13593 vl_api_show_lisp_status_t *mp;
13596 if (!vam->json_output)
13598 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13601 M (SHOW_LISP_STATUS, show_lisp_status);
13604 /* Wait for a reply... */
13612 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13614 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13617 if (!vam->json_output)
13619 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13622 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13625 /* Wait for a reply... */
13633 api_af_packet_create (vat_main_t * vam)
13635 unformat_input_t *i = vam->input;
13636 vl_api_af_packet_create_t *mp;
13638 u8 *host_if_name = 0;
13640 u8 random_hw_addr = 1;
13642 memset (hw_addr, 0, sizeof (hw_addr));
13644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13646 if (unformat (i, "name %s", &host_if_name))
13647 vec_add1 (host_if_name, 0);
13648 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13649 random_hw_addr = 0;
13654 if (!vec_len (host_if_name))
13656 errmsg ("host-interface name must be specified");
13660 if (vec_len (host_if_name) > 64)
13662 errmsg ("host-interface name too long");
13666 M (AF_PACKET_CREATE, af_packet_create);
13668 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13669 clib_memcpy (mp->hw_addr, hw_addr, 6);
13670 mp->use_random_hw_addr = random_hw_addr;
13671 vec_free (host_if_name);
13674 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13680 api_af_packet_delete (vat_main_t * vam)
13682 unformat_input_t *i = vam->input;
13683 vl_api_af_packet_delete_t *mp;
13685 u8 *host_if_name = 0;
13687 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13689 if (unformat (i, "name %s", &host_if_name))
13690 vec_add1 (host_if_name, 0);
13695 if (!vec_len (host_if_name))
13697 errmsg ("host-interface name must be specified");
13701 if (vec_len (host_if_name) > 64)
13703 errmsg ("host-interface name too long");
13707 M (AF_PACKET_DELETE, af_packet_delete);
13709 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13710 vec_free (host_if_name);
13719 api_policer_add_del (vat_main_t * vam)
13721 unformat_input_t *i = vam->input;
13722 vl_api_policer_add_del_t *mp;
13733 u8 color_aware = 0;
13734 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13736 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13738 if (unformat (i, "del"))
13740 else if (unformat (i, "name %s", &name))
13741 vec_add1 (name, 0);
13742 else if (unformat (i, "cir %u", &cir))
13744 else if (unformat (i, "eir %u", &eir))
13746 else if (unformat (i, "cb %u", &cb))
13748 else if (unformat (i, "eb %u", &eb))
13750 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13753 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13756 else if (unformat (i, "type %U", unformat_policer_type, &type))
13758 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13761 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13764 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13767 else if (unformat (i, "color-aware"))
13773 if (!vec_len (name))
13775 errmsg ("policer name must be specified");
13779 if (vec_len (name) > 64)
13781 errmsg ("policer name too long");
13785 M (POLICER_ADD_DEL, policer_add_del);
13787 clib_memcpy (mp->name, name, vec_len (name));
13789 mp->is_add = is_add;
13794 mp->rate_type = rate_type;
13795 mp->round_type = round_type;
13797 mp->conform_action_type = conform_action.action_type;
13798 mp->conform_dscp = conform_action.dscp;
13799 mp->exceed_action_type = exceed_action.action_type;
13800 mp->exceed_dscp = exceed_action.dscp;
13801 mp->violate_action_type = violate_action.action_type;
13802 mp->violate_dscp = violate_action.dscp;
13803 mp->color_aware = color_aware;
13812 api_policer_dump (vat_main_t * vam)
13814 unformat_input_t *i = vam->input;
13815 vl_api_policer_dump_t *mp;
13817 u8 *match_name = 0;
13818 u8 match_name_valid = 0;
13820 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13822 if (unformat (i, "name %s", &match_name))
13824 vec_add1 (match_name, 0);
13825 match_name_valid = 1;
13831 M (POLICER_DUMP, policer_dump);
13832 mp->match_name_valid = match_name_valid;
13833 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13834 vec_free (match_name);
13838 /* Use a control ping for synchronization */
13840 vl_api_control_ping_t *mp;
13841 M (CONTROL_PING, control_ping);
13844 /* Wait for a reply... */
13852 api_policer_classify_set_interface (vat_main_t * vam)
13854 unformat_input_t *i = vam->input;
13855 vl_api_policer_classify_set_interface_t *mp;
13858 int sw_if_index_set;
13859 u32 ip4_table_index = ~0;
13860 u32 ip6_table_index = ~0;
13861 u32 l2_table_index = ~0;
13864 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13866 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13867 sw_if_index_set = 1;
13868 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13869 sw_if_index_set = 1;
13870 else if (unformat (i, "del"))
13872 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13874 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13876 else if (unformat (i, "l2-table %d", &l2_table_index))
13880 clib_warning ("parse error '%U'", format_unformat_error, i);
13885 if (sw_if_index_set == 0)
13887 errmsg ("missing interface name or sw_if_index\n");
13891 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13893 mp->sw_if_index = ntohl (sw_if_index);
13894 mp->ip4_table_index = ntohl (ip4_table_index);
13895 mp->ip6_table_index = ntohl (ip6_table_index);
13896 mp->l2_table_index = ntohl (l2_table_index);
13897 mp->is_add = is_add;
13906 api_policer_classify_dump (vat_main_t * vam)
13908 unformat_input_t *i = vam->input;
13909 vl_api_policer_classify_dump_t *mp;
13911 u8 type = POLICER_CLASSIFY_N_TABLES;
13913 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13917 errmsg ("classify table type must be specified\n");
13921 if (!vam->json_output)
13923 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13926 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
13931 /* Use a control ping for synchronization */
13933 vl_api_control_ping_t *mp;
13934 M (CONTROL_PING, control_ping);
13937 /* Wait for a reply... */
13945 api_netmap_create (vat_main_t * vam)
13947 unformat_input_t *i = vam->input;
13948 vl_api_netmap_create_t *mp;
13952 u8 random_hw_addr = 1;
13956 memset (hw_addr, 0, sizeof (hw_addr));
13958 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13960 if (unformat (i, "name %s", &if_name))
13961 vec_add1 (if_name, 0);
13962 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13963 random_hw_addr = 0;
13964 else if (unformat (i, "pipe"))
13966 else if (unformat (i, "master"))
13968 else if (unformat (i, "slave"))
13974 if (!vec_len (if_name))
13976 errmsg ("interface name must be specified");
13980 if (vec_len (if_name) > 64)
13982 errmsg ("interface name too long");
13986 M (NETMAP_CREATE, netmap_create);
13988 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
13989 clib_memcpy (mp->hw_addr, hw_addr, 6);
13990 mp->use_random_hw_addr = random_hw_addr;
13991 mp->is_pipe = is_pipe;
13992 mp->is_master = is_master;
13993 vec_free (if_name);
14002 api_netmap_delete (vat_main_t * vam)
14004 unformat_input_t *i = vam->input;
14005 vl_api_netmap_delete_t *mp;
14009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14011 if (unformat (i, "name %s", &if_name))
14012 vec_add1 (if_name, 0);
14017 if (!vec_len (if_name))
14019 errmsg ("interface name must be specified");
14023 if (vec_len (if_name) > 64)
14025 errmsg ("interface name too long");
14029 M (NETMAP_DELETE, netmap_delete);
14031 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14032 vec_free (if_name);
14040 static void vl_api_mpls_gre_tunnel_details_t_handler
14041 (vl_api_mpls_gre_tunnel_details_t * mp)
14043 vat_main_t *vam = &vat_main;
14045 i32 len = ntohl (mp->nlabels);
14047 if (mp->l2_only == 0)
14049 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14050 ntohl (mp->tunnel_index),
14051 format_ip4_address, &mp->tunnel_src,
14052 format_ip4_address, &mp->tunnel_dst,
14053 format_ip4_address, &mp->intfc_address,
14054 ntohl (mp->mask_width));
14055 for (i = 0; i < len; i++)
14057 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14059 fformat (vam->ofp, "\n");
14060 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14061 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14065 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14066 ntohl (mp->tunnel_index),
14067 format_ip4_address, &mp->tunnel_src,
14068 format_ip4_address, &mp->tunnel_dst,
14069 format_ip4_address, &mp->intfc_address);
14070 for (i = 0; i < len; i++)
14072 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14074 fformat (vam->ofp, "\n");
14075 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14076 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14080 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14081 (vl_api_mpls_gre_tunnel_details_t * mp)
14083 vat_main_t *vam = &vat_main;
14084 vat_json_node_t *node = NULL;
14085 struct in_addr ip4;
14087 i32 len = ntohl (mp->nlabels);
14089 if (VAT_JSON_ARRAY != vam->json_tree.type)
14091 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14092 vat_json_init_array (&vam->json_tree);
14094 node = vat_json_array_add (&vam->json_tree);
14096 vat_json_init_object (node);
14097 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14098 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14099 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14100 vat_json_object_add_uint (node, "inner_fib_index",
14101 ntohl (mp->inner_fib_index));
14102 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14103 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14104 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14105 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14106 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14107 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14108 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14109 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14110 vat_json_object_add_uint (node, "outer_fib_index",
14111 ntohl (mp->outer_fib_index));
14112 vat_json_object_add_uint (node, "label_count", len);
14113 for (i = 0; i < len; i++)
14115 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14120 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14122 vl_api_mpls_gre_tunnel_dump_t *mp;
14126 /* Parse args required to build the message */
14127 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14129 if (!unformat (vam->input, "tunnel_index %d", &index))
14136 fformat (vam->ofp, " tunnel_index %d\n", index);
14138 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14139 mp->tunnel_index = htonl (index);
14142 /* Use a control ping for synchronization */
14144 vl_api_control_ping_t *mp;
14145 M (CONTROL_PING, control_ping);
14151 static void vl_api_mpls_eth_tunnel_details_t_handler
14152 (vl_api_mpls_eth_tunnel_details_t * mp)
14154 vat_main_t *vam = &vat_main;
14156 i32 len = ntohl (mp->nlabels);
14158 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14159 ntohl (mp->tunnel_index),
14160 format_ethernet_address, &mp->tunnel_dst_mac,
14161 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14162 for (i = 0; i < len; i++)
14164 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14166 fformat (vam->ofp, "\n");
14167 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14168 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14171 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14172 (vl_api_mpls_eth_tunnel_details_t * mp)
14174 vat_main_t *vam = &vat_main;
14175 vat_json_node_t *node = NULL;
14176 struct in_addr ip4;
14178 i32 len = ntohl (mp->nlabels);
14180 if (VAT_JSON_ARRAY != vam->json_tree.type)
14182 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14183 vat_json_init_array (&vam->json_tree);
14185 node = vat_json_array_add (&vam->json_tree);
14187 vat_json_init_object (node);
14188 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14189 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14190 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14191 vat_json_object_add_uint (node, "inner_fib_index",
14192 ntohl (mp->inner_fib_index));
14193 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14194 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14195 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14196 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14197 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14198 format (0, "%U", format_ethernet_address,
14199 &mp->tunnel_dst_mac));
14200 vat_json_object_add_uint (node, "tx_sw_if_index",
14201 ntohl (mp->tx_sw_if_index));
14202 vat_json_object_add_uint (node, "label_count", len);
14203 for (i = 0; i < len; i++)
14205 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14210 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14212 vl_api_mpls_eth_tunnel_dump_t *mp;
14216 /* Parse args required to build the message */
14217 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14219 if (!unformat (vam->input, "tunnel_index %d", &index))
14226 fformat (vam->ofp, " tunnel_index %d\n", index);
14228 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14229 mp->tunnel_index = htonl (index);
14232 /* Use a control ping for synchronization */
14234 vl_api_control_ping_t *mp;
14235 M (CONTROL_PING, control_ping);
14241 static void vl_api_mpls_fib_encap_details_t_handler
14242 (vl_api_mpls_fib_encap_details_t * mp)
14244 vat_main_t *vam = &vat_main;
14246 i32 len = ntohl (mp->nlabels);
14248 fformat (vam->ofp, "table %d, dest %U, label ",
14249 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14250 for (i = 0; i < len; i++)
14252 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14254 fformat (vam->ofp, "\n");
14257 static void vl_api_mpls_fib_encap_details_t_handler_json
14258 (vl_api_mpls_fib_encap_details_t * mp)
14260 vat_main_t *vam = &vat_main;
14261 vat_json_node_t *node = NULL;
14263 i32 len = ntohl (mp->nlabels);
14264 struct in_addr ip4;
14266 if (VAT_JSON_ARRAY != vam->json_tree.type)
14268 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14269 vat_json_init_array (&vam->json_tree);
14271 node = vat_json_array_add (&vam->json_tree);
14273 vat_json_init_object (node);
14274 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14275 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14276 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14277 vat_json_object_add_ip4 (node, "dest", ip4);
14278 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14279 vat_json_object_add_uint (node, "label_count", len);
14280 for (i = 0; i < len; i++)
14282 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14287 api_mpls_fib_encap_dump (vat_main_t * vam)
14289 vl_api_mpls_fib_encap_dump_t *mp;
14292 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14295 /* Use a control ping for synchronization */
14297 vl_api_control_ping_t *mp;
14298 M (CONTROL_PING, control_ping);
14304 static void vl_api_mpls_fib_decap_details_t_handler
14305 (vl_api_mpls_fib_decap_details_t * mp)
14307 vat_main_t *vam = &vat_main;
14310 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14311 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14312 ntohl (mp->label), ntohl (mp->s_bit));
14315 static void vl_api_mpls_fib_decap_details_t_handler_json
14316 (vl_api_mpls_fib_decap_details_t * mp)
14318 vat_main_t *vam = &vat_main;
14319 vat_json_node_t *node = NULL;
14320 struct in_addr ip4;
14322 if (VAT_JSON_ARRAY != vam->json_tree.type)
14324 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14325 vat_json_init_array (&vam->json_tree);
14327 node = vat_json_array_add (&vam->json_tree);
14329 vat_json_init_object (node);
14330 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14331 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14332 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14333 vat_json_object_add_ip4 (node, "dest", ip4);
14334 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14335 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14336 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14337 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14338 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14342 api_mpls_fib_decap_dump (vat_main_t * vam)
14344 vl_api_mpls_fib_decap_dump_t *mp;
14347 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14350 /* Use a control ping for synchronization */
14352 vl_api_control_ping_t *mp;
14353 M (CONTROL_PING, control_ping);
14360 api_classify_table_ids (vat_main_t * vam)
14362 vl_api_classify_table_ids_t *mp;
14365 /* Construct the API message */
14366 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14376 api_classify_table_by_interface (vat_main_t * vam)
14378 unformat_input_t *input = vam->input;
14379 vl_api_classify_table_by_interface_t *mp;
14382 u32 sw_if_index = ~0;
14383 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14385 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14387 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14392 if (sw_if_index == ~0)
14394 errmsg ("missing interface name or sw_if_index\n");
14398 /* Construct the API message */
14399 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14401 mp->sw_if_index = ntohl (sw_if_index);
14410 api_classify_table_info (vat_main_t * vam)
14412 unformat_input_t *input = vam->input;
14413 vl_api_classify_table_info_t *mp;
14417 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14419 if (unformat (input, "table_id %d", &table_id))
14424 if (table_id == ~0)
14426 errmsg ("missing table id\n");
14430 /* Construct the API message */
14431 M (CLASSIFY_TABLE_INFO, classify_table_info);
14433 mp->table_id = ntohl (table_id);
14442 api_classify_session_dump (vat_main_t * vam)
14444 unformat_input_t *input = vam->input;
14445 vl_api_classify_session_dump_t *mp;
14449 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14451 if (unformat (input, "table_id %d", &table_id))
14456 if (table_id == ~0)
14458 errmsg ("missing table id\n");
14462 /* Construct the API message */
14463 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14465 mp->table_id = ntohl (table_id);
14468 /* Use a control ping for synchronization */
14470 vl_api_control_ping_t *mp;
14471 M (CONTROL_PING, control_ping);
14480 vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
14482 vat_main_t *vam = &vat_main;
14484 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14485 "src_address %U, fib_index %u, path_mtu %u, "
14486 "template_interval %u\n",
14487 format_ip4_address, mp->collector_address,
14488 ntohs (mp->collector_port),
14489 format_ip4_address, mp->src_address,
14490 ntohl (mp->fib_index),
14491 ntohl (mp->path_mtu), ntohl (mp->template_interval));
14494 vam->result_ready = 1;
14498 vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp)
14500 vat_main_t *vam = &vat_main;
14501 vat_json_node_t node;
14502 struct in_addr collector_address;
14503 struct in_addr src_address;
14505 vat_json_init_object (&node);
14506 clib_memcpy (&collector_address, &mp->collector_address,
14507 sizeof (collector_address));
14508 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14509 vat_json_object_add_uint (&node, "collector_port",
14510 ntohs (mp->collector_port));
14511 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14512 vat_json_object_add_ip4 (&node, "src_address", src_address);
14513 vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index));
14514 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14515 vat_json_object_add_uint (&node, "template_interval",
14516 ntohl (mp->template_interval));
14518 vat_json_print (vam->ofp, &node);
14519 vat_json_free (&node);
14521 vam->result_ready = 1;
14525 api_ipfix_dump (vat_main_t * vam)
14527 vl_api_ipfix_dump_t *mp;
14530 /* Construct the API message */
14531 M (IPFIX_DUMP, ipfix_dump);
14541 api_pg_create_interface (vat_main_t * vam)
14543 unformat_input_t *input = vam->input;
14544 vl_api_pg_create_interface_t *mp;
14548 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14550 if (unformat (input, "if_id %d", &if_id))
14557 errmsg ("missing pg interface index\n");
14561 /* Construct the API message */
14562 M (PG_CREATE_INTERFACE, pg_create_interface);
14564 mp->interface_id = ntohl (if_id);
14573 api_pg_capture (vat_main_t * vam)
14575 unformat_input_t *input = vam->input;
14576 vl_api_pg_capture_t *mp;
14582 u8 pcap_file_set = 0;
14584 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14586 if (unformat (input, "if_id %d", &if_id))
14588 else if (unformat (input, "pcap %s", &pcap_file))
14590 else if (unformat (input, "count %d", &count))
14592 else if (unformat (input, "disable"))
14599 errmsg ("missing pg interface index\n");
14602 if (pcap_file_set > 0)
14604 if (vec_len (pcap_file) > 255)
14606 errmsg ("pcap file name is too long\n");
14611 u32 name_len = vec_len (pcap_file);
14612 /* Construct the API message */
14613 M (PG_CAPTURE, pg_capture);
14615 mp->interface_id = ntohl (if_id);
14616 mp->is_enabled = enable;
14617 mp->count = ntohl (count);
14618 mp->pcap_name_length = ntohl (name_len);
14619 if (pcap_file_set != 0)
14621 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14623 vec_free (pcap_file);
14632 api_pg_enable_disable (vat_main_t * vam)
14634 unformat_input_t *input = vam->input;
14635 vl_api_pg_enable_disable_t *mp;
14639 u8 stream_name_set = 0;
14640 u8 *stream_name = 0;
14641 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14643 if (unformat (input, "stream %s", &stream_name))
14644 stream_name_set = 1;
14645 else if (unformat (input, "disable"))
14651 if (stream_name_set > 0)
14653 if (vec_len (stream_name) > 255)
14655 errmsg ("stream name too long\n");
14660 u32 name_len = vec_len (stream_name);
14661 /* Construct the API message */
14662 M (PG_ENABLE_DISABLE, pg_enable_disable);
14664 mp->is_enabled = enable;
14665 if (stream_name_set != 0)
14667 mp->stream_name_length = ntohl (name_len);
14668 clib_memcpy (mp->stream_name, stream_name, name_len);
14670 vec_free (stream_name);
14679 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14681 unformat_input_t *input = vam->input;
14682 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14685 u16 *low_ports = 0;
14686 u16 *high_ports = 0;
14689 ip4_address_t ip4_addr;
14690 ip6_address_t ip6_addr;
14698 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14700 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14706 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14711 else if (unformat (input, "vrf %d", &vrf_id))
14713 else if (unformat (input, "del"))
14715 else if (unformat (input, "port %d", &tmp))
14717 if (tmp == 0 || tmp > 65535)
14719 errmsg ("port %d out of range", tmp);
14723 this_hi = this_low + 1;
14724 vec_add1 (low_ports, this_low);
14725 vec_add1 (high_ports, this_hi);
14727 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14729 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14731 errmsg ("incorrect range parameters\n");
14735 /* Note: in debug CLI +1 is added to high before
14736 passing to real fn that does "the work"
14737 (ip_source_and_port_range_check_add_del).
14738 This fn is a wrapper around the binary API fn a
14739 control plane will call, which expects this increment
14740 to have occurred. Hence letting the binary API control
14741 plane fn do the increment for consistency between VAT
14742 and other control planes.
14745 vec_add1 (low_ports, this_low);
14746 vec_add1 (high_ports, this_hi);
14752 if (prefix_set == 0)
14754 errmsg ("<address>/<mask> not specified\n");
14760 errmsg ("VRF ID required, not specified\n");
14767 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14771 if (vec_len (low_ports) == 0)
14773 errmsg ("At least one port or port range required\n");
14777 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14778 ip_source_and_port_range_check_add_del);
14780 mp->is_add = is_add;
14785 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14790 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14793 mp->mask_length = length;
14794 mp->number_of_ranges = vec_len (low_ports);
14796 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14797 vec_free (low_ports);
14799 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14800 vec_free (high_ports);
14802 mp->vrf_id = ntohl (vrf_id);
14811 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14813 unformat_input_t *input = vam->input;
14814 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14816 u32 sw_if_index = ~0;
14818 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14819 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14822 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14824 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14826 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14828 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14830 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14832 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14834 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14836 else if (unformat (input, "del"))
14842 if (sw_if_index == ~0)
14844 errmsg ("Interface required but not specified\n");
14850 errmsg ("VRF ID required but not specified\n");
14854 if (tcp_out_vrf_id == 0
14855 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14858 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14862 /* Construct the API message */
14863 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14864 ip_source_and_port_range_check_interface_add_del);
14866 mp->sw_if_index = ntohl (sw_if_index);
14867 mp->is_add = is_add;
14868 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14869 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14870 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14871 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14876 /* Wait for a reply... */
14881 q_or_quit (vat_main_t * vam)
14883 longjmp (vam->jump_buf, 1);
14884 return 0; /* not so much */
14888 q (vat_main_t * vam)
14890 return q_or_quit (vam);
14894 quit (vat_main_t * vam)
14896 return q_or_quit (vam);
14900 comment (vat_main_t * vam)
14906 cmd_cmp (void *a1, void *a2)
14911 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
14915 help (vat_main_t * vam)
14920 unformat_input_t *i = vam->input;
14923 if (unformat (i, "%s", &name))
14927 vec_add1 (name, 0);
14929 hs = hash_get_mem (vam->help_by_name, name);
14931 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
14933 fformat (vam->ofp, "No such msg / command '%s'\n", name);
14938 fformat (vam->ofp, "Help is available for the following:\n");
14941 hash_foreach_pair (p, vam->function_by_name,
14943 vec_add1 (cmds, (u8 *)(p->key));
14947 vec_sort_with_function (cmds, cmd_cmp);
14949 for (j = 0; j < vec_len (cmds); j++)
14950 fformat (vam->ofp, "%s\n", cmds[j]);
14957 set (vat_main_t * vam)
14959 u8 *name = 0, *value = 0;
14960 unformat_input_t *i = vam->input;
14962 if (unformat (i, "%s", &name))
14964 /* The input buffer is a vector, not a string. */
14965 value = vec_dup (i->buffer);
14966 vec_delete (value, i->index, 0);
14967 /* Almost certainly has a trailing newline */
14968 if (value[vec_len (value) - 1] == '\n')
14969 value[vec_len (value) - 1] = 0;
14970 /* Make sure it's a proper string, one way or the other */
14971 vec_add1 (value, 0);
14972 (void) clib_macro_set_value (&vam->macro_main,
14973 (char *) name, (char *) value);
14976 errmsg ("usage: set <name> <value>\n");
14984 unset (vat_main_t * vam)
14988 if (unformat (vam->input, "%s", &name))
14989 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
14990 errmsg ("unset: %s wasn't set\n", name);
15003 macro_sort_cmp (void *a1, void *a2)
15005 macro_sort_t *s1 = a1;
15006 macro_sort_t *s2 = a2;
15008 return strcmp ((char *) (s1->name), (char *) (s2->name));
15012 dump_macro_table (vat_main_t * vam)
15014 macro_sort_t *sort_me = 0, *sm;
15019 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15021 vec_add2 (sort_me, sm, 1);
15022 sm->name = (u8 *)(p->key);
15023 sm->value = (u8 *) (p->value[0]);
15027 vec_sort_with_function (sort_me, macro_sort_cmp);
15029 if (vec_len (sort_me))
15030 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15032 fformat (vam->ofp, "The macro table is empty...\n");
15034 for (i = 0; i < vec_len (sort_me); i++)
15035 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15040 dump_node_table (vat_main_t * vam)
15043 vlib_node_t *node, *next_node;
15045 if (vec_len (vam->graph_nodes) == 0)
15047 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15051 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15053 node = vam->graph_nodes[i];
15054 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15055 for (j = 0; j < vec_len (node->next_nodes); j++)
15057 if (node->next_nodes[j] != ~0)
15059 next_node = vam->graph_nodes[node->next_nodes[j]];
15060 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15068 search_node_table (vat_main_t * vam)
15070 unformat_input_t *line_input = vam->input;
15073 vlib_node_t *node, *next_node;
15076 if (vam->graph_node_index_by_name == 0)
15078 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15082 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15084 if (unformat (line_input, "%s", &node_to_find))
15086 vec_add1 (node_to_find, 0);
15087 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15090 fformat (vam->ofp, "%s not found...\n", node_to_find);
15093 node = vam->graph_nodes[p[0]];
15094 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15095 for (j = 0; j < vec_len (node->next_nodes); j++)
15097 if (node->next_nodes[j] != ~0)
15099 next_node = vam->graph_nodes[node->next_nodes[j]];
15100 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15107 clib_warning ("parse error '%U'", format_unformat_error,
15113 vec_free (node_to_find);
15122 script (vat_main_t * vam)
15125 char *save_current_file;
15126 unformat_input_t save_input;
15127 jmp_buf save_jump_buf;
15128 u32 save_line_number;
15130 FILE *new_fp, *save_ifp;
15132 if (unformat (vam->input, "%s", &s))
15134 new_fp = fopen ((char *) s, "r");
15137 errmsg ("Couldn't open script file %s\n", s);
15144 errmsg ("Missing script name\n");
15148 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15149 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15150 save_ifp = vam->ifp;
15151 save_line_number = vam->input_line_number;
15152 save_current_file = (char *) vam->current_file;
15154 vam->input_line_number = 0;
15156 vam->current_file = s;
15159 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15160 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15161 vam->ifp = save_ifp;
15162 vam->input_line_number = save_line_number;
15163 vam->current_file = (u8 *) save_current_file;
15170 echo (vat_main_t * vam)
15172 fformat (vam->ofp, "%v", vam->input->buffer);
15176 /* List of API message constructors, CLI names map to api_xxx */
15177 #define foreach_vpe_api_msg \
15178 _(create_loopback,"[mac <mac-addr>]") \
15179 _(sw_interface_dump,"") \
15180 _(sw_interface_set_flags, \
15181 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15182 _(sw_interface_add_del_address, \
15183 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15184 _(sw_interface_set_table, \
15185 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15186 _(sw_interface_set_vpath, \
15187 "<intfc> | sw_if_index <id> enable | disable") \
15188 _(sw_interface_set_l2_xconnect, \
15189 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15190 "enable | disable") \
15191 _(sw_interface_set_l2_bridge, \
15192 "rx <intfc> | rx_sw_if_index <id> bd_id <bridge-domain-id>\n" \
15193 "[shg <split-horizon-group>] [bvi]\n" \
15194 "enable | disable") \
15195 _(bridge_domain_add_del, \
15196 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15197 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15199 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15201 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15203 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15205 "tapname <name> mac <mac-addr> | random-mac") \
15207 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15209 "<vpp-if-name> | sw_if_index <id>") \
15210 _(sw_interface_tap_dump, "") \
15211 _(ip_add_del_route, \
15212 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15213 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15214 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15215 "[multipath] [count <n>]") \
15216 _(proxy_arp_add_del, \
15217 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15218 _(proxy_arp_intfc_enable_disable, \
15219 "<intfc> | sw_if_index <id> enable | disable") \
15220 _(mpls_add_del_encap, \
15221 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15222 _(mpls_add_del_decap, \
15223 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15224 _(mpls_gre_add_del_tunnel, \
15225 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15226 "adj <ip4-address>/<mask-width> [del]") \
15227 _(sw_interface_set_unnumbered, \
15228 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15229 _(ip_neighbor_add_del, \
15230 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15231 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15232 _(reset_vrf, "vrf <id> [ipv6]") \
15233 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15234 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15235 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15236 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15237 "[outer_vlan_id_any][inner_vlan_id_any]") \
15238 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15239 _(reset_fib, "vrf <n> [ipv6]") \
15240 _(dhcp_proxy_config, \
15241 "svr <v46-address> src <v46-address>\n" \
15242 "insert-cid <n> [del]") \
15243 _(dhcp_proxy_config_2, \
15244 "svr <v46-address> src <v46-address>\n" \
15245 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15246 _(dhcp_proxy_set_vss, \
15247 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15248 _(dhcp_client_config, \
15249 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15250 _(set_ip_flow_hash, \
15251 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15252 _(sw_interface_ip6_enable_disable, \
15253 "<intfc> | sw_if_index <id> enable | disable") \
15254 _(sw_interface_ip6_set_link_local_address, \
15255 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15256 _(sw_interface_ip6nd_ra_prefix, \
15257 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15258 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15259 "[nolink] [isno]") \
15260 _(sw_interface_ip6nd_ra_config, \
15261 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15262 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15263 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15264 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15265 _(l2_patch_add_del, \
15266 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15267 "enable | disable") \
15268 _(mpls_ethernet_add_del_tunnel, \
15269 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15270 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15271 _(mpls_ethernet_add_del_tunnel_2, \
15272 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15273 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15274 _(sr_tunnel_add_del, \
15275 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15276 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15277 "[policy <policy_name>]") \
15278 _(sr_policy_add_del, \
15279 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15280 _(sr_multicast_map_add_del, \
15281 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15282 _(classify_add_del_table, \
15283 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15284 "[del] mask <mask-value>\n" \
15285 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15286 _(classify_add_del_session, \
15287 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15288 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15289 " [l3 [ip4|ip6]]") \
15290 _(classify_set_interface_ip_table, \
15291 "<intfc> | sw_if_index <nn> table <nn>") \
15292 _(classify_set_interface_l2_tables, \
15293 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15294 " [other-table <nn>]") \
15295 _(get_node_index, "node <node-name") \
15296 _(add_node_next, "node <node-name> next <next-node-name>") \
15297 _(l2tpv3_create_tunnel, \
15298 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15299 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15300 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15301 _(l2tpv3_set_tunnel_cookies, \
15302 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15303 "[new_remote_cookie <nn>]\n") \
15304 _(l2tpv3_interface_enable_disable, \
15305 "<intfc> | sw_if_index <nn> enable | disable") \
15306 _(l2tpv3_set_lookup_key, \
15307 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15308 _(sw_if_l2tpv3_tunnel_dump, "") \
15309 _(vxlan_add_del_tunnel, \
15310 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15311 " [decap-next l2|ip4|ip6] [del]") \
15312 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15313 _(gre_add_del_tunnel, \
15314 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15315 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15316 _(l2_fib_clear_table, "") \
15317 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15318 _(l2_interface_vlan_tag_rewrite, \
15319 "<intfc> | sw_if_index <nn> \n" \
15320 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15321 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15322 _(create_vhost_user_if, \
15323 "socket <filename> [server] [renumber <dev_instance>] " \
15324 "[mac <mac_address>]") \
15325 _(modify_vhost_user_if, \
15326 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15327 "[server] [renumber <dev_instance>]") \
15328 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15329 _(sw_interface_vhost_user_dump, "") \
15330 _(show_version, "") \
15331 _(vxlan_gpe_add_del_tunnel, \
15332 "local <addr> remote <addr> vni <nn>\n" \
15333 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15334 "[next-ethernet] [next-nsh]\n") \
15335 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15336 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15337 _(interface_name_renumber, \
15338 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15339 _(input_acl_set_interface, \
15340 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15341 " [l2-table <nn>] [del]") \
15342 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15343 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15344 _(ip_dump, "ipv4 | ipv6") \
15345 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15346 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15348 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15349 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15350 " integ_alg <alg> integ_key <hex>") \
15351 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15352 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15353 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15354 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15355 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15356 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15357 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15358 "(auth_data 0x<data> | auth_data <data>)") \
15359 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15360 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15361 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15362 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15363 "(local|remote)") \
15364 _(ikev2_set_local_key, "file <absolute_file_path>") \
15365 _(delete_loopback,"sw_if_index <nn>") \
15366 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15367 _(map_add_domain, \
15368 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15369 "ip6-src <ip6addr> " \
15370 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15371 _(map_del_domain, "index <n>") \
15372 _(map_add_del_rule, \
15373 "index <n> psid <n> dst <ip6addr> [del]") \
15374 _(map_domain_dump, "") \
15375 _(map_rule_dump, "index <map-domain>") \
15376 _(want_interface_events, "enable|disable") \
15377 _(want_stats,"enable|disable") \
15378 _(get_first_msg_id, "client <name>") \
15379 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15380 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15381 "fib-id <nn> [ip4][ip6][default]") \
15382 _(get_node_graph, " ") \
15383 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15384 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
15385 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
15386 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
15387 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
15388 " vrf_id <nn> add | pop | none") \
15389 _(trace_profile_del, "") \
15390 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15391 " sw_if_index <sw_if_index> p <priority> " \
15392 "w <weight>] [del]") \
15393 _(lisp_add_del_locator, "locator-set <locator_name> " \
15394 "iface <intf> | sw_if_index <sw_if_index> " \
15395 "p <priority> w <weight> [del]") \
15396 _(lisp_add_del_local_eid,"vni <vni> eid " \
15397 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15398 "locator-set <locator_name> [del]") \
15399 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15400 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15401 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15402 _(lisp_gpe_enable_disable, "enable|disable") \
15403 _(lisp_enable_disable, "enable|disable") \
15404 _(lisp_gpe_add_del_iface, "up|down") \
15405 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
15406 "rloc <locator> p <prio> " \
15407 "w <weight> [rloc <loc> ... ] " \
15408 "action <action> [del-all]") \
15409 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15410 "<src-eid> rloc <locator> p <prio> w <weight>"\
15411 "[rloc <loc> ... ] action <action>") \
15412 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15413 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15414 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15415 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
15416 "locator-set <loc-set-name>] [local | remote]")\
15417 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15418 "[local] | [remote]") \
15419 _(lisp_eid_table_map_dump, "") \
15420 _(lisp_gpe_tunnel_dump, "") \
15421 _(lisp_map_resolver_dump, "") \
15422 _(show_lisp_status, "") \
15423 _(lisp_get_map_request_itr_rlocs, "") \
15424 _(show_lisp_pitr, "") \
15425 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15426 _(af_packet_delete, "name <host interface name>") \
15427 _(policer_add_del, "name <policer name> <params> [del]") \
15428 _(policer_dump, "[name <policer name>]") \
15429 _(policer_classify_set_interface, \
15430 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15431 " [l2-table <nn>] [del]") \
15432 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15433 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15434 "[master|slave]") \
15435 _(netmap_delete, "name <interface name>") \
15436 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15437 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15438 _(mpls_fib_encap_dump, "") \
15439 _(mpls_fib_decap_dump, "") \
15440 _(classify_table_ids, "") \
15441 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15442 _(classify_table_info, "table_id <nn>") \
15443 _(classify_session_dump, "table_id <nn>") \
15444 _(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
15445 "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
15446 "[template_interval <nn>]") \
15447 _(ipfix_dump, "") \
15448 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15449 _(pg_create_interface, "if_id <nn>") \
15450 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15451 _(pg_enable_disable, "[stream <id>] disable") \
15452 _(ip_source_and_port_range_check_add_del, \
15453 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15454 _(ip_source_and_port_range_check_interface_add_del, \
15455 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15456 "[udp-in-vrf <id>] [udp-out-vrf <id>]")
15458 /* List of command functions, CLI names map directly to functions */
15459 #define foreach_cli_function \
15460 _(comment, "usage: comment <ignore-rest-of-line>") \
15461 _(dump_interface_table, "usage: dump_interface_table") \
15462 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15463 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15464 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15465 _(dump_stats_table, "usage: dump_stats_table") \
15466 _(dump_macro_table, "usage: dump_macro_table ") \
15467 _(dump_node_table, "usage: dump_node_table") \
15468 _(echo, "usage: echo <message>") \
15469 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15470 _(help, "usage: help") \
15471 _(q, "usage: quit") \
15472 _(quit, "usage: quit") \
15473 _(search_node_table, "usage: search_node_table <name>...") \
15474 _(set, "usage: set <variable-name> <value>") \
15475 _(script, "usage: script <file-name>") \
15476 _(unset, "usage: unset <variable-name>")
15479 static void vl_api_##n##_t_handler_uni \
15480 (vl_api_##n##_t * mp) \
15482 vat_main_t * vam = &vat_main; \
15483 if (vam->json_output) { \
15484 vl_api_##n##_t_handler_json(mp); \
15486 vl_api_##n##_t_handler(mp); \
15489 foreach_vpe_api_reply_msg;
15493 vat_api_hookup (vat_main_t * vam)
15496 vl_msg_api_set_handlers(VL_API_##N, #n, \
15497 vl_api_##n##_t_handler_uni, \
15499 vl_api_##n##_t_endian, \
15500 vl_api_##n##_t_print, \
15501 sizeof(vl_api_##n##_t), 1);
15502 foreach_vpe_api_reply_msg;
15505 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15507 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15509 vam->function_by_name = hash_create_string (0, sizeof (uword));
15511 vam->help_by_name = hash_create_string (0, sizeof (uword));
15513 /* API messages we can send */
15514 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15515 foreach_vpe_api_msg;
15519 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15520 foreach_vpe_api_msg;
15523 /* CLI functions */
15524 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15525 foreach_cli_function;
15529 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15530 foreach_cli_function;
15534 #undef vl_api_version
15535 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15536 #include <vpp-api/vpe.api.h>
15537 #undef vl_api_version
15540 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15543 * Send the main API signature in slot 0. This bit of code must
15544 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15546 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15550 * fd.io coding-style-patch-verification: ON
15553 * eval: (c-set-style "gnu")