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 memset(&rloc, 0, sizeof(rloc));
11853 /* Parse args required to build the message */
11854 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11856 if (unformat (input, "del"))
11860 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
11864 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
11868 else if (unformat (input, "p %d w %d", &p, &w))
11872 errmsg ("No RLOC configured for setting priority/weight!");
11875 curr_rloc->priority = p;
11876 curr_rloc->weight = w;
11878 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
11879 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
11883 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
11884 rloc.priority = rloc.weight = 0;
11885 vec_add1 (lcl_locs, rloc);
11887 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
11888 vec_add1 (rmt_locs, rloc);
11889 /* priority and weight saved in rmt loc */
11890 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11892 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
11893 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
11896 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
11897 rloc.priority = rloc.weight = 0;
11898 vec_add1 (lcl_locs, rloc);
11900 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
11901 vec_add1 (rmt_locs, rloc);
11902 /* priority and weight saved in rmt loc */
11903 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
11905 else if (unformat (input, "action %d", &action))
11911 clib_warning ("parse error '%U'", format_unformat_error, input);
11918 errmsg ("remote eid addresses not set\n");
11922 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
11924 errmsg ("eid types don't match\n");
11928 if (0 == rmt_locs && (u32) ~0 == action)
11930 errmsg ("action not set for negative mapping\n");
11934 /* Construct the API message */
11935 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
11937 mp->is_add = is_add;
11938 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
11939 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
11940 mp->eid_type = rmt_eid->type;
11941 mp->rmt_len = rmt_eid->len;
11942 mp->lcl_len = lcl_eid->len;
11943 mp->action = action;
11945 if (0 != rmt_locs && 0 != lcl_locs)
11947 mp->loc_num = vec_len(rmt_locs);
11948 clib_memcpy (mp->lcl_locs, lcl_locs,
11949 (sizeof(rloc_t) * vec_len(lcl_locs)));
11950 clib_memcpy (mp->rmt_locs, rmt_locs,
11951 (sizeof(rloc_t) * vec_len(rmt_locs)));
11953 vec_free (lcl_locs);
11954 vec_free (rmt_locs);
11959 /* Wait for a reply... */
11967 api_lisp_add_del_map_resolver (vat_main_t * vam)
11969 unformat_input_t *input = vam->input;
11970 vl_api_lisp_add_del_map_resolver_t *mp;
11975 ip4_address_t ipv4;
11976 ip6_address_t ipv6;
11978 /* Parse args required to build the message */
11979 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
11981 if (unformat (input, "del"))
11985 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
11989 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
11997 if (ipv4_set && ipv6_set)
11999 errmsg ("both eid v4 and v6 addresses set\n");
12003 if (!ipv4_set && !ipv6_set)
12005 errmsg ("eid addresses not set\n");
12009 /* Construct the API message */
12010 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
12012 mp->is_add = is_add;
12016 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
12021 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
12027 /* Wait for a reply... */
12035 api_lisp_gpe_enable_disable (vat_main_t * vam)
12037 unformat_input_t *input = vam->input;
12038 vl_api_lisp_gpe_enable_disable_t *mp;
12043 /* Parse args required to build the message */
12044 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12046 if (unformat (input, "enable"))
12051 else if (unformat (input, "disable"))
12062 errmsg ("Value not set\n");
12066 /* Construct the API message */
12067 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
12074 /* Wait for a reply... */
12082 api_lisp_enable_disable (vat_main_t * vam)
12084 unformat_input_t *input = vam->input;
12085 vl_api_lisp_enable_disable_t *mp;
12090 /* Parse args required to build the message */
12091 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12093 if (unformat (input, "enable"))
12098 else if (unformat (input, "disable"))
12108 errmsg ("Value not set\n");
12112 /* Construct the API message */
12113 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
12120 /* Wait for a reply... */
12128 * Enable/disable LISP proxy ITR.
12130 * @param vam vpp API test context
12131 * @return return code
12134 api_lisp_pitr_set_locator_set (vat_main_t * vam)
12137 u8 ls_name_set = 0;
12138 unformat_input_t *input = vam->input;
12139 vl_api_lisp_pitr_set_locator_set_t *mp;
12143 /* Parse args required to build the message */
12144 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12146 if (unformat (input, "del"))
12148 else if (unformat (input, "locator-set %s", &ls_name))
12152 errmsg ("parse error '%U'", format_unformat_error, input);
12159 errmsg ("locator-set name not set!");
12163 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
12165 mp->is_add = is_add;
12166 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
12167 vec_free (ls_name);
12172 /* wait for reply */
12180 api_show_lisp_pitr (vat_main_t * vam)
12182 vl_api_show_lisp_pitr_t *mp;
12185 if (!vam->json_output)
12187 fformat (vam->ofp, "%=20s\n", "lisp status:");
12190 M (SHOW_LISP_PITR, show_lisp_pitr);
12194 /* Wait for a reply... */
12202 * Add/delete mapping between vni and vrf
12205 api_lisp_eid_table_add_del_map (vat_main_t * vam)
12208 unformat_input_t *input = vam->input;
12209 vl_api_lisp_eid_table_add_del_map_t *mp;
12210 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
12211 u32 vni, vrf, bd_index;
12213 /* Parse args required to build the message */
12214 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12216 if (unformat (input, "del"))
12218 else if (unformat (input, "vrf %d", &vrf))
12220 else if (unformat (input, "bd_index %d", &bd_index))
12222 else if (unformat (input, "vni %d", &vni))
12228 if (!vni_set || (!vrf_set && !bd_index_set))
12230 errmsg ("missing arguments!");
12234 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
12236 mp->is_add = is_add;
12237 mp->vni = htonl (vni);
12238 mp->dp_table = htonl (vrf);
12239 mp->is_l2 = bd_index_set;
12244 /* wait for reply */
12252 * Add/del remote mapping to/from LISP control plane
12254 * @param vam vpp API test context
12255 * @return return code
12258 api_lisp_add_del_remote_mapping (vat_main_t * vam)
12260 unformat_input_t *input = vam->input;
12261 vl_api_lisp_add_del_remote_mapping_t *mp;
12264 //TODO: seid need remove
12265 lisp_eid_vat_t _eid, *eid = &_eid;
12266 lisp_eid_vat_t _seid, *seid = &_seid;
12267 u8 is_add = 1, del_all = 0, eid_set = 0;
12268 u32 action = ~0, p, w;
12269 ip4_address_t rloc4;
12270 ip6_address_t rloc6;
12271 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
12273 /* Parse args required to build the message */
12274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12276 if (unformat (input, "del-all"))
12280 else if (unformat (input, "del"))
12284 else if (unformat (input, "add"))
12288 else if (unformat (input, "deid %U", unformat_lisp_eid_vat, eid))
12292 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, &seid))
12294 //TODO: Need remove, but first must be remove from CSIT test
12296 else if (unformat (input, "vni %d", &vni))
12300 else if (unformat (input, "p %d w %d", &p, &w))
12304 errmsg ("No RLOC configured for setting priority/weight!");
12307 curr_rloc->priority = p;
12308 curr_rloc->weight = w;
12310 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
12313 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
12314 vec_add1 (rlocs, rloc);
12315 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12317 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
12320 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
12321 vec_add1 (rlocs, rloc);
12322 curr_rloc = &rlocs[vec_len (rlocs) - 1];
12324 else if (unformat (input, "action %d", &action))
12330 clib_warning ("parse error '%U'", format_unformat_error, input);
12337 errmsg ("missing params!");
12341 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
12343 errmsg ("no action set for negative map-reply!");
12347 M (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
12348 mp->is_add = is_add;
12349 mp->vni = htonl (vni);
12350 mp->action = (u8) action;
12351 mp->eid_len = eid->len;
12352 mp->del_all = del_all;
12353 mp->eid_type = eid->type;
12354 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12356 mp->rloc_num = vec_len (rlocs);
12357 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
12363 /* Wait for a reply... */
12371 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
12372 * forwarding entries in data-plane accordingly.
12374 * @param vam vpp API test context
12375 * @return return code
12378 api_lisp_add_del_adjacency (vat_main_t * vam)
12380 unformat_input_t *input = vam->input;
12381 vl_api_lisp_add_del_adjacency_t *mp;
12384 ip4_address_t seid4, deid4;
12385 ip6_address_t seid6, deid6;
12386 u8 deid_mac[6] = { 0 };
12387 u8 seid_mac[6] = { 0 };
12388 u8 deid_type, seid_type;
12389 u32 seid_len = 0, deid_len = 0, len;
12392 seid_type = deid_type = (u8) ~ 0;
12394 /* Parse args required to build the message */
12395 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12397 if (unformat (input, "del"))
12401 else if (unformat (input, "add"))
12405 else if (unformat (input, "deid %U/%d", unformat_ip4_address,
12408 deid_type = 0; /* ipv4 */
12411 else if (unformat (input, "deid %U/%d", unformat_ip6_address,
12414 deid_type = 1; /* ipv6 */
12417 else if (unformat (input, "deid %U", unformat_ethernet_address,
12420 deid_type = 2; /* mac */
12422 else if (unformat (input, "seid %U/%d", unformat_ip4_address,
12425 seid_type = 0; /* ipv4 */
12428 else if (unformat (input, "seid %U/%d", unformat_ip6_address,
12431 seid_type = 1; /* ipv6 */
12434 else if (unformat (input, "seid %U", unformat_ethernet_address,
12437 seid_type = 2; /* mac */
12439 else if (unformat (input, "vni %d", &vni))
12445 errmsg ("parse error '%U'", format_unformat_error, input);
12450 if ((u8) ~ 0 == deid_type)
12452 errmsg ("missing params!");
12456 if (seid_type != deid_type)
12458 errmsg ("source and destination EIDs are of different types!");
12462 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
12463 mp->is_add = is_add;
12464 mp->vni = htonl (vni);
12465 mp->seid_len = seid_len;
12466 mp->deid_len = deid_len;
12467 mp->eid_type = deid_type;
12469 switch (mp->eid_type)
12472 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
12473 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
12476 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
12477 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
12480 clib_memcpy (mp->seid, seid_mac, 6);
12481 clib_memcpy (mp->deid, deid_mac, 6);
12484 errmsg ("unknown EID type %d!", mp->eid_type);
12491 /* Wait for a reply... */
12499 api_lisp_gpe_add_del_iface (vat_main_t * vam)
12501 unformat_input_t *input = vam->input;
12502 vl_api_lisp_gpe_add_del_iface_t *mp;
12504 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
12505 u32 dp_table=0, vni=0;
12507 /* Parse args required to build the message */
12508 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12510 if (unformat (input, "up"))
12515 else if (unformat (input, "down"))
12520 else if (unformat (input, "table_id %d", &dp_table))
12524 else if (unformat (input, "bd_id %d", &dp_table))
12529 else if (unformat (input, "vni %d", &vni))
12537 if (action_set == 0)
12539 errmsg ("Action not set\n");
12542 if (dp_table_set == 0 || vni_set == 0)
12544 errmsg ("vni and dp_table must be set\n");
12548 /* Construct the API message */
12549 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
12551 mp->is_add = is_add;
12552 mp->dp_table = dp_table;
12559 /* Wait for a reply... */
12567 * Add/del map request itr rlocs from LISP control plane and updates
12569 * @param vam vpp API test context
12570 * @return return code
12573 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
12575 unformat_input_t *input = vam->input;
12576 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
12578 u8 *locator_set_name = 0;
12579 u8 locator_set_name_set = 0;
12582 /* Parse args required to build the message */
12583 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12585 if (unformat (input, "del"))
12589 else if (unformat (input, "%_%v%_", &locator_set_name))
12591 locator_set_name_set = 1;
12595 clib_warning ("parse error '%U'", format_unformat_error, input);
12600 if (is_add && !locator_set_name_set)
12602 errmsg ("itr-rloc is not set!");
12606 if (is_add && vec_len (locator_set_name) > 64)
12608 errmsg ("itr-rloc locator-set name too long\n");
12609 vec_free (locator_set_name);
12613 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
12614 mp->is_add = is_add;
12617 clib_memcpy (mp->locator_set_name, locator_set_name,
12618 vec_len (locator_set_name));
12622 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
12624 vec_free (locator_set_name);
12629 /* Wait for a reply... */
12637 lisp_locator_dump_send_msg (vat_main_t * vam, u32 locator_set_index,
12640 vl_api_lisp_locator_dump_t *mp;
12643 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
12645 mp->locator_set_index = htonl (locator_set_index);
12646 mp->filter = filter;
12651 /* Use a control ping for synchronization */
12653 vl_api_noprint_control_ping_t *mp;
12654 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12657 /* Wait for a reply... */
12662 clean_locator_set_message (vat_main_t * vam)
12664 locator_set_msg_t *ls = 0;
12666 vec_foreach (ls, vam->locator_set_msg)
12668 vec_free (ls->locator_set_name);
12671 vec_free (vam->locator_set_msg);
12675 print_locator_in_locator_set (vat_main_t * vam, u8 filter)
12677 locator_set_msg_t *ls;
12678 locator_msg_t *loc;
12680 int i = 0, ret = 0;
12682 vec_foreach (ls, vam->locator_set_msg)
12684 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12687 vec_free (vam->locator_msg);
12688 clean_locator_set_message (vam);
12692 tmp_str = format (0, "%=20s%=16d%s", ls->locator_set_name,
12693 ls->locator_set_index,
12694 vec_len (vam->locator_msg) ? "" : "\n");
12696 vec_foreach (loc, vam->locator_msg)
12700 tmp_str = format (tmp_str, "%=37s", " ");
12704 tmp_str = format (tmp_str, "%=16d%=16d%=16d\n",
12705 loc->sw_if_index, loc->priority, loc->weight);
12709 tmp_str = format (tmp_str, "%=16U%=16d%=16d\n",
12710 loc->is_ipv6 ? format_ip6_address :
12711 format_ip4_address,
12712 loc->ip_address, loc->priority, loc->weight);
12717 fformat (vam->ofp, "%s", tmp_str);
12718 vec_free (tmp_str);
12719 vec_free (vam->locator_msg);
12722 clean_locator_set_message (vam);
12728 json_locator_in_locator_set (vat_main_t * vam, u8 filter)
12730 locator_set_msg_t *ls;
12731 locator_msg_t *loc;
12732 vat_json_node_t *node = NULL;
12733 vat_json_node_t *locator_array;
12734 vat_json_node_t *locator;
12735 struct in6_addr ip6;
12736 struct in_addr ip4;
12739 if (!vec_len (vam->locator_set_msg))
12741 /* just print [] */
12742 vat_json_init_array (&vam->json_tree);
12743 vat_json_print (vam->ofp, &vam->json_tree);
12744 vam->json_tree.type = VAT_JSON_NONE;
12748 if (VAT_JSON_ARRAY != vam->json_tree.type)
12750 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
12751 vat_json_init_array (&vam->json_tree);
12754 vec_foreach (ls, vam->locator_set_msg)
12756 ret = lisp_locator_dump_send_msg (vam, ls->locator_set_index, filter);
12759 vec_free (ls->locator_set_name);
12760 vec_free (vam->locator_msg);
12761 vec_free (vam->locator_set_msg);
12762 vat_json_free (&vam->json_tree);
12763 vam->json_tree.type = VAT_JSON_NONE;
12767 node = vat_json_array_add (&vam->json_tree);
12768 vat_json_init_object (node);
12770 vat_json_object_add_uint (node, "locator-set-index",
12771 ls->locator_set_index);
12772 vat_json_object_add_string_copy (node, "locator-set",
12773 ls->locator_set_name);
12774 locator_array = vat_json_object_add_list (node, "locator");
12775 vec_foreach (loc, vam->locator_msg)
12777 locator = vat_json_array_add (locator_array);
12778 vat_json_init_object (locator);
12781 vat_json_object_add_uint (locator, "locator-index",
12788 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
12789 vat_json_object_add_ip6 (locator, "locator", ip6);
12793 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
12794 vat_json_object_add_ip4 (locator, "locator", ip4);
12797 vat_json_object_add_uint (locator, "priority", loc->priority);
12798 vat_json_object_add_uint (locator, "weight", loc->weight);
12801 vec_free (ls->locator_set_name);
12802 vec_free (vam->locator_msg);
12805 vat_json_print (vam->ofp, &vam->json_tree);
12806 vat_json_free (&vam->json_tree);
12807 vam->json_tree.type = VAT_JSON_NONE;
12809 vec_free (vam->locator_set_msg);
12815 get_locator_set_index_from_msg (vat_main_t * vam, u8 * locator_set,
12816 u32 * locator_set_index)
12818 locator_set_msg_t *ls;
12821 *locator_set_index = ~0;
12823 if (!vec_len (vam->locator_set_msg))
12828 vec_foreach (ls, vam->locator_set_msg)
12830 if (!strcmp ((char *) locator_set, (char *) ls->locator_set_name))
12832 *locator_set_index = ls->locator_set_index;
12833 vec_free (vam->locator_set_msg);
12838 vec_free (vam->locator_set_msg);
12844 get_locator_set_index (vat_main_t * vam, u8 * locator_set,
12845 u32 * locator_set_index)
12847 vl_api_lisp_locator_set_dump_t *mp;
12850 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12854 /* Use a control ping for synchronization */
12856 vl_api_noprint_control_ping_t *mp;
12857 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12861 vam->noprint_msg = 1;
12862 /* Wait for a reply... */
12866 get_locator_set_index_from_msg (vam, locator_set, locator_set_index);
12867 vam->noprint_msg = 0;
12876 lisp_locator_dump (vat_main_t * vam, u32 locator_set_index, u8 * locator_set,
12883 if (!vam->json_output)
12885 fformat (vam->ofp, "%=20s%=16s%=16s\n",
12886 "locator", "priority", "weight");
12891 ret = get_locator_set_index (vam, locator_set, &locator_set_index);
12894 if (!ret && ~0 == locator_set_index)
12899 ret = lisp_locator_dump_send_msg (vam, locator_set_index, filter);
12905 lisp_locator_set_dump (vat_main_t * vam, u8 filter)
12907 vl_api_lisp_locator_set_dump_t *mp;
12910 if (!vam->json_output)
12912 fformat (vam->ofp, "%=20s%=16s%=16s%=16s%=16s\n",
12913 "locator-set", "locator-set-index", "locator", "priority",
12917 vam->noprint_msg = 1;
12919 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
12921 mp->filter = filter;
12926 /* Use a control ping for synchronization */
12928 vl_api_noprint_control_ping_t *mp;
12929 M (NOPRINT_CONTROL_PING, noprint_control_ping);
12933 /* Wait for a reply... */
12937 if (vam->noprint_msg)
12939 if (!vam->json_output)
12941 print_locator_in_locator_set(vam, filter);
12945 json_locator_in_locator_set(vam, filter);
12948 vam->noprint_msg = 0;
12957 api_lisp_locator_set_dump (vat_main_t * vam)
12959 unformat_input_t *input = vam->input;
12960 vam->noprint_msg = 0;
12961 u32 locator_set_index = ~0;
12962 u8 locator_set_index_set = 0;
12963 u8 *locator_set = 0;
12964 u8 locator_set_set = 0;
12968 /* Parse args required to build the message */
12969 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12971 if (unformat (input, "locator-set-index %u", &locator_set_index))
12973 locator_set_index_set = 1;
12975 else if (unformat (input, "locator-set %s", &locator_set))
12977 locator_set_set = 1;
12979 else if (unformat (input, "local"))
12983 else if (unformat (input, "remote"))
12993 if (locator_set_index_set && locator_set_set)
12995 errmsg ("use only input parameter!\n");
12999 if (locator_set_index_set || locator_set_set)
13001 ret = lisp_locator_dump (vam, locator_set_index, locator_set, filter);
13005 ret = lisp_locator_set_dump (vam, filter);
13008 vec_free (locator_set);
13014 api_lisp_eid_table_map_dump (vat_main_t * vam)
13016 vl_api_lisp_eid_table_map_dump_t *mp;
13019 if (!vam->json_output)
13021 fformat (vam->ofp, "%=10s%=10s\n", "VNI", "VRF");
13024 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13029 /* Use a control ping for synchronization */
13031 vl_api_control_ping_t *mp;
13032 M (CONTROL_PING, control_ping);
13035 /* Wait for a reply... */
13043 get_locator_set (vat_main_t * vam)
13045 vl_api_lisp_locator_set_dump_t *mp;
13048 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13052 /* Use a control ping for synchronization */
13054 vl_api_noprint_control_ping_t *mp;
13055 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13059 /* Wait for a reply... */
13067 format_eid_for_eid_table (vat_main_t * vam, u8 * str, eid_table_t * eid_table,
13070 u8 *(*format_eid) (u8 *, va_list *) = 0;
13072 ASSERT (vam != NULL);
13073 ASSERT (eid_table != NULL);
13080 switch (eid_table->eid_type)
13084 format_eid = (eid_table->eid_type ? format_ip6_address :
13085 format_ip4_address);
13086 str = format (0, "[%d] %U/%d",
13087 clib_net_to_host_u32 (eid_table->vni),
13088 format_eid, eid_table->eid, eid_table->eid_prefix_len);
13091 str = format (0, "[%d] %U",
13092 clib_net_to_host_u32 (eid_table->vni),
13093 format_ethernet_address, eid_table->eid);
13096 errmsg ("unknown EID type %d!", eid_table->eid_type);
13108 format_locator_set_for_eid_table (vat_main_t * vam, u8 * str,
13109 eid_table_t * eid_table)
13111 locator_set_msg_t *ls = 0;
13113 ASSERT (vam != NULL);
13114 ASSERT (eid_table != NULL);
13116 if (eid_table->is_local)
13118 vec_foreach (ls, vam->locator_set_msg)
13120 if (ls->locator_set_index == eid_table->locator_set_index)
13122 str = format (0, "local(%s)", ls->locator_set_name);
13127 str = format (0, "local(N/A)");
13131 str = format (0, "remote");
13138 format_locator_for_eid_table (vat_main_t * vam, u8 * str,
13139 eid_table_t * eid_table)
13141 locator_msg_t *loc = 0;
13142 int first_line = 1;
13144 ASSERT (vam != NULL);
13145 ASSERT (eid_table != NULL);
13147 vec_foreach (loc, vam->locator_msg)
13153 str = format (str, "%-55s%-d\n", " ", loc->sw_if_index);
13157 str = format (str, "%=55s%-U\n", " ",
13158 loc->is_ipv6 ? format_ip6_address :
13159 format_ip4_address, loc->ip_address);
13167 str = format (str, "%-30d%-20u%-u\n", loc->sw_if_index,
13168 eid_table->ttl, eid_table->authoritative);
13172 str = format (str, "%-30U%-20u%-u\n",
13173 loc->is_ipv6 ? format_ip6_address :
13174 format_ip4_address,
13175 loc->ip_address, eid_table->ttl,
13176 eid_table->authoritative);
13185 print_lisp_eid_table_dump (vat_main_t * vam)
13187 eid_table_t *eid_table = 0;
13188 u8 *tmp_str = 0, *tmp_str2 = 0;
13191 ASSERT (vam != NULL);
13193 ret = get_locator_set (vam);
13196 vec_free (vam->eid_tables);
13200 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type", "locators",
13201 "ttl", "authoritative");
13203 vec_foreach (eid_table, vam->eid_tables)
13205 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13208 vec_free (vam->locator_msg);
13209 clean_locator_set_message (vam);
13210 vec_free (vam->eid_tables);
13214 tmp_str2 = format_eid_for_eid_table (vam, tmp_str2, eid_table, &ret);
13217 vec_free (vam->locator_msg);
13218 clean_locator_set_message (vam);
13219 vec_free (vam->eid_tables);
13223 tmp_str = format (0, "%-35s", tmp_str2);
13224 vec_free (tmp_str2);
13226 tmp_str2 = format_locator_set_for_eid_table (vam, tmp_str2, eid_table);
13227 tmp_str = format (tmp_str, "%-20s", tmp_str2);
13228 vec_free (tmp_str2);
13230 tmp_str2 = format_locator_for_eid_table (vam, tmp_str2, eid_table);
13231 tmp_str = format (tmp_str, "%-s", tmp_str2);
13232 vec_free (tmp_str2);
13234 fformat (vam->ofp, "%s", tmp_str);
13235 vec_free (tmp_str);
13236 vec_free (vam->locator_msg);
13239 clean_locator_set_message (vam);
13240 vec_free (vam->eid_tables);
13246 json_locator_set_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13247 eid_table_t * eid_table)
13249 locator_set_msg_t *ls = 0;
13252 ASSERT (vam != NULL);
13253 ASSERT (node != NULL);
13254 ASSERT (eid_table != NULL);
13256 if (eid_table->is_local)
13258 vec_foreach (ls, vam->locator_set_msg)
13260 if (ls->locator_set_index == eid_table->locator_set_index)
13262 vat_json_object_add_string_copy (node, "locator-set",
13263 ls->locator_set_name);
13268 s = format (0, "N/A");
13270 vat_json_object_add_string_copy (node, "locator-set", s);
13275 s = format (0, "remote");
13277 vat_json_object_add_string_copy (node, "locator-set", s);
13283 json_eid_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13284 eid_table_t * eid_table)
13287 struct in6_addr ip6;
13288 struct in_addr ip4;
13290 ASSERT (vam != NULL);
13291 ASSERT (node != NULL);
13292 ASSERT (eid_table != NULL);
13294 switch (eid_table->eid_type)
13297 clib_memcpy (&ip4, eid_table->eid, sizeof (ip4));
13298 vat_json_object_add_ip4 (node, "eid", ip4);
13299 vat_json_object_add_uint (node, "eid-prefix-len",
13300 eid_table->eid_prefix_len);
13303 clib_memcpy (&ip6, eid_table->eid, sizeof (ip6));
13304 vat_json_object_add_ip6 (node, "eid", ip6);
13305 vat_json_object_add_uint (node, "eid-prefix-len",
13306 eid_table->eid_prefix_len);
13309 s = format (0, "%U", format_ethernet_address, eid_table->eid);
13311 vat_json_object_add_string_copy (node, "eid", s);
13315 errmsg ("unknown EID type %d!", eid_table->eid_type);
13323 json_locator_for_eid_table (vat_main_t * vam, vat_json_node_t * node,
13324 eid_table_t * eid_table)
13326 locator_msg_t *loc = 0;
13327 vat_json_node_t *locator_array = 0;
13328 vat_json_node_t *locator = 0;
13329 struct in6_addr ip6;
13330 struct in_addr ip4;
13332 ASSERT (vam != NULL);
13333 ASSERT (node != NULL);
13334 ASSERT (eid_table != NULL);
13336 locator_array = vat_json_object_add_list (node, "locator");
13337 vec_foreach (loc, vam->locator_msg)
13339 locator = vat_json_array_add (locator_array);
13340 vat_json_init_object (locator);
13343 vat_json_object_add_uint (locator, "locator-index", loc->sw_if_index);
13349 clib_memcpy (&ip6, loc->ip_address, sizeof (ip6));
13350 vat_json_object_add_ip6 (locator, "locator", ip6);
13354 clib_memcpy (&ip4, loc->ip_address, sizeof (ip4));
13355 vat_json_object_add_ip4 (locator, "locator", ip4);
13362 json_lisp_eid_table_dump (vat_main_t * vam)
13364 eid_table_t *eid_table;
13365 vat_json_node_t *node = 0;
13368 ASSERT (vam != NULL);
13370 ret = get_locator_set (vam);
13373 vec_free (vam->eid_tables);
13377 if (!vec_len (vam->eid_tables))
13379 /* just print [] */
13380 vat_json_init_array (&vam->json_tree);
13381 vat_json_print (vam->ofp, &vam->json_tree);
13382 vam->json_tree.type = VAT_JSON_NONE;
13386 if (VAT_JSON_ARRAY != vam->json_tree.type)
13388 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
13389 vat_json_init_array (&vam->json_tree);
13392 vec_foreach (eid_table, vam->eid_tables)
13394 ret = lisp_locator_dump_send_msg (vam, eid_table->locator_set_index, 0);
13397 vec_free (vam->locator_msg);
13398 vec_free (vam->eid_tables);
13399 clean_locator_set_message (vam);
13400 vat_json_free (&vam->json_tree);
13401 vam->json_tree.type = VAT_JSON_NONE;
13405 node = vat_json_array_add (&vam->json_tree);
13406 vat_json_init_object (node);
13408 vat_json_object_add_uint (node, "vni", eid_table->vni);
13410 json_locator_set_for_eid_table (vam, node, eid_table);
13411 ret = json_eid_for_eid_table (vam, node, eid_table);
13414 vec_free (vam->locator_msg);
13415 vec_free (vam->eid_tables);
13416 clean_locator_set_message (vam);
13417 vat_json_free (&vam->json_tree);
13418 vam->json_tree.type = VAT_JSON_NONE;
13422 json_locator_for_eid_table (vam, node, eid_table);
13424 vat_json_object_add_uint (node, "ttl", eid_table->ttl);
13425 vat_json_object_add_uint (node, "authoritative",
13426 eid_table->authoritative);
13428 vec_free (vam->locator_msg);
13431 vat_json_print (vam->ofp, &vam->json_tree);
13432 vat_json_free (&vam->json_tree);
13433 vam->json_tree.type = VAT_JSON_NONE;
13435 clean_locator_set_message (vam);
13436 vec_free (vam->eid_tables);
13442 api_lisp_eid_table_dump (vat_main_t * vam)
13444 unformat_input_t *i = vam->input;
13445 vl_api_lisp_eid_table_dump_t *mp;
13447 struct in_addr ip4;
13448 struct in6_addr ip6;
13450 u8 eid_type = ~0, eid_set = 0;
13451 u32 prefix_length = ~0, t, vni = 0;
13454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13456 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
13462 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
13468 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
13473 else if (unformat (i, "vni %d", &t))
13477 else if (unformat (i, "local"))
13481 else if (unformat (i, "remote"))
13487 errmsg ("parse error '%U'", format_unformat_error, i);
13492 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
13494 mp->filter = filter;
13498 mp->vni = htonl (vni);
13499 mp->eid_type = eid_type;
13503 mp->prefix_length = prefix_length;
13504 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
13507 mp->prefix_length = prefix_length;
13508 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
13511 clib_memcpy (mp->eid, mac, sizeof (mac));
13514 errmsg ("unknown EID type %d!", eid_type);
13519 vam->noprint_msg = 1;
13524 /* Use a control ping for synchronization */
13526 vl_api_noprint_control_ping_t *mp;
13527 M (NOPRINT_CONTROL_PING, noprint_control_ping);
13531 /* Wait for a reply... */
13535 if (vam->noprint_msg)
13537 if (!vam->json_output)
13539 vam->retval = print_lisp_eid_table_dump(vam);
13543 vam->retval = json_lisp_eid_table_dump(vam);
13546 vam->noprint_msg = 0;
13555 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
13557 vl_api_lisp_gpe_tunnel_dump_t *mp;
13560 if (!vam->json_output)
13562 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
13563 "%=16s%=16s%=16s%=16s%=16s\n",
13564 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
13565 "Decap next", "Lisp version", "Flags", "Next protocol",
13566 "ver_res", "res", "iid");
13569 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
13573 /* Use a control ping for synchronization */
13575 vl_api_control_ping_t *mp;
13576 M (CONTROL_PING, control_ping);
13579 /* Wait for a reply... */
13587 api_lisp_map_resolver_dump (vat_main_t * vam)
13589 vl_api_lisp_map_resolver_dump_t *mp;
13592 if (!vam->json_output)
13594 fformat (vam->ofp, "%=20s\n", "Map resolver");
13597 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
13601 /* Use a control ping for synchronization */
13603 vl_api_control_ping_t *mp;
13604 M (CONTROL_PING, control_ping);
13607 /* Wait for a reply... */
13615 api_show_lisp_status (vat_main_t * vam)
13617 vl_api_show_lisp_status_t *mp;
13620 if (!vam->json_output)
13622 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
13625 M (SHOW_LISP_STATUS, show_lisp_status);
13628 /* Wait for a reply... */
13636 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
13638 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
13641 if (!vam->json_output)
13643 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
13646 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
13649 /* Wait for a reply... */
13657 api_af_packet_create (vat_main_t * vam)
13659 unformat_input_t *i = vam->input;
13660 vl_api_af_packet_create_t *mp;
13662 u8 *host_if_name = 0;
13664 u8 random_hw_addr = 1;
13666 memset (hw_addr, 0, sizeof (hw_addr));
13668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13670 if (unformat (i, "name %s", &host_if_name))
13671 vec_add1 (host_if_name, 0);
13672 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13673 random_hw_addr = 0;
13678 if (!vec_len (host_if_name))
13680 errmsg ("host-interface name must be specified");
13684 if (vec_len (host_if_name) > 64)
13686 errmsg ("host-interface name too long");
13690 M (AF_PACKET_CREATE, af_packet_create);
13692 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13693 clib_memcpy (mp->hw_addr, hw_addr, 6);
13694 mp->use_random_hw_addr = random_hw_addr;
13695 vec_free (host_if_name);
13698 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
13704 api_af_packet_delete (vat_main_t * vam)
13706 unformat_input_t *i = vam->input;
13707 vl_api_af_packet_delete_t *mp;
13709 u8 *host_if_name = 0;
13711 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13713 if (unformat (i, "name %s", &host_if_name))
13714 vec_add1 (host_if_name, 0);
13719 if (!vec_len (host_if_name))
13721 errmsg ("host-interface name must be specified");
13725 if (vec_len (host_if_name) > 64)
13727 errmsg ("host-interface name too long");
13731 M (AF_PACKET_DELETE, af_packet_delete);
13733 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
13734 vec_free (host_if_name);
13743 api_policer_add_del (vat_main_t * vam)
13745 unformat_input_t *i = vam->input;
13746 vl_api_policer_add_del_t *mp;
13757 u8 color_aware = 0;
13758 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
13760 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13762 if (unformat (i, "del"))
13764 else if (unformat (i, "name %s", &name))
13765 vec_add1 (name, 0);
13766 else if (unformat (i, "cir %u", &cir))
13768 else if (unformat (i, "eir %u", &eir))
13770 else if (unformat (i, "cb %u", &cb))
13772 else if (unformat (i, "eb %u", &eb))
13774 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
13777 else if (unformat (i, "round_type %U", unformat_policer_round_type,
13780 else if (unformat (i, "type %U", unformat_policer_type, &type))
13782 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
13785 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
13788 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
13791 else if (unformat (i, "color-aware"))
13797 if (!vec_len (name))
13799 errmsg ("policer name must be specified");
13803 if (vec_len (name) > 64)
13805 errmsg ("policer name too long");
13809 M (POLICER_ADD_DEL, policer_add_del);
13811 clib_memcpy (mp->name, name, vec_len (name));
13813 mp->is_add = is_add;
13818 mp->rate_type = rate_type;
13819 mp->round_type = round_type;
13821 mp->conform_action_type = conform_action.action_type;
13822 mp->conform_dscp = conform_action.dscp;
13823 mp->exceed_action_type = exceed_action.action_type;
13824 mp->exceed_dscp = exceed_action.dscp;
13825 mp->violate_action_type = violate_action.action_type;
13826 mp->violate_dscp = violate_action.dscp;
13827 mp->color_aware = color_aware;
13836 api_policer_dump (vat_main_t * vam)
13838 unformat_input_t *i = vam->input;
13839 vl_api_policer_dump_t *mp;
13841 u8 *match_name = 0;
13842 u8 match_name_valid = 0;
13844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13846 if (unformat (i, "name %s", &match_name))
13848 vec_add1 (match_name, 0);
13849 match_name_valid = 1;
13855 M (POLICER_DUMP, policer_dump);
13856 mp->match_name_valid = match_name_valid;
13857 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
13858 vec_free (match_name);
13862 /* Use a control ping for synchronization */
13864 vl_api_control_ping_t *mp;
13865 M (CONTROL_PING, control_ping);
13868 /* Wait for a reply... */
13876 api_policer_classify_set_interface (vat_main_t * vam)
13878 unformat_input_t *i = vam->input;
13879 vl_api_policer_classify_set_interface_t *mp;
13882 int sw_if_index_set;
13883 u32 ip4_table_index = ~0;
13884 u32 ip6_table_index = ~0;
13885 u32 l2_table_index = ~0;
13888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13890 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
13891 sw_if_index_set = 1;
13892 else if (unformat (i, "sw_if_index %d", &sw_if_index))
13893 sw_if_index_set = 1;
13894 else if (unformat (i, "del"))
13896 else if (unformat (i, "ip4-table %d", &ip4_table_index))
13898 else if (unformat (i, "ip6-table %d", &ip6_table_index))
13900 else if (unformat (i, "l2-table %d", &l2_table_index))
13904 clib_warning ("parse error '%U'", format_unformat_error, i);
13909 if (sw_if_index_set == 0)
13911 errmsg ("missing interface name or sw_if_index\n");
13915 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
13917 mp->sw_if_index = ntohl (sw_if_index);
13918 mp->ip4_table_index = ntohl (ip4_table_index);
13919 mp->ip6_table_index = ntohl (ip6_table_index);
13920 mp->l2_table_index = ntohl (l2_table_index);
13921 mp->is_add = is_add;
13930 api_policer_classify_dump (vat_main_t * vam)
13932 unformat_input_t *i = vam->input;
13933 vl_api_policer_classify_dump_t *mp;
13935 u8 type = POLICER_CLASSIFY_N_TABLES;
13937 if (unformat (i, "type %U", unformat_classify_table_type, &type))
13941 errmsg ("classify table type must be specified\n");
13945 if (!vam->json_output)
13947 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
13950 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
13955 /* Use a control ping for synchronization */
13957 vl_api_control_ping_t *mp;
13958 M (CONTROL_PING, control_ping);
13961 /* Wait for a reply... */
13969 api_netmap_create (vat_main_t * vam)
13971 unformat_input_t *i = vam->input;
13972 vl_api_netmap_create_t *mp;
13976 u8 random_hw_addr = 1;
13980 memset (hw_addr, 0, sizeof (hw_addr));
13982 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
13984 if (unformat (i, "name %s", &if_name))
13985 vec_add1 (if_name, 0);
13986 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
13987 random_hw_addr = 0;
13988 else if (unformat (i, "pipe"))
13990 else if (unformat (i, "master"))
13992 else if (unformat (i, "slave"))
13998 if (!vec_len (if_name))
14000 errmsg ("interface name must be specified");
14004 if (vec_len (if_name) > 64)
14006 errmsg ("interface name too long");
14010 M (NETMAP_CREATE, netmap_create);
14012 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14013 clib_memcpy (mp->hw_addr, hw_addr, 6);
14014 mp->use_random_hw_addr = random_hw_addr;
14015 mp->is_pipe = is_pipe;
14016 mp->is_master = is_master;
14017 vec_free (if_name);
14026 api_netmap_delete (vat_main_t * vam)
14028 unformat_input_t *i = vam->input;
14029 vl_api_netmap_delete_t *mp;
14033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14035 if (unformat (i, "name %s", &if_name))
14036 vec_add1 (if_name, 0);
14041 if (!vec_len (if_name))
14043 errmsg ("interface name must be specified");
14047 if (vec_len (if_name) > 64)
14049 errmsg ("interface name too long");
14053 M (NETMAP_DELETE, netmap_delete);
14055 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14056 vec_free (if_name);
14064 static void vl_api_mpls_gre_tunnel_details_t_handler
14065 (vl_api_mpls_gre_tunnel_details_t * mp)
14067 vat_main_t *vam = &vat_main;
14069 i32 len = ntohl (mp->nlabels);
14071 if (mp->l2_only == 0)
14073 fformat (vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
14074 ntohl (mp->tunnel_index),
14075 format_ip4_address, &mp->tunnel_src,
14076 format_ip4_address, &mp->tunnel_dst,
14077 format_ip4_address, &mp->intfc_address,
14078 ntohl (mp->mask_width));
14079 for (i = 0; i < len; i++)
14081 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14083 fformat (vam->ofp, "\n");
14084 fformat (vam->ofp, " inner fib index %d, outer fib index %d\n",
14085 ntohl (mp->inner_fib_index), ntohl (mp->outer_fib_index));
14089 fformat (vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
14090 ntohl (mp->tunnel_index),
14091 format_ip4_address, &mp->tunnel_src,
14092 format_ip4_address, &mp->tunnel_dst,
14093 format_ip4_address, &mp->intfc_address);
14094 for (i = 0; i < len; i++)
14096 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14098 fformat (vam->ofp, "\n");
14099 fformat (vam->ofp, " l2 interface %d, outer fib index %d\n",
14100 ntohl (mp->hw_if_index), ntohl (mp->outer_fib_index));
14104 static void vl_api_mpls_gre_tunnel_details_t_handler_json
14105 (vl_api_mpls_gre_tunnel_details_t * mp)
14107 vat_main_t *vam = &vat_main;
14108 vat_json_node_t *node = NULL;
14109 struct in_addr ip4;
14111 i32 len = ntohl (mp->nlabels);
14113 if (VAT_JSON_ARRAY != vam->json_tree.type)
14115 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14116 vat_json_init_array (&vam->json_tree);
14118 node = vat_json_array_add (&vam->json_tree);
14120 vat_json_init_object (node);
14121 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14122 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14123 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14124 vat_json_object_add_uint (node, "inner_fib_index",
14125 ntohl (mp->inner_fib_index));
14126 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14127 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14128 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14129 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14130 clib_memcpy (&ip4, &(mp->tunnel_src), sizeof (ip4));
14131 vat_json_object_add_ip4 (node, "tunnel_src", ip4);
14132 clib_memcpy (&ip4, &(mp->tunnel_dst), sizeof (ip4));
14133 vat_json_object_add_ip4 (node, "tunnel_dst", ip4);
14134 vat_json_object_add_uint (node, "outer_fib_index",
14135 ntohl (mp->outer_fib_index));
14136 vat_json_object_add_uint (node, "label_count", len);
14137 for (i = 0; i < len; i++)
14139 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14144 api_mpls_gre_tunnel_dump (vat_main_t * vam)
14146 vl_api_mpls_gre_tunnel_dump_t *mp;
14150 /* Parse args required to build the message */
14151 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14153 if (!unformat (vam->input, "tunnel_index %d", &index))
14160 fformat (vam->ofp, " tunnel_index %d\n", index);
14162 M (MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
14163 mp->tunnel_index = htonl (index);
14166 /* Use a control ping for synchronization */
14168 vl_api_control_ping_t *mp;
14169 M (CONTROL_PING, control_ping);
14175 static void vl_api_mpls_eth_tunnel_details_t_handler
14176 (vl_api_mpls_eth_tunnel_details_t * mp)
14178 vat_main_t *vam = &vat_main;
14180 i32 len = ntohl (mp->nlabels);
14182 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14183 ntohl (mp->tunnel_index),
14184 format_ethernet_address, &mp->tunnel_dst_mac,
14185 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14186 for (i = 0; i < len; i++)
14188 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14190 fformat (vam->ofp, "\n");
14191 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14192 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14195 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14196 (vl_api_mpls_eth_tunnel_details_t * mp)
14198 vat_main_t *vam = &vat_main;
14199 vat_json_node_t *node = NULL;
14200 struct in_addr ip4;
14202 i32 len = ntohl (mp->nlabels);
14204 if (VAT_JSON_ARRAY != vam->json_tree.type)
14206 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14207 vat_json_init_array (&vam->json_tree);
14209 node = vat_json_array_add (&vam->json_tree);
14211 vat_json_init_object (node);
14212 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14213 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14214 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14215 vat_json_object_add_uint (node, "inner_fib_index",
14216 ntohl (mp->inner_fib_index));
14217 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14218 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14219 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14220 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14221 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14222 format (0, "%U", format_ethernet_address,
14223 &mp->tunnel_dst_mac));
14224 vat_json_object_add_uint (node, "tx_sw_if_index",
14225 ntohl (mp->tx_sw_if_index));
14226 vat_json_object_add_uint (node, "label_count", len);
14227 for (i = 0; i < len; i++)
14229 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14234 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14236 vl_api_mpls_eth_tunnel_dump_t *mp;
14240 /* Parse args required to build the message */
14241 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14243 if (!unformat (vam->input, "tunnel_index %d", &index))
14250 fformat (vam->ofp, " tunnel_index %d\n", index);
14252 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14253 mp->tunnel_index = htonl (index);
14256 /* Use a control ping for synchronization */
14258 vl_api_control_ping_t *mp;
14259 M (CONTROL_PING, control_ping);
14265 static void vl_api_mpls_fib_encap_details_t_handler
14266 (vl_api_mpls_fib_encap_details_t * mp)
14268 vat_main_t *vam = &vat_main;
14270 i32 len = ntohl (mp->nlabels);
14272 fformat (vam->ofp, "table %d, dest %U, label ",
14273 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14274 for (i = 0; i < len; i++)
14276 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14278 fformat (vam->ofp, "\n");
14281 static void vl_api_mpls_fib_encap_details_t_handler_json
14282 (vl_api_mpls_fib_encap_details_t * mp)
14284 vat_main_t *vam = &vat_main;
14285 vat_json_node_t *node = NULL;
14287 i32 len = ntohl (mp->nlabels);
14288 struct in_addr ip4;
14290 if (VAT_JSON_ARRAY != vam->json_tree.type)
14292 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14293 vat_json_init_array (&vam->json_tree);
14295 node = vat_json_array_add (&vam->json_tree);
14297 vat_json_init_object (node);
14298 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14299 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14300 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14301 vat_json_object_add_ip4 (node, "dest", ip4);
14302 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14303 vat_json_object_add_uint (node, "label_count", len);
14304 for (i = 0; i < len; i++)
14306 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14311 api_mpls_fib_encap_dump (vat_main_t * vam)
14313 vl_api_mpls_fib_encap_dump_t *mp;
14316 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14319 /* Use a control ping for synchronization */
14321 vl_api_control_ping_t *mp;
14322 M (CONTROL_PING, control_ping);
14328 static void vl_api_mpls_fib_decap_details_t_handler
14329 (vl_api_mpls_fib_decap_details_t * mp)
14331 vat_main_t *vam = &vat_main;
14334 "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
14335 ntohl (mp->rx_table_id), ntohl (mp->tx_table_id), mp->swif_tag,
14336 ntohl (mp->label), ntohl (mp->s_bit));
14339 static void vl_api_mpls_fib_decap_details_t_handler_json
14340 (vl_api_mpls_fib_decap_details_t * mp)
14342 vat_main_t *vam = &vat_main;
14343 vat_json_node_t *node = NULL;
14344 struct in_addr ip4;
14346 if (VAT_JSON_ARRAY != vam->json_tree.type)
14348 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14349 vat_json_init_array (&vam->json_tree);
14351 node = vat_json_array_add (&vam->json_tree);
14353 vat_json_init_object (node);
14354 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14355 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14356 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14357 vat_json_object_add_ip4 (node, "dest", ip4);
14358 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14359 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14360 vat_json_object_add_uint (node, "rx_table_id", ntohl (mp->rx_table_id));
14361 vat_json_object_add_uint (node, "tx_table_id", ntohl (mp->tx_table_id));
14362 vat_json_object_add_string_copy (node, "swif_tag", mp->swif_tag);
14366 api_mpls_fib_decap_dump (vat_main_t * vam)
14368 vl_api_mpls_fib_decap_dump_t *mp;
14371 M (MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
14374 /* Use a control ping for synchronization */
14376 vl_api_control_ping_t *mp;
14377 M (CONTROL_PING, control_ping);
14384 api_classify_table_ids (vat_main_t * vam)
14386 vl_api_classify_table_ids_t *mp;
14389 /* Construct the API message */
14390 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14400 api_classify_table_by_interface (vat_main_t * vam)
14402 unformat_input_t *input = vam->input;
14403 vl_api_classify_table_by_interface_t *mp;
14406 u32 sw_if_index = ~0;
14407 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14409 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14411 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14416 if (sw_if_index == ~0)
14418 errmsg ("missing interface name or sw_if_index\n");
14422 /* Construct the API message */
14423 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14425 mp->sw_if_index = ntohl (sw_if_index);
14434 api_classify_table_info (vat_main_t * vam)
14436 unformat_input_t *input = vam->input;
14437 vl_api_classify_table_info_t *mp;
14441 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14443 if (unformat (input, "table_id %d", &table_id))
14448 if (table_id == ~0)
14450 errmsg ("missing table id\n");
14454 /* Construct the API message */
14455 M (CLASSIFY_TABLE_INFO, classify_table_info);
14457 mp->table_id = ntohl (table_id);
14466 api_classify_session_dump (vat_main_t * vam)
14468 unformat_input_t *input = vam->input;
14469 vl_api_classify_session_dump_t *mp;
14473 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14475 if (unformat (input, "table_id %d", &table_id))
14480 if (table_id == ~0)
14482 errmsg ("missing table id\n");
14486 /* Construct the API message */
14487 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14489 mp->table_id = ntohl (table_id);
14492 /* Use a control ping for synchronization */
14494 vl_api_control_ping_t *mp;
14495 M (CONTROL_PING, control_ping);
14504 vl_api_ipfix_details_t_handler (vl_api_ipfix_details_t * mp)
14506 vat_main_t *vam = &vat_main;
14508 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14509 "src_address %U, fib_index %u, path_mtu %u, "
14510 "template_interval %u\n",
14511 format_ip4_address, mp->collector_address,
14512 ntohs (mp->collector_port),
14513 format_ip4_address, mp->src_address,
14514 ntohl (mp->fib_index),
14515 ntohl (mp->path_mtu), ntohl (mp->template_interval));
14518 vam->result_ready = 1;
14522 vl_api_ipfix_details_t_handler_json (vl_api_ipfix_details_t * mp)
14524 vat_main_t *vam = &vat_main;
14525 vat_json_node_t node;
14526 struct in_addr collector_address;
14527 struct in_addr src_address;
14529 vat_json_init_object (&node);
14530 clib_memcpy (&collector_address, &mp->collector_address,
14531 sizeof (collector_address));
14532 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
14533 vat_json_object_add_uint (&node, "collector_port",
14534 ntohs (mp->collector_port));
14535 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
14536 vat_json_object_add_ip4 (&node, "src_address", src_address);
14537 vat_json_object_add_uint (&node, "fib_index", ntohl (mp->fib_index));
14538 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
14539 vat_json_object_add_uint (&node, "template_interval",
14540 ntohl (mp->template_interval));
14542 vat_json_print (vam->ofp, &node);
14543 vat_json_free (&node);
14545 vam->result_ready = 1;
14549 api_ipfix_dump (vat_main_t * vam)
14551 vl_api_ipfix_dump_t *mp;
14554 /* Construct the API message */
14555 M (IPFIX_DUMP, ipfix_dump);
14565 api_pg_create_interface (vat_main_t * vam)
14567 unformat_input_t *input = vam->input;
14568 vl_api_pg_create_interface_t *mp;
14572 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14574 if (unformat (input, "if_id %d", &if_id))
14581 errmsg ("missing pg interface index\n");
14585 /* Construct the API message */
14586 M (PG_CREATE_INTERFACE, pg_create_interface);
14588 mp->interface_id = ntohl (if_id);
14597 api_pg_capture (vat_main_t * vam)
14599 unformat_input_t *input = vam->input;
14600 vl_api_pg_capture_t *mp;
14606 u8 pcap_file_set = 0;
14608 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14610 if (unformat (input, "if_id %d", &if_id))
14612 else if (unformat (input, "pcap %s", &pcap_file))
14614 else if (unformat (input, "count %d", &count))
14616 else if (unformat (input, "disable"))
14623 errmsg ("missing pg interface index\n");
14626 if (pcap_file_set > 0)
14628 if (vec_len (pcap_file) > 255)
14630 errmsg ("pcap file name is too long\n");
14635 u32 name_len = vec_len (pcap_file);
14636 /* Construct the API message */
14637 M (PG_CAPTURE, pg_capture);
14639 mp->interface_id = ntohl (if_id);
14640 mp->is_enabled = enable;
14641 mp->count = ntohl (count);
14642 mp->pcap_name_length = ntohl (name_len);
14643 if (pcap_file_set != 0)
14645 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
14647 vec_free (pcap_file);
14656 api_pg_enable_disable (vat_main_t * vam)
14658 unformat_input_t *input = vam->input;
14659 vl_api_pg_enable_disable_t *mp;
14663 u8 stream_name_set = 0;
14664 u8 *stream_name = 0;
14665 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14667 if (unformat (input, "stream %s", &stream_name))
14668 stream_name_set = 1;
14669 else if (unformat (input, "disable"))
14675 if (stream_name_set > 0)
14677 if (vec_len (stream_name) > 255)
14679 errmsg ("stream name too long\n");
14684 u32 name_len = vec_len (stream_name);
14685 /* Construct the API message */
14686 M (PG_ENABLE_DISABLE, pg_enable_disable);
14688 mp->is_enabled = enable;
14689 if (stream_name_set != 0)
14691 mp->stream_name_length = ntohl (name_len);
14692 clib_memcpy (mp->stream_name, stream_name, name_len);
14694 vec_free (stream_name);
14703 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
14705 unformat_input_t *input = vam->input;
14706 vl_api_ip_source_and_port_range_check_add_del_t *mp;
14709 u16 *low_ports = 0;
14710 u16 *high_ports = 0;
14713 ip4_address_t ip4_addr;
14714 ip6_address_t ip6_addr;
14722 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14724 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
14730 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
14735 else if (unformat (input, "vrf %d", &vrf_id))
14737 else if (unformat (input, "del"))
14739 else if (unformat (input, "port %d", &tmp))
14741 if (tmp == 0 || tmp > 65535)
14743 errmsg ("port %d out of range", tmp);
14747 this_hi = this_low + 1;
14748 vec_add1 (low_ports, this_low);
14749 vec_add1 (high_ports, this_hi);
14751 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
14753 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
14755 errmsg ("incorrect range parameters\n");
14759 /* Note: in debug CLI +1 is added to high before
14760 passing to real fn that does "the work"
14761 (ip_source_and_port_range_check_add_del).
14762 This fn is a wrapper around the binary API fn a
14763 control plane will call, which expects this increment
14764 to have occurred. Hence letting the binary API control
14765 plane fn do the increment for consistency between VAT
14766 and other control planes.
14769 vec_add1 (low_ports, this_low);
14770 vec_add1 (high_ports, this_hi);
14776 if (prefix_set == 0)
14778 errmsg ("<address>/<mask> not specified\n");
14784 errmsg ("VRF ID required, not specified\n");
14791 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14795 if (vec_len (low_ports) == 0)
14797 errmsg ("At least one port or port range required\n");
14801 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
14802 ip_source_and_port_range_check_add_del);
14804 mp->is_add = is_add;
14809 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
14814 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
14817 mp->mask_length = length;
14818 mp->number_of_ranges = vec_len (low_ports);
14820 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
14821 vec_free (low_ports);
14823 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
14824 vec_free (high_ports);
14826 mp->vrf_id = ntohl (vrf_id);
14835 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
14837 unformat_input_t *input = vam->input;
14838 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
14840 u32 sw_if_index = ~0;
14842 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
14843 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
14846 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14848 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14850 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14852 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
14854 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
14856 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
14858 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
14860 else if (unformat (input, "del"))
14866 if (sw_if_index == ~0)
14868 errmsg ("Interface required but not specified\n");
14874 errmsg ("VRF ID required but not specified\n");
14878 if (tcp_out_vrf_id == 0
14879 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
14882 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
14886 /* Construct the API message */
14887 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
14888 ip_source_and_port_range_check_interface_add_del);
14890 mp->sw_if_index = ntohl (sw_if_index);
14891 mp->is_add = is_add;
14892 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
14893 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
14894 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
14895 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
14900 /* Wait for a reply... */
14905 q_or_quit (vat_main_t * vam)
14907 longjmp (vam->jump_buf, 1);
14908 return 0; /* not so much */
14912 q (vat_main_t * vam)
14914 return q_or_quit (vam);
14918 quit (vat_main_t * vam)
14920 return q_or_quit (vam);
14924 comment (vat_main_t * vam)
14930 cmd_cmp (void *a1, void *a2)
14935 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
14939 help (vat_main_t * vam)
14944 unformat_input_t *i = vam->input;
14947 if (unformat (i, "%s", &name))
14951 vec_add1 (name, 0);
14953 hs = hash_get_mem (vam->help_by_name, name);
14955 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
14957 fformat (vam->ofp, "No such msg / command '%s'\n", name);
14962 fformat (vam->ofp, "Help is available for the following:\n");
14965 hash_foreach_pair (p, vam->function_by_name,
14967 vec_add1 (cmds, (u8 *)(p->key));
14971 vec_sort_with_function (cmds, cmd_cmp);
14973 for (j = 0; j < vec_len (cmds); j++)
14974 fformat (vam->ofp, "%s\n", cmds[j]);
14981 set (vat_main_t * vam)
14983 u8 *name = 0, *value = 0;
14984 unformat_input_t *i = vam->input;
14986 if (unformat (i, "%s", &name))
14988 /* The input buffer is a vector, not a string. */
14989 value = vec_dup (i->buffer);
14990 vec_delete (value, i->index, 0);
14991 /* Almost certainly has a trailing newline */
14992 if (value[vec_len (value) - 1] == '\n')
14993 value[vec_len (value) - 1] = 0;
14994 /* Make sure it's a proper string, one way or the other */
14995 vec_add1 (value, 0);
14996 (void) clib_macro_set_value (&vam->macro_main,
14997 (char *) name, (char *) value);
15000 errmsg ("usage: set <name> <value>\n");
15008 unset (vat_main_t * vam)
15012 if (unformat (vam->input, "%s", &name))
15013 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15014 errmsg ("unset: %s wasn't set\n", name);
15027 macro_sort_cmp (void *a1, void *a2)
15029 macro_sort_t *s1 = a1;
15030 macro_sort_t *s2 = a2;
15032 return strcmp ((char *) (s1->name), (char *) (s2->name));
15036 dump_macro_table (vat_main_t * vam)
15038 macro_sort_t *sort_me = 0, *sm;
15043 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15045 vec_add2 (sort_me, sm, 1);
15046 sm->name = (u8 *)(p->key);
15047 sm->value = (u8 *) (p->value[0]);
15051 vec_sort_with_function (sort_me, macro_sort_cmp);
15053 if (vec_len (sort_me))
15054 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
15056 fformat (vam->ofp, "The macro table is empty...\n");
15058 for (i = 0; i < vec_len (sort_me); i++)
15059 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
15064 dump_node_table (vat_main_t * vam)
15067 vlib_node_t *node, *next_node;
15069 if (vec_len (vam->graph_nodes) == 0)
15071 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15075 for (i = 0; i < vec_len (vam->graph_nodes); i++)
15077 node = vam->graph_nodes[i];
15078 fformat (vam->ofp, "[%d] %s\n", i, node->name);
15079 for (j = 0; j < vec_len (node->next_nodes); j++)
15081 if (node->next_nodes[j] != ~0)
15083 next_node = vam->graph_nodes[node->next_nodes[j]];
15084 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15092 search_node_table (vat_main_t * vam)
15094 unformat_input_t *line_input = vam->input;
15097 vlib_node_t *node, *next_node;
15100 if (vam->graph_node_index_by_name == 0)
15102 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
15106 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
15108 if (unformat (line_input, "%s", &node_to_find))
15110 vec_add1 (node_to_find, 0);
15111 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
15114 fformat (vam->ofp, "%s not found...\n", node_to_find);
15117 node = vam->graph_nodes[p[0]];
15118 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
15119 for (j = 0; j < vec_len (node->next_nodes); j++)
15121 if (node->next_nodes[j] != ~0)
15123 next_node = vam->graph_nodes[node->next_nodes[j]];
15124 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
15131 clib_warning ("parse error '%U'", format_unformat_error,
15137 vec_free (node_to_find);
15146 script (vat_main_t * vam)
15149 char *save_current_file;
15150 unformat_input_t save_input;
15151 jmp_buf save_jump_buf;
15152 u32 save_line_number;
15154 FILE *new_fp, *save_ifp;
15156 if (unformat (vam->input, "%s", &s))
15158 new_fp = fopen ((char *) s, "r");
15161 errmsg ("Couldn't open script file %s\n", s);
15168 errmsg ("Missing script name\n");
15172 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
15173 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
15174 save_ifp = vam->ifp;
15175 save_line_number = vam->input_line_number;
15176 save_current_file = (char *) vam->current_file;
15178 vam->input_line_number = 0;
15180 vam->current_file = s;
15183 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
15184 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
15185 vam->ifp = save_ifp;
15186 vam->input_line_number = save_line_number;
15187 vam->current_file = (u8 *) save_current_file;
15194 echo (vat_main_t * vam)
15196 fformat (vam->ofp, "%v", vam->input->buffer);
15200 /* List of API message constructors, CLI names map to api_xxx */
15201 #define foreach_vpe_api_msg \
15202 _(create_loopback,"[mac <mac-addr>]") \
15203 _(sw_interface_dump,"") \
15204 _(sw_interface_set_flags, \
15205 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
15206 _(sw_interface_add_del_address, \
15207 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
15208 _(sw_interface_set_table, \
15209 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
15210 _(sw_interface_set_vpath, \
15211 "<intfc> | sw_if_index <id> enable | disable") \
15212 _(sw_interface_set_l2_xconnect, \
15213 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15214 "enable | disable") \
15215 _(sw_interface_set_l2_bridge, \
15216 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
15217 "[shg <split-horizon-group>] [bvi]\n" \
15218 "enable | disable") \
15219 _(bridge_domain_add_del, \
15220 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
15221 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
15223 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
15225 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
15227 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
15229 "tapname <name> mac <mac-addr> | random-mac") \
15231 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
15233 "<vpp-if-name> | sw_if_index <id>") \
15234 _(sw_interface_tap_dump, "") \
15235 _(ip_add_del_route, \
15236 "<addr>/<mask> via <addr> [vrf <n>]\n" \
15237 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
15238 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
15239 "[multipath] [count <n>]") \
15240 _(proxy_arp_add_del, \
15241 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
15242 _(proxy_arp_intfc_enable_disable, \
15243 "<intfc> | sw_if_index <id> enable | disable") \
15244 _(mpls_add_del_encap, \
15245 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
15246 _(mpls_add_del_decap, \
15247 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
15248 _(mpls_gre_add_del_tunnel, \
15249 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
15250 "adj <ip4-address>/<mask-width> [del]") \
15251 _(sw_interface_set_unnumbered, \
15252 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
15253 _(ip_neighbor_add_del, \
15254 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
15255 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
15256 _(reset_vrf, "vrf <id> [ipv6]") \
15257 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
15258 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
15259 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
15260 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
15261 "[outer_vlan_id_any][inner_vlan_id_any]") \
15262 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
15263 _(reset_fib, "vrf <n> [ipv6]") \
15264 _(dhcp_proxy_config, \
15265 "svr <v46-address> src <v46-address>\n" \
15266 "insert-cid <n> [del]") \
15267 _(dhcp_proxy_config_2, \
15268 "svr <v46-address> src <v46-address>\n" \
15269 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
15270 _(dhcp_proxy_set_vss, \
15271 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
15272 _(dhcp_client_config, \
15273 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
15274 _(set_ip_flow_hash, \
15275 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
15276 _(sw_interface_ip6_enable_disable, \
15277 "<intfc> | sw_if_index <id> enable | disable") \
15278 _(sw_interface_ip6_set_link_local_address, \
15279 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
15280 _(sw_interface_ip6nd_ra_prefix, \
15281 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
15282 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
15283 "[nolink] [isno]") \
15284 _(sw_interface_ip6nd_ra_config, \
15285 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
15286 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
15287 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
15288 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
15289 _(l2_patch_add_del, \
15290 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
15291 "enable | disable") \
15292 _(mpls_ethernet_add_del_tunnel, \
15293 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
15294 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
15295 _(mpls_ethernet_add_del_tunnel_2, \
15296 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
15297 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
15298 _(sr_tunnel_add_del, \
15299 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
15300 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
15301 "[policy <policy_name>]") \
15302 _(sr_policy_add_del, \
15303 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
15304 _(sr_multicast_map_add_del, \
15305 "address [ip6 multicast address] sr-policy [policy name] [del]") \
15306 _(classify_add_del_table, \
15307 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
15308 "[del] mask <mask-value>\n" \
15309 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
15310 _(classify_add_del_session, \
15311 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
15312 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
15313 " [l3 [ip4|ip6]]") \
15314 _(classify_set_interface_ip_table, \
15315 "<intfc> | sw_if_index <nn> table <nn>") \
15316 _(classify_set_interface_l2_tables, \
15317 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15318 " [other-table <nn>]") \
15319 _(get_node_index, "node <node-name") \
15320 _(add_node_next, "node <node-name> next <next-node-name>") \
15321 _(l2tpv3_create_tunnel, \
15322 "client_address <ip6-addr> our_address <ip6-addr>\n" \
15323 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
15324 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
15325 _(l2tpv3_set_tunnel_cookies, \
15326 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
15327 "[new_remote_cookie <nn>]\n") \
15328 _(l2tpv3_interface_enable_disable, \
15329 "<intfc> | sw_if_index <nn> enable | disable") \
15330 _(l2tpv3_set_lookup_key, \
15331 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
15332 _(sw_if_l2tpv3_tunnel_dump, "") \
15333 _(vxlan_add_del_tunnel, \
15334 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
15335 " [decap-next l2|ip4|ip6] [del]") \
15336 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15337 _(gre_add_del_tunnel, \
15338 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
15339 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15340 _(l2_fib_clear_table, "") \
15341 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
15342 _(l2_interface_vlan_tag_rewrite, \
15343 "<intfc> | sw_if_index <nn> \n" \
15344 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
15345 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
15346 _(create_vhost_user_if, \
15347 "socket <filename> [server] [renumber <dev_instance>] " \
15348 "[mac <mac_address>]") \
15349 _(modify_vhost_user_if, \
15350 "<intfc> | sw_if_index <nn> socket <filename>\n" \
15351 "[server] [renumber <dev_instance>]") \
15352 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
15353 _(sw_interface_vhost_user_dump, "") \
15354 _(show_version, "") \
15355 _(vxlan_gpe_add_del_tunnel, \
15356 "local <addr> remote <addr> vni <nn>\n" \
15357 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
15358 "[next-ethernet] [next-nsh]\n") \
15359 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
15360 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
15361 _(interface_name_renumber, \
15362 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
15363 _(input_acl_set_interface, \
15364 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15365 " [l2-table <nn>] [del]") \
15366 _(want_ip4_arp_events, "address <ip4-address> [del]") \
15367 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
15368 _(ip_dump, "ipv4 | ipv6") \
15369 _(ipsec_spd_add_del, "spd_id <n> [del]") \
15370 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
15372 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
15373 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
15374 " integ_alg <alg> integ_key <hex>") \
15375 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
15376 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
15377 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
15378 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
15379 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
15380 _(ikev2_profile_add_del, "name <profile_name> [del]") \
15381 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
15382 "(auth_data 0x<data> | auth_data <data>)") \
15383 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
15384 "(id_data 0x<data> | id_data <data>) (local|remote)") \
15385 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
15386 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
15387 "(local|remote)") \
15388 _(ikev2_set_local_key, "file <absolute_file_path>") \
15389 _(delete_loopback,"sw_if_index <nn>") \
15390 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
15391 _(map_add_domain, \
15392 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
15393 "ip6-src <ip6addr> " \
15394 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
15395 _(map_del_domain, "index <n>") \
15396 _(map_add_del_rule, \
15397 "index <n> psid <n> dst <ip6addr> [del]") \
15398 _(map_domain_dump, "") \
15399 _(map_rule_dump, "index <map-domain>") \
15400 _(want_interface_events, "enable|disable") \
15401 _(want_stats,"enable|disable") \
15402 _(get_first_msg_id, "client <name>") \
15403 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
15404 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
15405 "fib-id <nn> [ip4][ip6][default]") \
15406 _(get_node_graph, " ") \
15407 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
15408 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
15409 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
15410 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
15411 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
15412 " vrf_id <nn> add | pop | none") \
15413 _(trace_profile_del, "") \
15414 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
15415 " sw_if_index <sw_if_index> p <priority> " \
15416 "w <weight>] [del]") \
15417 _(lisp_add_del_locator, "locator-set <locator_name> " \
15418 "iface <intf> | sw_if_index <sw_if_index> " \
15419 "p <priority> w <weight> [del]") \
15420 _(lisp_add_del_local_eid,"vni <vni> eid " \
15421 "<ipv4|ipv6>/<prefix> | <L2 address> " \
15422 "locator-set <locator_name> [del]") \
15423 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
15424 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
15425 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
15426 _(lisp_gpe_enable_disable, "enable|disable") \
15427 _(lisp_enable_disable, "enable|disable") \
15428 _(lisp_gpe_add_del_iface, "up|down") \
15429 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> " \
15430 "rloc <locator> p <prio> " \
15431 "w <weight> [rloc <loc> ... ] " \
15432 "action <action> [del-all]") \
15433 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid " \
15434 "<src-eid> rloc <locator> p <prio> w <weight>"\
15435 "[rloc <loc> ... ] action <action>") \
15436 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
15437 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
15438 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
15439 _(lisp_locator_set_dump, "[locator-set-index <ls-index> | " \
15440 "locator-set <loc-set-name>] [local | remote]")\
15441 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
15442 "[local] | [remote]") \
15443 _(lisp_eid_table_map_dump, "") \
15444 _(lisp_gpe_tunnel_dump, "") \
15445 _(lisp_map_resolver_dump, "") \
15446 _(show_lisp_status, "") \
15447 _(lisp_get_map_request_itr_rlocs, "") \
15448 _(show_lisp_pitr, "") \
15449 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
15450 _(af_packet_delete, "name <host interface name>") \
15451 _(policer_add_del, "name <policer name> <params> [del]") \
15452 _(policer_dump, "[name <policer name>]") \
15453 _(policer_classify_set_interface, \
15454 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
15455 " [l2-table <nn>] [del]") \
15456 _(policer_classify_dump, "type [ip4|ip6|l2]") \
15457 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
15458 "[master|slave]") \
15459 _(netmap_delete, "name <interface name>") \
15460 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
15461 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
15462 _(mpls_fib_encap_dump, "") \
15463 _(mpls_fib_decap_dump, "") \
15464 _(classify_table_ids, "") \
15465 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
15466 _(classify_table_info, "table_id <nn>") \
15467 _(classify_session_dump, "table_id <nn>") \
15468 _(ipfix_enable, "collector_address <ip4> [collector_port <nn>] " \
15469 "src_address <ip4> [fib_id <nn>] [path_mtu <nn>] " \
15470 "[template_interval <nn>]") \
15471 _(ipfix_dump, "") \
15472 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
15473 _(pg_create_interface, "if_id <nn>") \
15474 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
15475 _(pg_enable_disable, "[stream <id>] disable") \
15476 _(ip_source_and_port_range_check_add_del, \
15477 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
15478 _(ip_source_and_port_range_check_interface_add_del, \
15479 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
15480 "[udp-in-vrf <id>] [udp-out-vrf <id>]")
15482 /* List of command functions, CLI names map directly to functions */
15483 #define foreach_cli_function \
15484 _(comment, "usage: comment <ignore-rest-of-line>") \
15485 _(dump_interface_table, "usage: dump_interface_table") \
15486 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
15487 _(dump_ipv4_table, "usage: dump_ipv4_table") \
15488 _(dump_ipv6_table, "usage: dump_ipv6_table") \
15489 _(dump_stats_table, "usage: dump_stats_table") \
15490 _(dump_macro_table, "usage: dump_macro_table ") \
15491 _(dump_node_table, "usage: dump_node_table") \
15492 _(echo, "usage: echo <message>") \
15493 _(exec, "usage: exec <vpe-debug-CLI-command>") \
15494 _(help, "usage: help") \
15495 _(q, "usage: quit") \
15496 _(quit, "usage: quit") \
15497 _(search_node_table, "usage: search_node_table <name>...") \
15498 _(set, "usage: set <variable-name> <value>") \
15499 _(script, "usage: script <file-name>") \
15500 _(unset, "usage: unset <variable-name>")
15503 static void vl_api_##n##_t_handler_uni \
15504 (vl_api_##n##_t * mp) \
15506 vat_main_t * vam = &vat_main; \
15507 if (vam->json_output) { \
15508 vl_api_##n##_t_handler_json(mp); \
15510 vl_api_##n##_t_handler(mp); \
15513 foreach_vpe_api_reply_msg;
15517 vat_api_hookup (vat_main_t * vam)
15520 vl_msg_api_set_handlers(VL_API_##N, #n, \
15521 vl_api_##n##_t_handler_uni, \
15523 vl_api_##n##_t_endian, \
15524 vl_api_##n##_t_print, \
15525 sizeof(vl_api_##n##_t), 1);
15526 foreach_vpe_api_reply_msg;
15529 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
15531 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
15533 vam->function_by_name = hash_create_string (0, sizeof (uword));
15535 vam->help_by_name = hash_create_string (0, sizeof (uword));
15537 /* API messages we can send */
15538 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
15539 foreach_vpe_api_msg;
15543 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15544 foreach_vpe_api_msg;
15547 /* CLI functions */
15548 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
15549 foreach_cli_function;
15553 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
15554 foreach_cli_function;
15558 #undef vl_api_version
15559 #define vl_api_version(n,v) static u32 vpe_api_version = v;
15560 #include <vpp-api/vpe.api.h>
15561 #undef vl_api_version
15564 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
15567 * Send the main API signature in slot 0. This bit of code must
15568 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
15570 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
15574 * fd.io coding-style-patch-verification: ON
15577 * eval: (c-set-style "gnu")