2 *------------------------------------------------------------------
5 * Copyright (c) 2014-2016 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/classify/flow_classify.h>
39 #include <vnet/mpls/mpls.h>
41 #include <vnet/ipsec/ipsec.h>
42 #include <vnet/ipsec/ikev2.h>
46 #include <vnet/map/map.h>
47 #include <vnet/cop/cop.h>
48 #include <vnet/ip/ip6_hop_by_hop.h>
49 #include <vnet/ip/ip_source_and_port_range_check.h>
50 #include <vnet/policer/xlate.h>
51 #include <vnet/span/span.h>
52 #include <vnet/policer/policer.h>
53 #include <vnet/policer/police.h>
55 #include "vat/json_format.h"
59 #define vl_typedefs /* define message structures */
60 #include <vpp-api/vpe_all_api_h.h>
63 /* declare message handlers for each api */
65 #define vl_endianfun /* define message structures */
66 #include <vpp-api/vpe_all_api_h.h>
69 /* instantiate all the print functions we know about */
70 #define vl_print(handle, ...)
72 #include <vpp-api/vpe_all_api_h.h>
76 unformat_sw_if_index (unformat_input_t * input, va_list * args)
78 vat_main_t *vam = va_arg (*args, vat_main_t *);
79 u32 *result = va_arg (*args, u32 *);
83 if (!unformat (input, "%s", &if_name))
86 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
93 /* Parse an IP4 address %d.%d.%d.%d. */
95 unformat_ip4_address (unformat_input_t * input, va_list * args)
97 u8 *result = va_arg (*args, u8 *);
100 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
103 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
116 unformat_ethernet_address (unformat_input_t * input, va_list * args)
118 u8 *result = va_arg (*args, u8 *);
121 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
122 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
126 for (i = 0; i < 6; i++)
127 if (a[i] >= (1 << 8))
130 for (i = 0; i < 6; i++)
136 /* Returns ethernet type as an int in host byte order. */
138 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
141 u16 *result = va_arg (*args, u16 *);
145 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
147 if (type >= (1 << 16))
155 /* Parse an IP6 address. */
157 unformat_ip6_address (unformat_input_t * input, va_list * args)
159 ip6_address_t *result = va_arg (*args, ip6_address_t *);
161 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
162 uword c, n_colon, double_colon_index;
164 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
165 double_colon_index = ARRAY_LEN (hex_quads);
166 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
169 if (c >= '0' && c <= '9')
171 else if (c >= 'a' && c <= 'f')
172 hex_digit = c + 10 - 'a';
173 else if (c >= 'A' && c <= 'F')
174 hex_digit = c + 10 - 'A';
175 else if (c == ':' && n_colon < 2)
179 unformat_put_input (input);
183 /* Too many hex quads. */
184 if (n_hex_quads >= ARRAY_LEN (hex_quads))
189 hex_quad = (hex_quad << 4) | hex_digit;
191 /* Hex quad must fit in 16 bits. */
192 if (n_hex_digits >= 4)
199 /* Save position of :: */
202 /* More than one :: ? */
203 if (double_colon_index < ARRAY_LEN (hex_quads))
205 double_colon_index = n_hex_quads;
208 if (n_colon > 0 && n_hex_digits > 0)
210 hex_quads[n_hex_quads++] = hex_quad;
216 if (n_hex_digits > 0)
217 hex_quads[n_hex_quads++] = hex_quad;
222 /* Expand :: to appropriate number of zero hex quads. */
223 if (double_colon_index < ARRAY_LEN (hex_quads))
225 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
227 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
228 hex_quads[n_zero + i] = hex_quads[i];
230 for (i = 0; i < n_zero; i++)
231 hex_quads[double_colon_index + i] = 0;
233 n_hex_quads = ARRAY_LEN (hex_quads);
236 /* Too few hex quads given. */
237 if (n_hex_quads < ARRAY_LEN (hex_quads))
240 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
241 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
248 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
251 u32 *r = va_arg (*args, u32 *);
254 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
255 foreach_ipsec_policy_action
266 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
269 u32 *r = va_arg (*args, u32 *);
272 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
273 foreach_ipsec_crypto_alg
284 format_ipsec_crypto_alg (u8 * s, va_list * args)
287 u32 i = va_arg (*args, u32);
292 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
293 foreach_ipsec_crypto_alg
296 return format (s, "unknown");
298 return format (s, "%s", t);
300 return format (s, "Unimplemented");
305 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
308 u32 *r = va_arg (*args, u32 *);
311 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
312 foreach_ipsec_integ_alg
323 format_ipsec_integ_alg (u8 * s, va_list * args)
326 u32 i = va_arg (*args, u32);
331 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
332 foreach_ipsec_integ_alg
335 return format (s, "unknown");
337 return format (s, "%s", t);
339 return format (s, "Unsupported");
344 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
347 u32 *r = va_arg (*args, u32 *);
350 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
351 foreach_ikev2_auth_method
362 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
365 u32 *r = va_arg (*args, u32 *);
368 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
369 foreach_ikev2_id_type
380 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
382 u8 *r = va_arg (*args, u8 *);
384 if (unformat (input, "kbps"))
385 *r = SSE2_QOS_RATE_KBPS;
386 else if (unformat (input, "pps"))
387 *r = SSE2_QOS_RATE_PPS;
394 unformat_policer_round_type (unformat_input_t * input, va_list * args)
396 u8 *r = va_arg (*args, u8 *);
398 if (unformat (input, "closest"))
399 *r = SSE2_QOS_ROUND_TO_CLOSEST;
400 else if (unformat (input, "up"))
401 *r = SSE2_QOS_ROUND_TO_UP;
402 else if (unformat (input, "down"))
403 *r = SSE2_QOS_ROUND_TO_DOWN;
410 unformat_policer_type (unformat_input_t * input, va_list * args)
412 u8 *r = va_arg (*args, u8 *);
414 if (unformat (input, "1r2c"))
415 *r = SSE2_QOS_POLICER_TYPE_1R2C;
416 else if (unformat (input, "1r3c"))
417 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
418 else if (unformat (input, "2r3c-2698"))
419 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
420 else if (unformat (input, "2r3c-4115"))
421 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
422 else if (unformat (input, "2r3c-mef5cf1"))
423 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
430 unformat_dscp (unformat_input_t * input, va_list * va)
432 u8 *r = va_arg (*va, u8 *);
435 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
444 unformat_policer_action_type (unformat_input_t * input, va_list * va)
446 sse2_qos_pol_action_params_st *a
447 = va_arg (*va, sse2_qos_pol_action_params_st *);
449 if (unformat (input, "drop"))
450 a->action_type = SSE2_QOS_ACTION_DROP;
451 else if (unformat (input, "transmit"))
452 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
453 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
454 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
461 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
463 u32 *r = va_arg (*va, u32 *);
466 if (unformat (input, "ip4"))
467 tid = POLICER_CLASSIFY_TABLE_IP4;
468 else if (unformat (input, "ip6"))
469 tid = POLICER_CLASSIFY_TABLE_IP6;
470 else if (unformat (input, "l2"))
471 tid = POLICER_CLASSIFY_TABLE_L2;
480 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
482 u32 *r = va_arg (*va, u32 *);
485 if (unformat (input, "ip4"))
486 tid = FLOW_CLASSIFY_TABLE_IP4;
487 else if (unformat (input, "ip6"))
488 tid = FLOW_CLASSIFY_TABLE_IP6;
497 format_ip4_address (u8 * s, va_list * args)
499 u8 *a = va_arg (*args, u8 *);
500 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
504 format_ip6_address (u8 * s, va_list * args)
506 ip6_address_t *a = va_arg (*args, ip6_address_t *);
507 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
509 i_max_n_zero = ARRAY_LEN (a->as_u16);
511 i_first_zero = i_max_n_zero;
513 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
515 u32 is_zero = a->as_u16[i] == 0;
516 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
522 if ((!is_zero && n_zeros > max_n_zeros)
523 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
525 i_max_n_zero = i_first_zero;
526 max_n_zeros = n_zeros;
527 i_first_zero = ARRAY_LEN (a->as_u16);
532 last_double_colon = 0;
533 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
535 if (i == i_max_n_zero && max_n_zeros > 1)
537 s = format (s, "::");
538 i += max_n_zeros - 1;
539 last_double_colon = 1;
543 s = format (s, "%s%x",
544 (last_double_colon || i == 0) ? "" : ":",
545 clib_net_to_host_u16 (a->as_u16[i]));
546 last_double_colon = 0;
553 /* Format an IP46 address. */
555 format_ip46_address (u8 * s, va_list * args)
557 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
558 ip46_type_t type = va_arg (*args, ip46_type_t);
564 is_ip4 = ip46_address_is_ip4 (ip46);
575 format (s, "%U", format_ip4_address, &ip46->ip4) :
576 format (s, "%U", format_ip6_address, &ip46->ip6);
580 format_ethernet_address (u8 * s, va_list * args)
582 u8 *a = va_arg (*args, u8 *);
584 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
585 a[0], a[1], a[2], a[3], a[4], a[5]);
589 increment_v4_address (ip4_address_t * a)
593 v = ntohl (a->as_u32) + 1;
594 a->as_u32 = ntohl (v);
598 increment_v6_address (ip6_address_t * a)
602 v0 = clib_net_to_host_u64 (a->as_u64[0]);
603 v1 = clib_net_to_host_u64 (a->as_u64[1]);
608 a->as_u64[0] = clib_net_to_host_u64 (v0);
609 a->as_u64[1] = clib_net_to_host_u64 (v1);
613 increment_mac_address (u64 * mac)
617 tmp = clib_net_to_host_u64 (tmp);
618 tmp += 1 << 16; /* skip unused (least significant) octets */
619 tmp = clib_host_to_net_u64 (tmp);
623 static void vl_api_create_loopback_reply_t_handler
624 (vl_api_create_loopback_reply_t * mp)
626 vat_main_t *vam = &vat_main;
627 i32 retval = ntohl (mp->retval);
629 vam->retval = retval;
630 vam->regenerate_interface_table = 1;
631 vam->sw_if_index = ntohl (mp->sw_if_index);
632 vam->result_ready = 1;
635 static void vl_api_create_loopback_reply_t_handler_json
636 (vl_api_create_loopback_reply_t * mp)
638 vat_main_t *vam = &vat_main;
639 vat_json_node_t node;
641 vat_json_init_object (&node);
642 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
643 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
645 vat_json_print (vam->ofp, &node);
646 vat_json_free (&node);
647 vam->retval = ntohl (mp->retval);
648 vam->result_ready = 1;
651 static void vl_api_af_packet_create_reply_t_handler
652 (vl_api_af_packet_create_reply_t * mp)
654 vat_main_t *vam = &vat_main;
655 i32 retval = ntohl (mp->retval);
657 vam->retval = retval;
658 vam->regenerate_interface_table = 1;
659 vam->sw_if_index = ntohl (mp->sw_if_index);
660 vam->result_ready = 1;
663 static void vl_api_af_packet_create_reply_t_handler_json
664 (vl_api_af_packet_create_reply_t * mp)
666 vat_main_t *vam = &vat_main;
667 vat_json_node_t node;
669 vat_json_init_object (&node);
670 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
671 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
673 vat_json_print (vam->ofp, &node);
674 vat_json_free (&node);
676 vam->retval = ntohl (mp->retval);
677 vam->result_ready = 1;
680 static void vl_api_create_vlan_subif_reply_t_handler
681 (vl_api_create_vlan_subif_reply_t * mp)
683 vat_main_t *vam = &vat_main;
684 i32 retval = ntohl (mp->retval);
686 vam->retval = retval;
687 vam->regenerate_interface_table = 1;
688 vam->sw_if_index = ntohl (mp->sw_if_index);
689 vam->result_ready = 1;
692 static void vl_api_create_vlan_subif_reply_t_handler_json
693 (vl_api_create_vlan_subif_reply_t * mp)
695 vat_main_t *vam = &vat_main;
696 vat_json_node_t node;
698 vat_json_init_object (&node);
699 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
700 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
702 vat_json_print (vam->ofp, &node);
703 vat_json_free (&node);
705 vam->retval = ntohl (mp->retval);
706 vam->result_ready = 1;
709 static void vl_api_create_subif_reply_t_handler
710 (vl_api_create_subif_reply_t * mp)
712 vat_main_t *vam = &vat_main;
713 i32 retval = ntohl (mp->retval);
715 vam->retval = retval;
716 vam->regenerate_interface_table = 1;
717 vam->sw_if_index = ntohl (mp->sw_if_index);
718 vam->result_ready = 1;
721 static void vl_api_create_subif_reply_t_handler_json
722 (vl_api_create_subif_reply_t * mp)
724 vat_main_t *vam = &vat_main;
725 vat_json_node_t node;
727 vat_json_init_object (&node);
728 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
729 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
731 vat_json_print (vam->ofp, &node);
732 vat_json_free (&node);
734 vam->retval = ntohl (mp->retval);
735 vam->result_ready = 1;
738 static void vl_api_interface_name_renumber_reply_t_handler
739 (vl_api_interface_name_renumber_reply_t * mp)
741 vat_main_t *vam = &vat_main;
742 i32 retval = ntohl (mp->retval);
744 vam->retval = retval;
745 vam->regenerate_interface_table = 1;
746 vam->result_ready = 1;
749 static void vl_api_interface_name_renumber_reply_t_handler_json
750 (vl_api_interface_name_renumber_reply_t * mp)
752 vat_main_t *vam = &vat_main;
753 vat_json_node_t node;
755 vat_json_init_object (&node);
756 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
758 vat_json_print (vam->ofp, &node);
759 vat_json_free (&node);
761 vam->retval = ntohl (mp->retval);
762 vam->result_ready = 1;
766 * Special-case: build the interface table, maintain
767 * the next loopback sw_if_index vbl.
769 static void vl_api_sw_interface_details_t_handler
770 (vl_api_sw_interface_details_t * mp)
772 vat_main_t *vam = &vat_main;
773 u8 *s = format (0, "%s%c", mp->interface_name, 0);
775 hash_set_mem (vam->sw_if_index_by_interface_name, s,
776 ntohl (mp->sw_if_index));
778 /* In sub interface case, fill the sub interface table entry */
779 if (mp->sw_if_index != mp->sup_sw_if_index)
781 sw_interface_subif_t *sub = NULL;
783 vec_add2 (vam->sw_if_subif_table, sub, 1);
785 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
786 strncpy ((char *) sub->interface_name, (char *) s,
787 vec_len (sub->interface_name));
788 sub->sw_if_index = ntohl (mp->sw_if_index);
789 sub->sub_id = ntohl (mp->sub_id);
791 sub->sub_dot1ad = mp->sub_dot1ad;
792 sub->sub_number_of_tags = mp->sub_number_of_tags;
793 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
794 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
795 sub->sub_exact_match = mp->sub_exact_match;
796 sub->sub_default = mp->sub_default;
797 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
798 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
800 /* vlan tag rewrite */
801 sub->vtr_op = ntohl (mp->vtr_op);
802 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
803 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
804 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
808 static void vl_api_sw_interface_details_t_handler_json
809 (vl_api_sw_interface_details_t * mp)
811 vat_main_t *vam = &vat_main;
812 vat_json_node_t *node = NULL;
814 if (VAT_JSON_ARRAY != vam->json_tree.type)
816 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
817 vat_json_init_array (&vam->json_tree);
819 node = vat_json_array_add (&vam->json_tree);
821 vat_json_init_object (node);
822 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
823 vat_json_object_add_uint (node, "sup_sw_if_index",
824 ntohl (mp->sup_sw_if_index));
825 vat_json_object_add_uint (node, "l2_address_length",
826 ntohl (mp->l2_address_length));
827 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
828 sizeof (mp->l2_address));
829 vat_json_object_add_string_copy (node, "interface_name",
831 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
832 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
833 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
834 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
835 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
836 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
837 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
838 vat_json_object_add_uint (node, "sub_number_of_tags",
839 mp->sub_number_of_tags);
840 vat_json_object_add_uint (node, "sub_outer_vlan_id",
841 ntohs (mp->sub_outer_vlan_id));
842 vat_json_object_add_uint (node, "sub_inner_vlan_id",
843 ntohs (mp->sub_inner_vlan_id));
844 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
845 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
846 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
847 mp->sub_outer_vlan_id_any);
848 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
849 mp->sub_inner_vlan_id_any);
850 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
851 vat_json_object_add_uint (node, "vtr_push_dot1q",
852 ntohl (mp->vtr_push_dot1q));
853 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
854 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
857 static void vl_api_sw_interface_set_flags_t_handler
858 (vl_api_sw_interface_set_flags_t * mp)
860 vat_main_t *vam = &vat_main;
861 if (vam->interface_event_display)
862 errmsg ("interface flags: sw_if_index %d %s %s\n",
863 ntohl (mp->sw_if_index),
864 mp->admin_up_down ? "admin-up" : "admin-down",
865 mp->link_up_down ? "link-up" : "link-down");
868 static void vl_api_sw_interface_set_flags_t_handler_json
869 (vl_api_sw_interface_set_flags_t * mp)
871 /* JSON output not supported */
875 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
877 vat_main_t *vam = &vat_main;
878 i32 retval = ntohl (mp->retval);
880 vam->retval = retval;
881 vam->shmem_result = (u8 *) mp->reply_in_shmem;
882 vam->result_ready = 1;
886 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
888 vat_main_t *vam = &vat_main;
889 vat_json_node_t node;
890 api_main_t *am = &api_main;
894 vat_json_init_object (&node);
895 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
896 vat_json_object_add_uint (&node, "reply_in_shmem",
897 ntohl (mp->reply_in_shmem));
898 /* Toss the shared-memory original... */
899 pthread_mutex_lock (&am->vlib_rp->mutex);
900 oldheap = svm_push_data_heap (am->vlib_rp);
902 reply = (u8 *) (mp->reply_in_shmem);
905 svm_pop_heap (oldheap);
906 pthread_mutex_unlock (&am->vlib_rp->mutex);
908 vat_json_print (vam->ofp, &node);
909 vat_json_free (&node);
911 vam->retval = ntohl (mp->retval);
912 vam->result_ready = 1;
916 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
918 vat_main_t *vam = &vat_main;
919 i32 retval = ntohl (mp->retval);
921 vam->retval = retval;
922 vam->cmd_reply = mp->reply;
923 vam->result_ready = 1;
927 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
929 vat_main_t *vam = &vat_main;
930 vat_json_node_t node;
932 vat_json_init_object (&node);
933 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
934 vat_json_object_add_string_copy (&node, "reply", mp->reply);
936 vat_json_print (vam->ofp, &node);
937 vat_json_free (&node);
939 vam->retval = ntohl (mp->retval);
940 vam->result_ready = 1;
943 static void vl_api_classify_add_del_table_reply_t_handler
944 (vl_api_classify_add_del_table_reply_t * mp)
946 vat_main_t *vam = &vat_main;
947 i32 retval = ntohl (mp->retval);
950 vam->async_errors += (retval < 0);
954 vam->retval = retval;
956 ((mp->new_table_index != 0xFFFFFFFF) ||
957 (mp->skip_n_vectors != 0xFFFFFFFF) ||
958 (mp->match_n_vectors != 0xFFFFFFFF)))
960 * Note: this is just barely thread-safe, depends on
961 * the main thread spinning waiting for an answer...
963 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
964 ntohl (mp->new_table_index),
965 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
966 vam->result_ready = 1;
970 static void vl_api_classify_add_del_table_reply_t_handler_json
971 (vl_api_classify_add_del_table_reply_t * mp)
973 vat_main_t *vam = &vat_main;
974 vat_json_node_t node;
976 vat_json_init_object (&node);
977 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
978 vat_json_object_add_uint (&node, "new_table_index",
979 ntohl (mp->new_table_index));
980 vat_json_object_add_uint (&node, "skip_n_vectors",
981 ntohl (mp->skip_n_vectors));
982 vat_json_object_add_uint (&node, "match_n_vectors",
983 ntohl (mp->match_n_vectors));
985 vat_json_print (vam->ofp, &node);
986 vat_json_free (&node);
988 vam->retval = ntohl (mp->retval);
989 vam->result_ready = 1;
992 static void vl_api_get_node_index_reply_t_handler
993 (vl_api_get_node_index_reply_t * mp)
995 vat_main_t *vam = &vat_main;
996 i32 retval = ntohl (mp->retval);
999 vam->async_errors += (retval < 0);
1003 vam->retval = retval;
1005 errmsg ("node index %d\n", ntohl (mp->node_index));
1006 vam->result_ready = 1;
1010 static void vl_api_get_node_index_reply_t_handler_json
1011 (vl_api_get_node_index_reply_t * mp)
1013 vat_main_t *vam = &vat_main;
1014 vat_json_node_t node;
1016 vat_json_init_object (&node);
1017 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1018 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1020 vat_json_print (vam->ofp, &node);
1021 vat_json_free (&node);
1023 vam->retval = ntohl (mp->retval);
1024 vam->result_ready = 1;
1027 static void vl_api_get_next_index_reply_t_handler
1028 (vl_api_get_next_index_reply_t * mp)
1030 vat_main_t *vam = &vat_main;
1031 i32 retval = ntohl (mp->retval);
1032 if (vam->async_mode)
1034 vam->async_errors += (retval < 0);
1038 vam->retval = retval;
1040 errmsg ("next node index %d\n", ntohl (mp->next_index));
1041 vam->result_ready = 1;
1045 static void vl_api_get_next_index_reply_t_handler_json
1046 (vl_api_get_next_index_reply_t * mp)
1048 vat_main_t *vam = &vat_main;
1049 vat_json_node_t node;
1051 vat_json_init_object (&node);
1052 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1053 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1055 vat_json_print (vam->ofp, &node);
1056 vat_json_free (&node);
1058 vam->retval = ntohl (mp->retval);
1059 vam->result_ready = 1;
1062 static void vl_api_add_node_next_reply_t_handler
1063 (vl_api_add_node_next_reply_t * mp)
1065 vat_main_t *vam = &vat_main;
1066 i32 retval = ntohl (mp->retval);
1067 if (vam->async_mode)
1069 vam->async_errors += (retval < 0);
1073 vam->retval = retval;
1075 errmsg ("next index %d\n", ntohl (mp->next_index));
1076 vam->result_ready = 1;
1080 static void vl_api_add_node_next_reply_t_handler_json
1081 (vl_api_add_node_next_reply_t * mp)
1083 vat_main_t *vam = &vat_main;
1084 vat_json_node_t node;
1086 vat_json_init_object (&node);
1087 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1088 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1090 vat_json_print (vam->ofp, &node);
1091 vat_json_free (&node);
1093 vam->retval = ntohl (mp->retval);
1094 vam->result_ready = 1;
1097 static void vl_api_show_version_reply_t_handler
1098 (vl_api_show_version_reply_t * mp)
1100 vat_main_t *vam = &vat_main;
1101 i32 retval = ntohl (mp->retval);
1105 errmsg (" program: %s\n", mp->program);
1106 errmsg (" version: %s\n", mp->version);
1107 errmsg (" build date: %s\n", mp->build_date);
1108 errmsg ("build directory: %s\n", mp->build_directory);
1110 vam->retval = retval;
1111 vam->result_ready = 1;
1114 static void vl_api_show_version_reply_t_handler_json
1115 (vl_api_show_version_reply_t * mp)
1117 vat_main_t *vam = &vat_main;
1118 vat_json_node_t node;
1120 vat_json_init_object (&node);
1121 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1122 vat_json_object_add_string_copy (&node, "program", mp->program);
1123 vat_json_object_add_string_copy (&node, "version", mp->version);
1124 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1125 vat_json_object_add_string_copy (&node, "build_directory",
1126 mp->build_directory);
1128 vat_json_print (vam->ofp, &node);
1129 vat_json_free (&node);
1131 vam->retval = ntohl (mp->retval);
1132 vam->result_ready = 1;
1136 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1138 vat_main_t *vam = &vat_main;
1139 errmsg ("arp %s event: address %U new mac %U sw_if_index %d\n",
1140 mp->mac_ip ? "mac/ip binding" : "address resolution",
1141 format_ip4_address, &mp->address,
1142 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1146 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1148 /* JSON output not supported */
1152 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1154 vat_main_t *vam = &vat_main;
1155 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d\n",
1156 mp->mac_ip ? "mac/ip binding" : "address resolution",
1157 format_ip6_address, mp->address,
1158 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1162 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1164 /* JSON output not supported */
1168 * Special-case: build the bridge domain table, maintain
1169 * the next bd id vbl.
1171 static void vl_api_bridge_domain_details_t_handler
1172 (vl_api_bridge_domain_details_t * mp)
1174 vat_main_t *vam = &vat_main;
1175 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1177 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1178 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1180 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1181 ntohl (mp->bd_id), mp->learn, mp->forward,
1182 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1185 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1189 static void vl_api_bridge_domain_details_t_handler_json
1190 (vl_api_bridge_domain_details_t * mp)
1192 vat_main_t *vam = &vat_main;
1193 vat_json_node_t *node, *array = NULL;
1195 if (VAT_JSON_ARRAY != vam->json_tree.type)
1197 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1198 vat_json_init_array (&vam->json_tree);
1200 node = vat_json_array_add (&vam->json_tree);
1202 vat_json_init_object (node);
1203 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1204 vat_json_object_add_uint (node, "flood", mp->flood);
1205 vat_json_object_add_uint (node, "forward", mp->forward);
1206 vat_json_object_add_uint (node, "learn", mp->learn);
1207 vat_json_object_add_uint (node, "bvi_sw_if_index",
1208 ntohl (mp->bvi_sw_if_index));
1209 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1210 array = vat_json_object_add (node, "sw_if");
1211 vat_json_init_array (array);
1215 * Special-case: build the bridge domain sw if table.
1217 static void vl_api_bridge_domain_sw_if_details_t_handler
1218 (vl_api_bridge_domain_sw_if_details_t * mp)
1220 vat_main_t *vam = &vat_main;
1225 sw_if_index = ntohl (mp->sw_if_index);
1227 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1229 if ((u32) p->value[0] == sw_if_index)
1231 sw_if_name = (u8 *)(p->key);
1237 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1238 mp->shg, sw_if_name ? (char *) sw_if_name :
1239 "sw_if_index not found!");
1242 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1243 (vl_api_bridge_domain_sw_if_details_t * mp)
1245 vat_main_t *vam = &vat_main;
1246 vat_json_node_t *node = NULL;
1247 uword last_index = 0;
1249 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1250 ASSERT (vec_len (vam->json_tree.array) >= 1);
1251 last_index = vec_len (vam->json_tree.array) - 1;
1252 node = &vam->json_tree.array[last_index];
1253 node = vat_json_object_get_element (node, "sw_if");
1254 ASSERT (NULL != node);
1255 node = vat_json_array_add (node);
1257 vat_json_init_object (node);
1258 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1259 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1260 vat_json_object_add_uint (node, "shg", mp->shg);
1263 static void vl_api_control_ping_reply_t_handler
1264 (vl_api_control_ping_reply_t * mp)
1266 vat_main_t *vam = &vat_main;
1267 i32 retval = ntohl (mp->retval);
1268 if (vam->async_mode)
1270 vam->async_errors += (retval < 0);
1274 vam->retval = retval;
1275 vam->result_ready = 1;
1279 static void vl_api_control_ping_reply_t_handler_json
1280 (vl_api_control_ping_reply_t * mp)
1282 vat_main_t *vam = &vat_main;
1283 i32 retval = ntohl (mp->retval);
1285 if (VAT_JSON_NONE != vam->json_tree.type)
1287 vat_json_print (vam->ofp, &vam->json_tree);
1288 vat_json_free (&vam->json_tree);
1289 vam->json_tree.type = VAT_JSON_NONE;
1294 vat_json_init_array (&vam->json_tree);
1295 vat_json_print (vam->ofp, &vam->json_tree);
1296 vam->json_tree.type = VAT_JSON_NONE;
1299 vam->retval = retval;
1300 vam->result_ready = 1;
1304 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1306 vat_main_t *vam = &vat_main;
1307 i32 retval = ntohl (mp->retval);
1308 if (vam->async_mode)
1310 vam->async_errors += (retval < 0);
1314 vam->retval = retval;
1315 vam->result_ready = 1;
1319 static void vl_api_l2_flags_reply_t_handler_json
1320 (vl_api_l2_flags_reply_t * mp)
1322 vat_main_t *vam = &vat_main;
1323 vat_json_node_t node;
1325 vat_json_init_object (&node);
1326 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1327 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1328 ntohl (mp->resulting_feature_bitmap));
1330 vat_json_print (vam->ofp, &node);
1331 vat_json_free (&node);
1333 vam->retval = ntohl (mp->retval);
1334 vam->result_ready = 1;
1337 static void vl_api_bridge_flags_reply_t_handler
1338 (vl_api_bridge_flags_reply_t * mp)
1340 vat_main_t *vam = &vat_main;
1341 i32 retval = ntohl (mp->retval);
1342 if (vam->async_mode)
1344 vam->async_errors += (retval < 0);
1348 vam->retval = retval;
1349 vam->result_ready = 1;
1353 static void vl_api_bridge_flags_reply_t_handler_json
1354 (vl_api_bridge_flags_reply_t * mp)
1356 vat_main_t *vam = &vat_main;
1357 vat_json_node_t node;
1359 vat_json_init_object (&node);
1360 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1361 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1362 ntohl (mp->resulting_feature_bitmap));
1364 vat_json_print (vam->ofp, &node);
1365 vat_json_free (&node);
1367 vam->retval = ntohl (mp->retval);
1368 vam->result_ready = 1;
1371 static void vl_api_tap_connect_reply_t_handler
1372 (vl_api_tap_connect_reply_t * mp)
1374 vat_main_t *vam = &vat_main;
1375 i32 retval = ntohl (mp->retval);
1376 if (vam->async_mode)
1378 vam->async_errors += (retval < 0);
1382 vam->retval = retval;
1383 vam->sw_if_index = ntohl (mp->sw_if_index);
1384 vam->result_ready = 1;
1389 static void vl_api_tap_connect_reply_t_handler_json
1390 (vl_api_tap_connect_reply_t * mp)
1392 vat_main_t *vam = &vat_main;
1393 vat_json_node_t node;
1395 vat_json_init_object (&node);
1396 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1397 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1399 vat_json_print (vam->ofp, &node);
1400 vat_json_free (&node);
1402 vam->retval = ntohl (mp->retval);
1403 vam->result_ready = 1;
1408 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1410 vat_main_t *vam = &vat_main;
1411 i32 retval = ntohl (mp->retval);
1412 if (vam->async_mode)
1414 vam->async_errors += (retval < 0);
1418 vam->retval = retval;
1419 vam->sw_if_index = ntohl (mp->sw_if_index);
1420 vam->result_ready = 1;
1424 static void vl_api_tap_modify_reply_t_handler_json
1425 (vl_api_tap_modify_reply_t * mp)
1427 vat_main_t *vam = &vat_main;
1428 vat_json_node_t node;
1430 vat_json_init_object (&node);
1431 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1432 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1434 vat_json_print (vam->ofp, &node);
1435 vat_json_free (&node);
1437 vam->retval = ntohl (mp->retval);
1438 vam->result_ready = 1;
1442 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1444 vat_main_t *vam = &vat_main;
1445 i32 retval = ntohl (mp->retval);
1446 if (vam->async_mode)
1448 vam->async_errors += (retval < 0);
1452 vam->retval = retval;
1453 vam->result_ready = 1;
1457 static void vl_api_tap_delete_reply_t_handler_json
1458 (vl_api_tap_delete_reply_t * mp)
1460 vat_main_t *vam = &vat_main;
1461 vat_json_node_t node;
1463 vat_json_init_object (&node);
1464 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1466 vat_json_print (vam->ofp, &node);
1467 vat_json_free (&node);
1469 vam->retval = ntohl (mp->retval);
1470 vam->result_ready = 1;
1473 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1474 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1476 vat_main_t *vam = &vat_main;
1477 i32 retval = ntohl (mp->retval);
1478 if (vam->async_mode)
1480 vam->async_errors += (retval < 0);
1484 vam->retval = retval;
1485 vam->result_ready = 1;
1489 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1490 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1492 vat_main_t *vam = &vat_main;
1493 vat_json_node_t node;
1495 vat_json_init_object (&node);
1496 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1497 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1498 ntohl (mp->tunnel_sw_if_index));
1500 vat_json_print (vam->ofp, &node);
1501 vat_json_free (&node);
1503 vam->retval = ntohl (mp->retval);
1504 vam->result_ready = 1;
1507 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1508 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1510 vat_main_t *vam = &vat_main;
1511 i32 retval = ntohl (mp->retval);
1512 if (vam->async_mode)
1514 vam->async_errors += (retval < 0);
1518 vam->retval = retval;
1519 vam->sw_if_index = ntohl (mp->sw_if_index);
1520 vam->result_ready = 1;
1524 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1525 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1527 vat_main_t *vam = &vat_main;
1528 vat_json_node_t node;
1530 vat_json_init_object (&node);
1531 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1532 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1534 vat_json_print (vam->ofp, &node);
1535 vat_json_free (&node);
1537 vam->retval = ntohl (mp->retval);
1538 vam->result_ready = 1;
1542 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1543 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1545 vat_main_t *vam = &vat_main;
1546 i32 retval = ntohl (mp->retval);
1547 if (vam->async_mode)
1549 vam->async_errors += (retval < 0);
1553 vam->retval = retval;
1554 vam->result_ready = 1;
1558 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1559 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1561 vat_main_t *vam = &vat_main;
1562 vat_json_node_t node;
1564 vat_json_init_object (&node);
1565 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1566 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1568 vat_json_print (vam->ofp, &node);
1569 vat_json_free (&node);
1571 vam->retval = ntohl (mp->retval);
1572 vam->result_ready = 1;
1575 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1576 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1578 vat_main_t *vam = &vat_main;
1579 i32 retval = ntohl (mp->retval);
1580 if (vam->async_mode)
1582 vam->async_errors += (retval < 0);
1586 vam->retval = retval;
1587 vam->sw_if_index = ntohl (mp->sw_if_index);
1588 vam->result_ready = 1;
1592 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1593 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1595 vat_main_t *vam = &vat_main;
1596 vat_json_node_t node;
1598 vat_json_init_object (&node);
1599 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1600 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1602 vat_json_print (vam->ofp, &node);
1603 vat_json_free (&node);
1605 vam->retval = ntohl (mp->retval);
1606 vam->result_ready = 1;
1609 static void vl_api_gre_add_del_tunnel_reply_t_handler
1610 (vl_api_gre_add_del_tunnel_reply_t * mp)
1612 vat_main_t *vam = &vat_main;
1613 i32 retval = ntohl (mp->retval);
1614 if (vam->async_mode)
1616 vam->async_errors += (retval < 0);
1620 vam->retval = retval;
1621 vam->sw_if_index = ntohl (mp->sw_if_index);
1622 vam->result_ready = 1;
1626 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1627 (vl_api_gre_add_del_tunnel_reply_t * mp)
1629 vat_main_t *vam = &vat_main;
1630 vat_json_node_t node;
1632 vat_json_init_object (&node);
1633 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1634 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1636 vat_json_print (vam->ofp, &node);
1637 vat_json_free (&node);
1639 vam->retval = ntohl (mp->retval);
1640 vam->result_ready = 1;
1643 static void vl_api_create_vhost_user_if_reply_t_handler
1644 (vl_api_create_vhost_user_if_reply_t * mp)
1646 vat_main_t *vam = &vat_main;
1647 i32 retval = ntohl (mp->retval);
1648 if (vam->async_mode)
1650 vam->async_errors += (retval < 0);
1654 vam->retval = retval;
1655 vam->sw_if_index = ntohl (mp->sw_if_index);
1656 vam->result_ready = 1;
1660 static void vl_api_create_vhost_user_if_reply_t_handler_json
1661 (vl_api_create_vhost_user_if_reply_t * mp)
1663 vat_main_t *vam = &vat_main;
1664 vat_json_node_t node;
1666 vat_json_init_object (&node);
1667 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1668 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1670 vat_json_print (vam->ofp, &node);
1671 vat_json_free (&node);
1673 vam->retval = ntohl (mp->retval);
1674 vam->result_ready = 1;
1677 static void vl_api_ip_address_details_t_handler
1678 (vl_api_ip_address_details_t * mp)
1680 vat_main_t *vam = &vat_main;
1681 static ip_address_details_t empty_ip_address_details = { {0} };
1682 ip_address_details_t *address = NULL;
1683 ip_details_t *current_ip_details = NULL;
1684 ip_details_t *details = NULL;
1686 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1688 if (!details || vam->current_sw_if_index >= vec_len (details)
1689 || !details[vam->current_sw_if_index].present)
1691 errmsg ("ip address details arrived but not stored\n");
1692 errmsg ("ip_dump should be called first\n");
1696 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1698 #define addresses (current_ip_details->addr)
1700 vec_validate_init_empty (addresses, vec_len (addresses),
1701 empty_ip_address_details);
1703 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1705 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1706 address->prefix_length = mp->prefix_length;
1710 static void vl_api_ip_address_details_t_handler_json
1711 (vl_api_ip_address_details_t * mp)
1713 vat_main_t *vam = &vat_main;
1714 vat_json_node_t *node = NULL;
1715 struct in6_addr ip6;
1718 if (VAT_JSON_ARRAY != vam->json_tree.type)
1720 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1721 vat_json_init_array (&vam->json_tree);
1723 node = vat_json_array_add (&vam->json_tree);
1725 vat_json_init_object (node);
1728 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1729 vat_json_object_add_ip6 (node, "ip", ip6);
1733 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1734 vat_json_object_add_ip4 (node, "ip", ip4);
1736 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1740 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1742 vat_main_t *vam = &vat_main;
1743 static ip_details_t empty_ip_details = { 0 };
1744 ip_details_t *ip = NULL;
1745 u32 sw_if_index = ~0;
1747 sw_if_index = ntohl (mp->sw_if_index);
1749 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1750 sw_if_index, empty_ip_details);
1752 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1759 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1761 vat_main_t *vam = &vat_main;
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);
1768 vat_json_array_add_uint (&vam->json_tree,
1769 clib_net_to_host_u32 (mp->sw_if_index));
1772 static void vl_api_map_domain_details_t_handler_json
1773 (vl_api_map_domain_details_t * mp)
1775 vat_json_node_t *node = NULL;
1776 vat_main_t *vam = &vat_main;
1777 struct in6_addr ip6;
1780 if (VAT_JSON_ARRAY != vam->json_tree.type)
1782 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1783 vat_json_init_array (&vam->json_tree);
1786 node = vat_json_array_add (&vam->json_tree);
1787 vat_json_init_object (node);
1789 vat_json_object_add_uint (node, "domain_index",
1790 clib_net_to_host_u32 (mp->domain_index));
1791 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1792 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1793 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1794 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1795 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1796 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1797 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1798 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1799 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1800 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1801 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1802 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1803 vat_json_object_add_uint (node, "flags", mp->flags);
1804 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1805 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1808 static void vl_api_map_domain_details_t_handler
1809 (vl_api_map_domain_details_t * mp)
1811 vat_main_t *vam = &vat_main;
1813 if (mp->is_translation)
1816 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1817 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1818 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1819 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1820 clib_net_to_host_u32 (mp->domain_index));
1825 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1826 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1827 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1828 format_ip6_address, mp->ip6_src,
1829 clib_net_to_host_u32 (mp->domain_index));
1831 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1832 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1833 mp->is_translation ? "map-t" : "");
1836 static void vl_api_map_rule_details_t_handler_json
1837 (vl_api_map_rule_details_t * mp)
1839 struct in6_addr ip6;
1840 vat_json_node_t *node = NULL;
1841 vat_main_t *vam = &vat_main;
1843 if (VAT_JSON_ARRAY != vam->json_tree.type)
1845 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1846 vat_json_init_array (&vam->json_tree);
1849 node = vat_json_array_add (&vam->json_tree);
1850 vat_json_init_object (node);
1852 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1853 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1854 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1858 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1860 vat_main_t *vam = &vat_main;
1861 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1862 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1866 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1868 vat_main_t *vam = &vat_main;
1869 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1870 "router_addr %U host_mac %U\n",
1871 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1872 format_ip4_address, &mp->host_address,
1873 format_ip4_address, &mp->router_address,
1874 format_ethernet_address, mp->host_mac);
1877 static void vl_api_dhcp_compl_event_t_handler_json
1878 (vl_api_dhcp_compl_event_t * mp)
1880 /* JSON output not supported */
1884 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1887 vat_main_t *vam = &vat_main;
1888 static u64 default_counter = 0;
1890 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1892 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1893 sw_if_index, default_counter);
1894 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1898 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1899 interface_counter_t counter)
1901 vat_main_t *vam = &vat_main;
1902 static interface_counter_t default_counter = { 0, };
1904 vec_validate_init_empty (vam->combined_interface_counters,
1905 vnet_counter_type, NULL);
1906 vec_validate_init_empty (vam->combined_interface_counters
1907 [vnet_counter_type], sw_if_index, default_counter);
1908 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1911 static void vl_api_vnet_interface_counters_t_handler
1912 (vl_api_vnet_interface_counters_t * mp)
1917 static void vl_api_vnet_interface_counters_t_handler_json
1918 (vl_api_vnet_interface_counters_t * mp)
1920 interface_counter_t counter;
1925 u32 first_sw_if_index;
1928 count = ntohl (mp->count);
1929 first_sw_if_index = ntohl (mp->first_sw_if_index);
1931 if (!mp->is_combined)
1933 v_packets = (u64 *) & mp->data;
1934 for (i = 0; i < count; i++)
1937 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1938 set_simple_interface_counter (mp->vnet_counter_type,
1939 first_sw_if_index + i, packets);
1945 v = (vlib_counter_t *) & mp->data;
1946 for (i = 0; i < count; i++)
1949 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1951 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1952 set_combined_interface_counter (mp->vnet_counter_type,
1953 first_sw_if_index + i, counter);
1960 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1962 vat_main_t *vam = &vat_main;
1965 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1967 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1976 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1978 vat_main_t *vam = &vat_main;
1981 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1983 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
1991 static void vl_api_vnet_ip4_fib_counters_t_handler
1992 (vl_api_vnet_ip4_fib_counters_t * mp)
1997 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1998 (vl_api_vnet_ip4_fib_counters_t * mp)
2000 vat_main_t *vam = &vat_main;
2001 vl_api_ip4_fib_counter_t *v;
2002 ip4_fib_counter_t *counter;
2009 vrf_id = ntohl (mp->vrf_id);
2010 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2011 if (~0 == vrf_index)
2013 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2014 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2015 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2016 vec_validate (vam->ip4_fib_counters, vrf_index);
2017 vam->ip4_fib_counters[vrf_index] = NULL;
2020 vec_free (vam->ip4_fib_counters[vrf_index]);
2021 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2022 count = ntohl (mp->count);
2023 for (i = 0; i < count; i++)
2025 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2026 counter = &vam->ip4_fib_counters[vrf_index][i];
2027 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2028 counter->address = ip4;
2029 counter->address_length = v->address_length;
2030 counter->packets = clib_net_to_host_u64 (v->packets);
2031 counter->bytes = clib_net_to_host_u64 (v->bytes);
2036 static void vl_api_vnet_ip6_fib_counters_t_handler
2037 (vl_api_vnet_ip6_fib_counters_t * mp)
2042 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2043 (vl_api_vnet_ip6_fib_counters_t * mp)
2045 vat_main_t *vam = &vat_main;
2046 vl_api_ip6_fib_counter_t *v;
2047 ip6_fib_counter_t *counter;
2048 struct in6_addr ip6;
2054 vrf_id = ntohl (mp->vrf_id);
2055 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2056 if (~0 == vrf_index)
2058 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2059 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2060 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2061 vec_validate (vam->ip6_fib_counters, vrf_index);
2062 vam->ip6_fib_counters[vrf_index] = NULL;
2065 vec_free (vam->ip6_fib_counters[vrf_index]);
2066 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2067 count = ntohl (mp->count);
2068 for (i = 0; i < count; i++)
2070 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2071 counter = &vam->ip6_fib_counters[vrf_index][i];
2072 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2073 counter->address = ip6;
2074 counter->address_length = v->address_length;
2075 counter->packets = clib_net_to_host_u64 (v->packets);
2076 counter->bytes = clib_net_to_host_u64 (v->bytes);
2081 static void vl_api_get_first_msg_id_reply_t_handler
2082 (vl_api_get_first_msg_id_reply_t * mp)
2084 vat_main_t *vam = &vat_main;
2085 i32 retval = ntohl (mp->retval);
2087 if (vam->async_mode)
2089 vam->async_errors += (retval < 0);
2093 vam->retval = retval;
2094 vam->result_ready = 1;
2098 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2102 static void vl_api_get_first_msg_id_reply_t_handler_json
2103 (vl_api_get_first_msg_id_reply_t * mp)
2105 vat_main_t *vam = &vat_main;
2106 vat_json_node_t node;
2108 vat_json_init_object (&node);
2109 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2110 vat_json_object_add_uint (&node, "first_msg_id",
2111 (uint) ntohs (mp->first_msg_id));
2113 vat_json_print (vam->ofp, &node);
2114 vat_json_free (&node);
2116 vam->retval = ntohl (mp->retval);
2117 vam->result_ready = 1;
2120 static void vl_api_get_node_graph_reply_t_handler
2121 (vl_api_get_node_graph_reply_t * mp)
2123 vat_main_t *vam = &vat_main;
2124 api_main_t *am = &api_main;
2125 i32 retval = ntohl (mp->retval);
2126 u8 *pvt_copy, *reply;
2131 if (vam->async_mode)
2133 vam->async_errors += (retval < 0);
2137 vam->retval = retval;
2138 vam->result_ready = 1;
2141 /* "Should never happen..." */
2145 reply = (u8 *) (mp->reply_in_shmem);
2146 pvt_copy = vec_dup (reply);
2148 /* Toss the shared-memory original... */
2149 pthread_mutex_lock (&am->vlib_rp->mutex);
2150 oldheap = svm_push_data_heap (am->vlib_rp);
2154 svm_pop_heap (oldheap);
2155 pthread_mutex_unlock (&am->vlib_rp->mutex);
2157 if (vam->graph_nodes)
2159 hash_free (vam->graph_node_index_by_name);
2161 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2163 node = vam->graph_nodes[i];
2164 vec_free (node->name);
2165 vec_free (node->next_nodes);
2168 vec_free (vam->graph_nodes);
2171 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2172 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2173 vec_free (pvt_copy);
2175 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2177 node = vam->graph_nodes[i];
2178 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2182 static void vl_api_get_node_graph_reply_t_handler_json
2183 (vl_api_get_node_graph_reply_t * mp)
2185 vat_main_t *vam = &vat_main;
2186 api_main_t *am = &api_main;
2188 vat_json_node_t node;
2191 /* $$$$ make this real? */
2192 vat_json_init_object (&node);
2193 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2194 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2196 reply = (u8 *) (mp->reply_in_shmem);
2198 /* Toss the shared-memory original... */
2199 pthread_mutex_lock (&am->vlib_rp->mutex);
2200 oldheap = svm_push_data_heap (am->vlib_rp);
2204 svm_pop_heap (oldheap);
2205 pthread_mutex_unlock (&am->vlib_rp->mutex);
2207 vat_json_print (vam->ofp, &node);
2208 vat_json_free (&node);
2210 vam->retval = ntohl (mp->retval);
2211 vam->result_ready = 1;
2215 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2217 vat_main_t *vam = &vat_main;
2222 s = format (s, "%=16d%=16d%=16d\n",
2223 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2227 s = format (s, "%=16U%=16d%=16d\n",
2228 mp->is_ipv6 ? format_ip6_address :
2230 mp->ip_address, mp->priority, mp->weight);
2233 fformat (vam->ofp, "%v", s);
2238 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2241 vat_main_t *vam = &vat_main;
2242 vat_json_node_t *node = NULL;
2243 struct in6_addr ip6;
2246 if (VAT_JSON_ARRAY != vam->json_tree.type)
2248 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2249 vat_json_init_array (&vam->json_tree);
2251 node = vat_json_array_add (&vam->json_tree);
2252 vat_json_init_object (node);
2254 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2255 vat_json_object_add_uint (node, "priority", mp->priority);
2256 vat_json_object_add_uint (node, "weight", mp->weight);
2259 vat_json_object_add_uint (node, "sw_if_index",
2260 clib_net_to_host_u32 (mp->sw_if_index));
2265 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2266 vat_json_object_add_ip6 (node, "address", ip6);
2270 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2271 vat_json_object_add_ip4 (node, "address", ip4);
2277 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2280 vat_main_t *vam = &vat_main;
2283 ls_name = format (0, "%s", mp->ls_name);
2285 fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
2291 vl_api_lisp_locator_set_details_t_handler_json
2292 (vl_api_lisp_locator_set_details_t * mp)
2294 vat_main_t *vam = &vat_main;
2295 vat_json_node_t *node = 0;
2298 ls_name = format (0, "%s", mp->ls_name);
2299 vec_add1 (ls_name, 0);
2301 if (VAT_JSON_ARRAY != vam->json_tree.type)
2303 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2304 vat_json_init_array (&vam->json_tree);
2306 node = vat_json_array_add (&vam->json_tree);
2308 vat_json_init_object (node);
2309 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2310 vat_json_object_add_uint (node, "ls_index",
2311 clib_net_to_host_u32 (mp->ls_index));
2316 format_lisp_flat_eid (u8 * s, va_list * args)
2318 u32 type = va_arg (*args, u32);
2319 u8 *eid = va_arg (*args, u8 *);
2320 u32 eid_len = va_arg (*args, u32);
2325 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2327 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2329 return format (s, "%U", format_ethernet_address, eid);
2335 format_lisp_eid_vat (u8 * s, va_list * args)
2337 u32 type = va_arg (*args, u32);
2338 u8 *eid = va_arg (*args, u8 *);
2339 u32 eid_len = va_arg (*args, u32);
2340 u8 *seid = va_arg (*args, u8 *);
2341 u32 seid_len = va_arg (*args, u32);
2342 u32 is_src_dst = va_arg (*args, u32);
2345 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2347 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2353 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2355 vat_main_t *vam = &vat_main;
2356 u8 *s = 0, *eid = 0;
2358 if (~0 == mp->locator_set_index)
2359 s = format (0, "action: %d", mp->action);
2361 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2363 eid = format (0, "%U", format_lisp_eid_vat,
2367 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2370 fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n",
2371 clib_net_to_host_u32 (mp->vni),
2373 mp->is_local ? "local" : "remote",
2374 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative);
2380 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2383 vat_main_t *vam = &vat_main;
2384 vat_json_node_t *node = 0;
2387 if (VAT_JSON_ARRAY != vam->json_tree.type)
2389 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2390 vat_json_init_array (&vam->json_tree);
2392 node = vat_json_array_add (&vam->json_tree);
2394 vat_json_init_object (node);
2395 if (~0 == mp->locator_set_index)
2396 vat_json_object_add_uint (node, "action", mp->action);
2398 vat_json_object_add_uint (node, "locator_set_index",
2399 clib_net_to_host_u32 (mp->locator_set_index));
2401 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2402 eid = format (0, "%U", format_lisp_eid_vat,
2406 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2408 vat_json_object_add_string_copy (node, "eid", eid);
2409 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2410 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2411 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2416 vl_api_lisp_eid_table_map_details_t_handler
2417 (vl_api_lisp_eid_table_map_details_t * mp)
2419 vat_main_t *vam = &vat_main;
2421 u8 *line = format (0, "%=10d%=10d",
2422 clib_net_to_host_u32 (mp->vni),
2423 clib_net_to_host_u32 (mp->dp_table));
2424 fformat (vam->ofp, "%v\n", line);
2429 vl_api_lisp_eid_table_map_details_t_handler_json
2430 (vl_api_lisp_eid_table_map_details_t * mp)
2432 vat_main_t *vam = &vat_main;
2433 vat_json_node_t *node = NULL;
2435 if (VAT_JSON_ARRAY != vam->json_tree.type)
2437 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2438 vat_json_init_array (&vam->json_tree);
2440 node = vat_json_array_add (&vam->json_tree);
2441 vat_json_init_object (node);
2442 vat_json_object_add_uint (node, "dp_table",
2443 clib_net_to_host_u32 (mp->dp_table));
2444 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2448 vl_api_lisp_eid_table_vni_details_t_handler
2449 (vl_api_lisp_eid_table_vni_details_t * mp)
2451 vat_main_t *vam = &vat_main;
2453 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2454 fformat (vam->ofp, "%v\n", line);
2459 vl_api_lisp_eid_table_vni_details_t_handler_json
2460 (vl_api_lisp_eid_table_vni_details_t * mp)
2462 vat_main_t *vam = &vat_main;
2463 vat_json_node_t *node = NULL;
2465 if (VAT_JSON_ARRAY != vam->json_tree.type)
2467 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2468 vat_json_init_array (&vam->json_tree);
2470 node = vat_json_array_add (&vam->json_tree);
2471 vat_json_init_object (node);
2472 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2476 format_decap_next (u8 * s, va_list * args)
2478 u32 next_index = va_arg (*args, u32);
2482 case LISP_GPE_INPUT_NEXT_DROP:
2483 return format (s, "drop");
2484 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2485 return format (s, "ip4");
2486 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2487 return format (s, "ip6");
2489 return format (s, "unknown %d", next_index);
2495 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2498 vat_main_t *vam = &vat_main;
2500 u8 *flag_str = NULL;
2502 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2504 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2505 foreach_lisp_gpe_flag_bit;
2508 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2509 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2511 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2513 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2515 ntohl (mp->encap_fib_id),
2516 ntohl (mp->decap_fib_id),
2517 format_decap_next, ntohl (mp->dcap_next),
2519 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2525 vl_api_lisp_gpe_tunnel_details_t_handler_json
2526 (vl_api_lisp_gpe_tunnel_details_t * mp)
2528 vat_main_t *vam = &vat_main;
2529 vat_json_node_t *node = NULL;
2530 struct in6_addr ip6;
2534 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2536 if (VAT_JSON_ARRAY != vam->json_tree.type)
2538 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2539 vat_json_init_array (&vam->json_tree);
2541 node = vat_json_array_add (&vam->json_tree);
2543 vat_json_init_object (node);
2544 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2547 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2548 vat_json_object_add_ip6 (node, "source address", ip6);
2549 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2550 vat_json_object_add_ip6 (node, "destination address", ip6);
2554 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2555 vat_json_object_add_ip4 (node, "source address", ip4);
2556 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2557 vat_json_object_add_ip4 (node, "destination address", ip4);
2559 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2560 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2561 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2562 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2563 vat_json_object_add_uint (node, "flags", mp->flags);
2564 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2565 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2566 vat_json_object_add_uint (node, "res", mp->res);
2567 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2569 vec_free (next_decap_str);
2573 vl_api_lisp_adjacencies_get_reply_t_handler
2574 (vl_api_lisp_adjacencies_get_reply_t * mp)
2576 vat_main_t *vam = &vat_main;
2578 int retval = clib_net_to_host_u32 (mp->retval);
2579 vl_api_lisp_adjacency_t *a;
2584 n = clib_net_to_host_u32 (mp->count);
2586 for (i = 0; i < n; i++)
2588 a = &mp->adjacencies[i];
2589 fformat (vam->ofp, "%U %40U\n",
2590 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2591 format_lisp_flat_eid, a->eid_type, a->reid,
2592 a->reid_prefix_len);
2596 vam->retval = retval;
2597 vam->result_ready = 1;
2601 vl_api_lisp_adjacencies_get_reply_t_handler_json
2602 (vl_api_lisp_adjacencies_get_reply_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 vat_json_node_t *e = 0, root;
2608 int retval = clib_net_to_host_u32 (mp->retval);
2609 vl_api_lisp_adjacency_t *a;
2614 n = clib_net_to_host_u32 (mp->count);
2615 vat_json_init_array (&root);
2617 for (i = 0; i < n; i++)
2619 e = vat_json_array_add (&root);
2620 a = &mp->adjacencies[i];
2622 vat_json_init_object (e);
2623 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2624 a->leid_prefix_len);
2626 vat_json_object_add_string_copy (e, "leid", s);
2629 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2630 a->reid_prefix_len);
2632 vat_json_object_add_string_copy (e, "reid", s);
2636 vat_json_print (vam->ofp, &root);
2637 vat_json_free (&root);
2640 vam->retval = retval;
2641 vam->result_ready = 1;
2645 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2648 vat_main_t *vam = &vat_main;
2650 fformat (vam->ofp, "%=20U\n",
2651 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2656 vl_api_lisp_map_resolver_details_t_handler_json
2657 (vl_api_lisp_map_resolver_details_t * mp)
2659 vat_main_t *vam = &vat_main;
2660 vat_json_node_t *node = NULL;
2661 struct in6_addr ip6;
2664 if (VAT_JSON_ARRAY != vam->json_tree.type)
2666 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2667 vat_json_init_array (&vam->json_tree);
2669 node = vat_json_array_add (&vam->json_tree);
2671 vat_json_init_object (node);
2674 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2675 vat_json_object_add_ip6 (node, "map resolver", ip6);
2679 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2680 vat_json_object_add_ip4 (node, "map resolver", ip4);
2685 vl_api_show_lisp_status_reply_t_handler
2686 (vl_api_show_lisp_status_reply_t * mp)
2688 vat_main_t *vam = &vat_main;
2689 i32 retval = ntohl (mp->retval);
2693 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2694 mp->feature_status ? "enabled" : "disabled",
2695 mp->gpe_status ? "enabled" : "disabled");
2698 vam->retval = retval;
2699 vam->result_ready = 1;
2703 vl_api_show_lisp_status_reply_t_handler_json
2704 (vl_api_show_lisp_status_reply_t * mp)
2706 vat_main_t *vam = &vat_main;
2707 vat_json_node_t node;
2708 u8 *gpe_status = NULL;
2709 u8 *feature_status = NULL;
2711 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2712 feature_status = format (0, "%s",
2713 mp->feature_status ? "enabled" : "disabled");
2714 vec_add1 (gpe_status, 0);
2715 vec_add1 (feature_status, 0);
2717 vat_json_init_object (&node);
2718 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2719 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2721 vec_free (gpe_status);
2722 vec_free (feature_status);
2724 vat_json_print (vam->ofp, &node);
2725 vat_json_free (&node);
2727 vam->retval = ntohl (mp->retval);
2728 vam->result_ready = 1;
2732 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2733 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2735 vat_main_t *vam = &vat_main;
2736 i32 retval = ntohl (mp->retval);
2740 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2743 vam->retval = retval;
2744 vam->result_ready = 1;
2748 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2749 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2751 vat_main_t *vam = &vat_main;
2752 vat_json_node_t *node = NULL;
2754 if (VAT_JSON_ARRAY != vam->json_tree.type)
2756 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2757 vat_json_init_array (&vam->json_tree);
2759 node = vat_json_array_add (&vam->json_tree);
2761 vat_json_init_object (node);
2762 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2764 vat_json_print (vam->ofp, node);
2765 vat_json_free (node);
2767 vam->retval = ntohl (mp->retval);
2768 vam->result_ready = 1;
2772 format_lisp_map_request_mode (u8 * s, va_list * args)
2774 u32 mode = va_arg (*args, u32);
2779 return format (0, "dst-only");
2781 return format (0, "src-dst");
2787 vl_api_show_lisp_map_request_mode_reply_t_handler
2788 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2790 vat_main_t *vam = &vat_main;
2791 i32 retval = ntohl (mp->retval);
2795 u32 mode = mp->mode;
2796 fformat (vam->ofp, "map_request_mode: %U\n",
2797 format_lisp_map_request_mode, mode);
2800 vam->retval = retval;
2801 vam->result_ready = 1;
2805 vl_api_show_lisp_map_request_mode_reply_t_handler_json
2806 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2808 vat_main_t *vam = &vat_main;
2809 vat_json_node_t node;
2814 s = format (0, "%U", format_lisp_map_request_mode, mode);
2817 vat_json_init_object (&node);
2818 vat_json_object_add_string_copy (&node, "map_request_mode", s);
2819 vat_json_print (vam->ofp, &node);
2820 vat_json_free (&node);
2823 vam->retval = ntohl (mp->retval);
2824 vam->result_ready = 1;
2828 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2830 vat_main_t *vam = &vat_main;
2831 i32 retval = ntohl (mp->retval);
2835 fformat (vam->ofp, "%-20s%-16s\n",
2836 mp->status ? "enabled" : "disabled",
2837 mp->status ? (char *) mp->locator_set_name : "");
2840 vam->retval = retval;
2841 vam->result_ready = 1;
2845 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2848 vat_main_t *vam = &vat_main;
2849 vat_json_node_t node;
2852 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2853 vec_add1 (status, 0);
2855 vat_json_init_object (&node);
2856 vat_json_object_add_string_copy (&node, "status", status);
2859 vat_json_object_add_string_copy (&node, "locator_set",
2860 mp->locator_set_name);
2865 vat_json_print (vam->ofp, &node);
2866 vat_json_free (&node);
2868 vam->retval = ntohl (mp->retval);
2869 vam->result_ready = 1;
2873 format_policer_type (u8 * s, va_list * va)
2875 u32 i = va_arg (*va, u32);
2877 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2878 s = format (s, "1r2c");
2879 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2880 s = format (s, "1r3c");
2881 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2882 s = format (s, "2r3c-2698");
2883 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2884 s = format (s, "2r3c-4115");
2885 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2886 s = format (s, "2r3c-mef5cf1");
2888 s = format (s, "ILLEGAL");
2893 format_policer_rate_type (u8 * s, va_list * va)
2895 u32 i = va_arg (*va, u32);
2897 if (i == SSE2_QOS_RATE_KBPS)
2898 s = format (s, "kbps");
2899 else if (i == SSE2_QOS_RATE_PPS)
2900 s = format (s, "pps");
2902 s = format (s, "ILLEGAL");
2907 format_policer_round_type (u8 * s, va_list * va)
2909 u32 i = va_arg (*va, u32);
2911 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2912 s = format (s, "closest");
2913 else if (i == SSE2_QOS_ROUND_TO_UP)
2914 s = format (s, "up");
2915 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2916 s = format (s, "down");
2918 s = format (s, "ILLEGAL");
2923 format_policer_action_type (u8 * s, va_list * va)
2925 u32 i = va_arg (*va, u32);
2927 if (i == SSE2_QOS_ACTION_DROP)
2928 s = format (s, "drop");
2929 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2930 s = format (s, "transmit");
2931 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2932 s = format (s, "mark-and-transmit");
2934 s = format (s, "ILLEGAL");
2939 format_dscp (u8 * s, va_list * va)
2941 u32 i = va_arg (*va, u32);
2946 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2950 return format (s, "ILLEGAL");
2952 s = format (s, "%s", t);
2957 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2959 vat_main_t *vam = &vat_main;
2960 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2962 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2963 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2965 conform_dscp_str = format (0, "");
2967 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2968 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2970 exceed_dscp_str = format (0, "");
2972 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2973 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2975 violate_dscp_str = format (0, "");
2977 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2978 "rate type %U, round type %U, %s rate, %s color-aware, "
2979 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2980 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2981 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2983 format_policer_type, mp->type,
2986 clib_net_to_host_u64 (mp->cb),
2987 clib_net_to_host_u64 (mp->eb),
2988 format_policer_rate_type, mp->rate_type,
2989 format_policer_round_type, mp->round_type,
2990 mp->single_rate ? "single" : "dual",
2991 mp->color_aware ? "is" : "not",
2992 ntohl (mp->cir_tokens_per_period),
2993 ntohl (mp->pir_tokens_per_period),
2995 ntohl (mp->current_limit),
2996 ntohl (mp->current_bucket),
2997 ntohl (mp->extended_limit),
2998 ntohl (mp->extended_bucket),
2999 clib_net_to_host_u64 (mp->last_update_time),
3000 format_policer_action_type, mp->conform_action_type,
3002 format_policer_action_type, mp->exceed_action_type,
3004 format_policer_action_type, mp->violate_action_type,
3007 vec_free (conform_dscp_str);
3008 vec_free (exceed_dscp_str);
3009 vec_free (violate_dscp_str);
3012 static void vl_api_policer_details_t_handler_json
3013 (vl_api_policer_details_t * mp)
3015 vat_main_t *vam = &vat_main;
3016 vat_json_node_t *node;
3017 u8 *rate_type_str, *round_type_str, *type_str;
3018 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3020 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3022 format (0, "%U", format_policer_round_type, mp->round_type);
3023 type_str = format (0, "%U", format_policer_type, mp->type);
3024 conform_action_str = format (0, "%U", format_policer_action_type,
3025 mp->conform_action_type);
3026 exceed_action_str = format (0, "%U", format_policer_action_type,
3027 mp->exceed_action_type);
3028 violate_action_str = format (0, "%U", format_policer_action_type,
3029 mp->violate_action_type);
3031 if (VAT_JSON_ARRAY != vam->json_tree.type)
3033 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3034 vat_json_init_array (&vam->json_tree);
3036 node = vat_json_array_add (&vam->json_tree);
3038 vat_json_init_object (node);
3039 vat_json_object_add_string_copy (node, "name", mp->name);
3040 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3041 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3042 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3043 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3044 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3045 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3046 vat_json_object_add_string_copy (node, "type", type_str);
3047 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3048 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3049 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3050 vat_json_object_add_uint (node, "cir_tokens_per_period",
3051 ntohl (mp->cir_tokens_per_period));
3052 vat_json_object_add_uint (node, "eir_tokens_per_period",
3053 ntohl (mp->pir_tokens_per_period));
3054 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3055 vat_json_object_add_uint (node, "current_bucket",
3056 ntohl (mp->current_bucket));
3057 vat_json_object_add_uint (node, "extended_limit",
3058 ntohl (mp->extended_limit));
3059 vat_json_object_add_uint (node, "extended_bucket",
3060 ntohl (mp->extended_bucket));
3061 vat_json_object_add_uint (node, "last_update_time",
3062 ntohl (mp->last_update_time));
3063 vat_json_object_add_string_copy (node, "conform_action",
3064 conform_action_str);
3065 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3067 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3068 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3069 vec_free (dscp_str);
3071 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3072 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3074 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3075 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3076 vec_free (dscp_str);
3078 vat_json_object_add_string_copy (node, "violate_action",
3079 violate_action_str);
3080 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3082 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3083 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3084 vec_free (dscp_str);
3087 vec_free (rate_type_str);
3088 vec_free (round_type_str);
3089 vec_free (type_str);
3090 vec_free (conform_action_str);
3091 vec_free (exceed_action_str);
3092 vec_free (violate_action_str);
3096 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3099 vat_main_t *vam = &vat_main;
3100 int i, count = ntohl (mp->count);
3103 fformat (vam->ofp, "classify table ids (%d) : ", count);
3104 for (i = 0; i < count; i++)
3106 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3107 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3109 vam->retval = ntohl (mp->retval);
3110 vam->result_ready = 1;
3114 vl_api_classify_table_ids_reply_t_handler_json
3115 (vl_api_classify_table_ids_reply_t * mp)
3117 vat_main_t *vam = &vat_main;
3118 int i, count = ntohl (mp->count);
3122 vat_json_node_t node;
3124 vat_json_init_object (&node);
3125 for (i = 0; i < count; i++)
3127 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3129 vat_json_print (vam->ofp, &node);
3130 vat_json_free (&node);
3132 vam->retval = ntohl (mp->retval);
3133 vam->result_ready = 1;
3137 vl_api_classify_table_by_interface_reply_t_handler
3138 (vl_api_classify_table_by_interface_reply_t * mp)
3140 vat_main_t *vam = &vat_main;
3143 table_id = ntohl (mp->l2_table_id);
3145 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3147 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3148 table_id = ntohl (mp->ip4_table_id);
3150 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3152 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3153 table_id = ntohl (mp->ip6_table_id);
3155 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3157 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3158 vam->retval = ntohl (mp->retval);
3159 vam->result_ready = 1;
3163 vl_api_classify_table_by_interface_reply_t_handler_json
3164 (vl_api_classify_table_by_interface_reply_t * mp)
3166 vat_main_t *vam = &vat_main;
3167 vat_json_node_t node;
3169 vat_json_init_object (&node);
3171 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3172 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3173 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3175 vat_json_print (vam->ofp, &node);
3176 vat_json_free (&node);
3178 vam->retval = ntohl (mp->retval);
3179 vam->result_ready = 1;
3182 static void vl_api_policer_add_del_reply_t_handler
3183 (vl_api_policer_add_del_reply_t * mp)
3185 vat_main_t *vam = &vat_main;
3186 i32 retval = ntohl (mp->retval);
3187 if (vam->async_mode)
3189 vam->async_errors += (retval < 0);
3193 vam->retval = retval;
3194 vam->result_ready = 1;
3195 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3197 * Note: this is just barely thread-safe, depends on
3198 * the main thread spinning waiting for an answer...
3200 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3204 static void vl_api_policer_add_del_reply_t_handler_json
3205 (vl_api_policer_add_del_reply_t * mp)
3207 vat_main_t *vam = &vat_main;
3208 vat_json_node_t node;
3210 vat_json_init_object (&node);
3211 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3212 vat_json_object_add_uint (&node, "policer_index",
3213 ntohl (mp->policer_index));
3215 vat_json_print (vam->ofp, &node);
3216 vat_json_free (&node);
3218 vam->retval = ntohl (mp->retval);
3219 vam->result_ready = 1;
3222 /* Format hex dump. */
3224 format_hex_bytes (u8 * s, va_list * va)
3226 u8 *bytes = va_arg (*va, u8 *);
3227 int n_bytes = va_arg (*va, int);
3230 /* Print short or long form depending on byte count. */
3231 uword short_form = n_bytes <= 32;
3232 uword indent = format_get_indent (s);
3237 for (i = 0; i < n_bytes; i++)
3239 if (!short_form && (i % 32) == 0)
3240 s = format (s, "%08x: ", i);
3241 s = format (s, "%02x", bytes[i]);
3242 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3243 s = format (s, "\n%U", format_white_space, indent);
3250 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3253 vat_main_t *vam = &vat_main;
3254 i32 retval = ntohl (mp->retval);
3257 fformat (vam->ofp, "classify table info :\n");
3258 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3259 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3260 ntohl (mp->miss_next_index));
3261 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3262 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3263 ntohl (mp->match_n_vectors));
3264 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3265 ntohl (mp->mask_length));
3267 vam->retval = retval;
3268 vam->result_ready = 1;
3272 vl_api_classify_table_info_reply_t_handler_json
3273 (vl_api_classify_table_info_reply_t * mp)
3275 vat_main_t *vam = &vat_main;
3276 vat_json_node_t node;
3278 i32 retval = ntohl (mp->retval);
3281 vat_json_init_object (&node);
3283 vat_json_object_add_int (&node, "sessions",
3284 ntohl (mp->active_sessions));
3285 vat_json_object_add_int (&node, "nexttbl",
3286 ntohl (mp->next_table_index));
3287 vat_json_object_add_int (&node, "nextnode",
3288 ntohl (mp->miss_next_index));
3289 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3290 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3291 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3292 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3293 ntohl (mp->mask_length), 0);
3294 vat_json_object_add_string_copy (&node, "mask", s);
3296 vat_json_print (vam->ofp, &node);
3297 vat_json_free (&node);
3299 vam->retval = ntohl (mp->retval);
3300 vam->result_ready = 1;
3304 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3307 vat_main_t *vam = &vat_main;
3309 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3310 ntohl (mp->hit_next_index), ntohl (mp->advance),
3311 ntohl (mp->opaque_index));
3312 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3313 ntohl (mp->match_length));
3317 vl_api_classify_session_details_t_handler_json
3318 (vl_api_classify_session_details_t * mp)
3320 vat_main_t *vam = &vat_main;
3321 vat_json_node_t *node = NULL;
3323 if (VAT_JSON_ARRAY != vam->json_tree.type)
3325 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3326 vat_json_init_array (&vam->json_tree);
3328 node = vat_json_array_add (&vam->json_tree);
3330 vat_json_init_object (node);
3331 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3332 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3333 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3335 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3337 vat_json_object_add_string_copy (node, "match", s);
3340 static void vl_api_pg_create_interface_reply_t_handler
3341 (vl_api_pg_create_interface_reply_t * mp)
3343 vat_main_t *vam = &vat_main;
3345 vam->retval = ntohl (mp->retval);
3346 vam->result_ready = 1;
3349 static void vl_api_pg_create_interface_reply_t_handler_json
3350 (vl_api_pg_create_interface_reply_t * mp)
3352 vat_main_t *vam = &vat_main;
3353 vat_json_node_t node;
3355 i32 retval = ntohl (mp->retval);
3358 vat_json_init_object (&node);
3360 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3362 vat_json_print (vam->ofp, &node);
3363 vat_json_free (&node);
3365 vam->retval = ntohl (mp->retval);
3366 vam->result_ready = 1;
3369 static void vl_api_policer_classify_details_t_handler
3370 (vl_api_policer_classify_details_t * mp)
3372 vat_main_t *vam = &vat_main;
3374 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3375 ntohl (mp->table_index));
3378 static void vl_api_policer_classify_details_t_handler_json
3379 (vl_api_policer_classify_details_t * mp)
3381 vat_main_t *vam = &vat_main;
3382 vat_json_node_t *node;
3384 if (VAT_JSON_ARRAY != vam->json_tree.type)
3386 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3387 vat_json_init_array (&vam->json_tree);
3389 node = vat_json_array_add (&vam->json_tree);
3391 vat_json_init_object (node);
3392 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3393 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3396 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3397 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3399 vat_main_t *vam = &vat_main;
3400 i32 retval = ntohl (mp->retval);
3401 if (vam->async_mode)
3403 vam->async_errors += (retval < 0);
3407 vam->retval = retval;
3408 vam->sw_if_index = ntohl (mp->sw_if_index);
3409 vam->result_ready = 1;
3413 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3414 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3416 vat_main_t *vam = &vat_main;
3417 vat_json_node_t node;
3419 vat_json_init_object (&node);
3420 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3421 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3423 vat_json_print (vam->ofp, &node);
3424 vat_json_free (&node);
3426 vam->retval = ntohl (mp->retval);
3427 vam->result_ready = 1;
3430 static void vl_api_flow_classify_details_t_handler
3431 (vl_api_flow_classify_details_t * mp)
3433 vat_main_t *vam = &vat_main;
3435 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3436 ntohl (mp->table_index));
3439 static void vl_api_flow_classify_details_t_handler_json
3440 (vl_api_flow_classify_details_t * mp)
3442 vat_main_t *vam = &vat_main;
3443 vat_json_node_t *node;
3445 if (VAT_JSON_ARRAY != vam->json_tree.type)
3447 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3448 vat_json_init_array (&vam->json_tree);
3450 node = vat_json_array_add (&vam->json_tree);
3452 vat_json_init_object (node);
3453 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3454 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3459 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3460 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3461 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3462 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3463 #define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
3464 #define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
3467 * Generate boilerplate reply handlers, which
3468 * dig the return value out of the xxx_reply_t API message,
3469 * stick it into vam->retval, and set vam->result_ready
3471 * Could also do this by pointing N message decode slots at
3472 * a single function, but that could break in subtle ways.
3475 #define foreach_standard_reply_retval_handler \
3476 _(sw_interface_set_flags_reply) \
3477 _(sw_interface_add_del_address_reply) \
3478 _(sw_interface_set_table_reply) \
3479 _(sw_interface_set_mpls_enable_reply) \
3480 _(sw_interface_set_vpath_reply) \
3481 _(sw_interface_set_l2_bridge_reply) \
3482 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3483 _(sw_interface_set_dpdk_hqos_subport_reply) \
3484 _(sw_interface_set_dpdk_hqos_tctbl_reply) \
3485 _(bridge_domain_add_del_reply) \
3486 _(sw_interface_set_l2_xconnect_reply) \
3487 _(l2fib_add_del_reply) \
3488 _(ip_add_del_route_reply) \
3489 _(mpls_route_add_del_reply) \
3490 _(mpls_ip_bind_unbind_reply) \
3491 _(proxy_arp_add_del_reply) \
3492 _(proxy_arp_intfc_enable_disable_reply) \
3493 _(mpls_add_del_encap_reply) \
3494 _(mpls_ethernet_add_del_tunnel_2_reply) \
3495 _(sw_interface_set_unnumbered_reply) \
3496 _(ip_neighbor_add_del_reply) \
3497 _(reset_vrf_reply) \
3498 _(oam_add_del_reply) \
3499 _(reset_fib_reply) \
3500 _(dhcp_proxy_config_reply) \
3501 _(dhcp_proxy_config_2_reply) \
3502 _(dhcp_proxy_set_vss_reply) \
3503 _(dhcp_client_config_reply) \
3504 _(set_ip_flow_hash_reply) \
3505 _(sw_interface_ip6_enable_disable_reply) \
3506 _(sw_interface_ip6_set_link_local_address_reply) \
3507 _(sw_interface_ip6nd_ra_prefix_reply) \
3508 _(sw_interface_ip6nd_ra_config_reply) \
3509 _(set_arp_neighbor_limit_reply) \
3510 _(l2_patch_add_del_reply) \
3511 _(sr_tunnel_add_del_reply) \
3512 _(sr_policy_add_del_reply) \
3513 _(sr_multicast_map_add_del_reply) \
3514 _(classify_add_del_session_reply) \
3515 _(classify_set_interface_ip_table_reply) \
3516 _(classify_set_interface_l2_tables_reply) \
3517 _(l2tpv3_set_tunnel_cookies_reply) \
3518 _(l2tpv3_interface_enable_disable_reply) \
3519 _(l2tpv3_set_lookup_key_reply) \
3520 _(l2_fib_clear_table_reply) \
3521 _(l2_interface_efp_filter_reply) \
3522 _(l2_interface_vlan_tag_rewrite_reply) \
3523 _(modify_vhost_user_if_reply) \
3524 _(delete_vhost_user_if_reply) \
3525 _(want_ip4_arp_events_reply) \
3526 _(want_ip6_nd_events_reply) \
3527 _(input_acl_set_interface_reply) \
3528 _(ipsec_spd_add_del_reply) \
3529 _(ipsec_interface_add_del_spd_reply) \
3530 _(ipsec_spd_add_del_entry_reply) \
3531 _(ipsec_sad_add_del_entry_reply) \
3532 _(ipsec_sa_set_key_reply) \
3533 _(ikev2_profile_add_del_reply) \
3534 _(ikev2_profile_set_auth_reply) \
3535 _(ikev2_profile_set_id_reply) \
3536 _(ikev2_profile_set_ts_reply) \
3537 _(ikev2_set_local_key_reply) \
3538 _(delete_loopback_reply) \
3539 _(bd_ip_mac_add_del_reply) \
3540 _(map_del_domain_reply) \
3541 _(map_add_del_rule_reply) \
3542 _(want_interface_events_reply) \
3543 _(want_stats_reply) \
3544 _(cop_interface_enable_disable_reply) \
3545 _(cop_whitelist_enable_disable_reply) \
3546 _(sw_interface_clear_stats_reply) \
3547 _(ioam_enable_reply) \
3548 _(ioam_disable_reply) \
3549 _(lisp_add_del_locator_reply) \
3550 _(lisp_add_del_local_eid_reply) \
3551 _(lisp_add_del_remote_mapping_reply) \
3552 _(lisp_add_del_adjacency_reply) \
3553 _(lisp_gpe_add_del_fwd_entry_reply) \
3554 _(lisp_add_del_map_resolver_reply) \
3555 _(lisp_gpe_enable_disable_reply) \
3556 _(lisp_gpe_add_del_iface_reply) \
3557 _(lisp_enable_disable_reply) \
3558 _(lisp_pitr_set_locator_set_reply) \
3559 _(lisp_map_request_mode_reply) \
3560 _(lisp_add_del_map_request_itr_rlocs_reply) \
3561 _(lisp_eid_table_add_del_map_reply) \
3562 _(vxlan_gpe_add_del_tunnel_reply) \
3563 _(af_packet_delete_reply) \
3564 _(policer_classify_set_interface_reply) \
3565 _(netmap_create_reply) \
3566 _(netmap_delete_reply) \
3567 _(set_ipfix_exporter_reply) \
3568 _(set_ipfix_classify_stream_reply) \
3569 _(ipfix_classify_table_add_del_reply) \
3570 _(flow_classify_set_interface_reply) \
3571 _(sw_interface_span_enable_disable_reply) \
3572 _(pg_capture_reply) \
3573 _(pg_enable_disable_reply) \
3574 _(ip_source_and_port_range_check_add_del_reply) \
3575 _(ip_source_and_port_range_check_interface_add_del_reply)\
3576 _(delete_subif_reply) \
3577 _(l2_interface_pbb_tag_rewrite_reply) \
3581 static void vl_api_##n##_t_handler \
3582 (vl_api_##n##_t * mp) \
3584 vat_main_t * vam = &vat_main; \
3585 i32 retval = ntohl(mp->retval); \
3586 if (vam->async_mode) { \
3587 vam->async_errors += (retval < 0); \
3589 vam->retval = retval; \
3590 vam->result_ready = 1; \
3593 foreach_standard_reply_retval_handler;
3597 static void vl_api_##n##_t_handler_json \
3598 (vl_api_##n##_t * mp) \
3600 vat_main_t * vam = &vat_main; \
3601 vat_json_node_t node; \
3602 vat_json_init_object(&node); \
3603 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3604 vat_json_print(vam->ofp, &node); \
3605 vam->retval = ntohl(mp->retval); \
3606 vam->result_ready = 1; \
3608 foreach_standard_reply_retval_handler;
3612 * Table of message reply handlers, must include boilerplate handlers
3616 #define foreach_vpe_api_reply_msg \
3617 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3618 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3619 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3620 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3621 _(CONTROL_PING_REPLY, control_ping_reply) \
3622 _(CLI_REPLY, cli_reply) \
3623 _(CLI_INBAND_REPLY, cli_inband_reply) \
3624 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3625 sw_interface_add_del_address_reply) \
3626 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3627 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3628 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3629 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3630 sw_interface_set_l2_xconnect_reply) \
3631 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3632 sw_interface_set_l2_bridge_reply) \
3633 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
3634 sw_interface_set_dpdk_hqos_pipe_reply) \
3635 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
3636 sw_interface_set_dpdk_hqos_subport_reply) \
3637 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
3638 sw_interface_set_dpdk_hqos_tctbl_reply) \
3639 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3640 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3641 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3642 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3643 _(L2_FLAGS_REPLY, l2_flags_reply) \
3644 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3645 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3646 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3647 _(TAP_DELETE_REPLY, tap_delete_reply) \
3648 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3649 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3650 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
3651 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
3652 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3653 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3654 proxy_arp_intfc_enable_disable_reply) \
3655 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3656 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3657 mpls_ethernet_add_del_tunnel_reply) \
3658 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3659 mpls_ethernet_add_del_tunnel_2_reply) \
3660 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3661 sw_interface_set_unnumbered_reply) \
3662 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3663 _(RESET_VRF_REPLY, reset_vrf_reply) \
3664 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3665 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3666 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3667 _(RESET_FIB_REPLY, reset_fib_reply) \
3668 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3669 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3670 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3671 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3672 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3673 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3674 sw_interface_ip6_enable_disable_reply) \
3675 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3676 sw_interface_ip6_set_link_local_address_reply) \
3677 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3678 sw_interface_ip6nd_ra_prefix_reply) \
3679 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3680 sw_interface_ip6nd_ra_config_reply) \
3681 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3682 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3683 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3684 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3685 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3686 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3687 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3688 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3689 classify_set_interface_ip_table_reply) \
3690 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3691 classify_set_interface_l2_tables_reply) \
3692 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3693 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3694 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3695 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3696 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3697 l2tpv3_interface_enable_disable_reply) \
3698 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3699 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3700 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3701 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3702 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3703 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3704 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3705 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3706 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3707 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3708 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3709 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3710 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3711 _(SHOW_VERSION_REPLY, show_version_reply) \
3712 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3713 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3714 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3715 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3716 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3717 _(IP4_ARP_EVENT, ip4_arp_event) \
3718 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3719 _(IP6_ND_EVENT, ip6_nd_event) \
3720 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3721 _(IP_ADDRESS_DETAILS, ip_address_details) \
3722 _(IP_DETAILS, ip_details) \
3723 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3724 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3725 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3726 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3727 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3728 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3729 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3730 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3731 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3732 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3733 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3734 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3735 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3736 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3737 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3738 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3739 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3740 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3741 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3742 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3743 _(MAP_RULE_DETAILS, map_rule_details) \
3744 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3745 _(WANT_STATS_REPLY, want_stats_reply) \
3746 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3747 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3748 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3749 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3750 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3751 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3752 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3753 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3754 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3755 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3756 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3757 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3758 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3759 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3760 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3761 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3762 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3763 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3764 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3765 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3766 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3767 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3768 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3769 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3770 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3771 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3772 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3773 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
3774 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3775 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3776 lisp_add_del_map_request_itr_rlocs_reply) \
3777 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3778 lisp_get_map_request_itr_rlocs_reply) \
3779 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3780 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3781 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3782 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3783 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3784 _(POLICER_DETAILS, policer_details) \
3785 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3786 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3787 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3788 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3789 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3790 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3791 _(MPLS_FIB_DETAILS, mpls_fib_details) \
3792 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3793 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3794 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3795 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3796 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3797 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3798 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3799 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3800 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3801 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3802 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
3803 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
3804 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
3805 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
3806 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3807 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3808 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3809 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3810 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3811 ip_source_and_port_range_check_add_del_reply) \
3812 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3813 ip_source_and_port_range_check_interface_add_del_reply) \
3814 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3815 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3816 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3817 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3818 _(PUNT_REPLY, punt_reply) \
3819 _(IP_FIB_DETAILS, ip_fib_details) \
3820 _(IP6_FIB_DETAILS, ip6_fib_details)
3822 /* M: construct, but don't yet send a message */
3826 vam->result_ready = 0; \
3827 mp = vl_msg_api_alloc(sizeof(*mp)); \
3828 memset (mp, 0, sizeof (*mp)); \
3829 mp->_vl_msg_id = ntohs (VL_API_##T); \
3830 mp->client_index = vam->my_client_index; \
3835 vam->result_ready = 0; \
3836 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3837 memset (mp, 0, sizeof (*mp)); \
3838 mp->_vl_msg_id = ntohs (VL_API_##T); \
3839 mp->client_index = vam->my_client_index; \
3843 /* S: send a message */
3844 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3846 /* W: wait for results, with timeout */
3849 timeout = vat_time_now (vam) + 1.0; \
3851 while (vat_time_now (vam) < timeout) { \
3852 if (vam->result_ready == 1) { \
3853 return (vam->retval); \
3859 /* W2: wait for results, with timeout */
3862 timeout = vat_time_now (vam) + 1.0; \
3864 while (vat_time_now (vam) < timeout) { \
3865 if (vam->result_ready == 1) { \
3867 return (vam->retval); \
3880 #define STR_VTR_OP_CASE(op) \
3881 case L2_VTR_ ## op: \
3885 str_vtr_op (u32 vtr_op)
3889 STR_VTR_OP_CASE (DISABLED);
3890 STR_VTR_OP_CASE (PUSH_1);
3891 STR_VTR_OP_CASE (PUSH_2);
3892 STR_VTR_OP_CASE (POP_1);
3893 STR_VTR_OP_CASE (POP_2);
3894 STR_VTR_OP_CASE (TRANSLATE_1_1);
3895 STR_VTR_OP_CASE (TRANSLATE_1_2);
3896 STR_VTR_OP_CASE (TRANSLATE_2_1);
3897 STR_VTR_OP_CASE (TRANSLATE_2_2);
3904 dump_sub_interface_table (vat_main_t * vam)
3906 const sw_interface_subif_t *sub = NULL;
3908 if (vam->json_output)
3911 ("JSON output supported only for VPE API calls and dump_stats_table");
3916 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3917 "Interface", "sw_if_index",
3918 "sub id", "dot1ad", "tags", "outer id",
3919 "inner id", "exact", "default", "outer any", "inner any");
3921 vec_foreach (sub, vam->sw_if_subif_table)
3924 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3925 sub->interface_name,
3927 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3928 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3929 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3930 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3931 if (sub->vtr_op != L2_VTR_DISABLED)
3934 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3935 "tag1: %d tag2: %d ]\n",
3936 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3937 sub->vtr_tag1, sub->vtr_tag2);
3945 name_sort_cmp (void *a1, void *a2)
3947 name_sort_t *n1 = a1;
3948 name_sort_t *n2 = a2;
3950 return strcmp ((char *) n1->name, (char *) n2->name);
3954 dump_interface_table (vat_main_t * vam)
3957 name_sort_t *nses = 0, *ns;
3959 if (vam->json_output)
3962 ("JSON output supported only for VPE API calls and dump_stats_table");
3967 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3969 vec_add2 (nses, ns, 1);
3970 ns->name = (u8 *)(p->key);
3971 ns->value = (u32) p->value[0];
3975 vec_sort_with_function (nses, name_sort_cmp);
3977 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3978 vec_foreach (ns, nses)
3980 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3987 dump_ip_table (vat_main_t * vam, int is_ipv6)
3989 const ip_details_t *det = NULL;
3990 const ip_address_details_t *address = NULL;
3993 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3995 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4002 fformat (vam->ofp, "%-12d\n", i);
4004 " %-30s%-13s\n", "Address", "Prefix length");
4009 vec_foreach (address, det->addr)
4013 is_ipv6 ? format_ip6_address : format_ip4_address,
4014 address->ip, address->prefix_length);
4022 dump_ipv4_table (vat_main_t * vam)
4024 if (vam->json_output)
4027 ("JSON output supported only for VPE API calls and dump_stats_table");
4031 return dump_ip_table (vam, 0);
4035 dump_ipv6_table (vat_main_t * vam)
4037 if (vam->json_output)
4040 ("JSON output supported only for VPE API calls and dump_stats_table");
4044 return dump_ip_table (vam, 1);
4048 counter_type_to_str (u8 counter_type, u8 is_combined)
4052 switch (counter_type)
4054 case VNET_INTERFACE_COUNTER_DROP:
4056 case VNET_INTERFACE_COUNTER_PUNT:
4058 case VNET_INTERFACE_COUNTER_IP4:
4060 case VNET_INTERFACE_COUNTER_IP6:
4062 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4064 case VNET_INTERFACE_COUNTER_RX_MISS:
4066 case VNET_INTERFACE_COUNTER_RX_ERROR:
4068 case VNET_INTERFACE_COUNTER_TX_ERROR:
4071 return "INVALID-COUNTER-TYPE";
4076 switch (counter_type)
4078 case VNET_INTERFACE_COUNTER_RX:
4080 case VNET_INTERFACE_COUNTER_TX:
4083 return "INVALID-COUNTER-TYPE";
4089 dump_stats_table (vat_main_t * vam)
4091 vat_json_node_t node;
4092 vat_json_node_t *msg_array;
4093 vat_json_node_t *msg;
4094 vat_json_node_t *counter_array;
4095 vat_json_node_t *counter;
4096 interface_counter_t c;
4098 ip4_fib_counter_t *c4;
4099 ip6_fib_counter_t *c6;
4102 if (!vam->json_output)
4104 clib_warning ("dump_stats_table supported only in JSON format");
4108 vat_json_init_object (&node);
4110 /* interface counters */
4111 msg_array = vat_json_object_add (&node, "interface_counters");
4112 vat_json_init_array (msg_array);
4113 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4115 msg = vat_json_array_add (msg_array);
4116 vat_json_init_object (msg);
4117 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4118 (u8 *) counter_type_to_str (i, 0));
4119 vat_json_object_add_int (msg, "is_combined", 0);
4120 counter_array = vat_json_object_add (msg, "data");
4121 vat_json_init_array (counter_array);
4122 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4124 packets = vam->simple_interface_counters[i][j];
4125 vat_json_array_add_uint (counter_array, packets);
4128 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4130 msg = vat_json_array_add (msg_array);
4131 vat_json_init_object (msg);
4132 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4133 (u8 *) counter_type_to_str (i, 1));
4134 vat_json_object_add_int (msg, "is_combined", 1);
4135 counter_array = vat_json_object_add (msg, "data");
4136 vat_json_init_array (counter_array);
4137 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4139 c = vam->combined_interface_counters[i][j];
4140 counter = vat_json_array_add (counter_array);
4141 vat_json_init_object (counter);
4142 vat_json_object_add_uint (counter, "packets", c.packets);
4143 vat_json_object_add_uint (counter, "bytes", c.bytes);
4147 /* ip4 fib counters */
4148 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4149 vat_json_init_array (msg_array);
4150 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4152 msg = vat_json_array_add (msg_array);
4153 vat_json_init_object (msg);
4154 vat_json_object_add_uint (msg, "vrf_id",
4155 vam->ip4_fib_counters_vrf_id_by_index[i]);
4156 counter_array = vat_json_object_add (msg, "c");
4157 vat_json_init_array (counter_array);
4158 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4160 counter = vat_json_array_add (counter_array);
4161 vat_json_init_object (counter);
4162 c4 = &vam->ip4_fib_counters[i][j];
4163 vat_json_object_add_ip4 (counter, "address", c4->address);
4164 vat_json_object_add_uint (counter, "address_length",
4165 c4->address_length);
4166 vat_json_object_add_uint (counter, "packets", c4->packets);
4167 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4171 /* ip6 fib counters */
4172 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4173 vat_json_init_array (msg_array);
4174 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4176 msg = vat_json_array_add (msg_array);
4177 vat_json_init_object (msg);
4178 vat_json_object_add_uint (msg, "vrf_id",
4179 vam->ip6_fib_counters_vrf_id_by_index[i]);
4180 counter_array = vat_json_object_add (msg, "c");
4181 vat_json_init_array (counter_array);
4182 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4184 counter = vat_json_array_add (counter_array);
4185 vat_json_init_object (counter);
4186 c6 = &vam->ip6_fib_counters[i][j];
4187 vat_json_object_add_ip6 (counter, "address", c6->address);
4188 vat_json_object_add_uint (counter, "address_length",
4189 c6->address_length);
4190 vat_json_object_add_uint (counter, "packets", c6->packets);
4191 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4195 vat_json_print (vam->ofp, &node);
4196 vat_json_free (&node);
4202 exec (vat_main_t * vam)
4204 api_main_t *am = &api_main;
4205 vl_api_cli_request_t *mp;
4209 unformat_input_t *i = vam->input;
4211 if (vec_len (i->buffer) == 0)
4214 if (vam->exec_mode == 0 && unformat (i, "mode"))
4219 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4226 M (CLI_REQUEST, cli_request);
4229 * Copy cmd into shared memory.
4230 * In order for the CLI command to work, it
4231 * must be a vector ending in \n, not a C-string ending
4234 pthread_mutex_lock (&am->vlib_rp->mutex);
4235 oldheap = svm_push_data_heap (am->vlib_rp);
4237 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4238 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4240 svm_pop_heap (oldheap);
4241 pthread_mutex_unlock (&am->vlib_rp->mutex);
4243 mp->cmd_in_shmem = (u64) cmd;
4245 timeout = vat_time_now (vam) + 10.0;
4247 while (vat_time_now (vam) < timeout)
4249 if (vam->result_ready == 1)
4252 if (vam->shmem_result != NULL)
4253 fformat (vam->ofp, "%s", vam->shmem_result);
4254 pthread_mutex_lock (&am->vlib_rp->mutex);
4255 oldheap = svm_push_data_heap (am->vlib_rp);
4257 free_me = (u8 *) vam->shmem_result;
4260 svm_pop_heap (oldheap);
4261 pthread_mutex_unlock (&am->vlib_rp->mutex);
4269 * Future replacement of exec() that passes CLI buffers directly in
4270 * the API messages instead of an additional shared memory area.
4273 exec_inband (vat_main_t * vam)
4275 vl_api_cli_inband_t *mp;
4277 unformat_input_t *i = vam->input;
4279 if (vec_len (i->buffer) == 0)
4282 if (vam->exec_mode == 0 && unformat (i, "mode"))
4287 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4294 * In order for the CLI command to work, it
4295 * must be a vector ending in \n, not a C-string ending
4298 u32 len = vec_len (vam->input->buffer);
4299 M2 (CLI_INBAND, cli_inband, len);
4300 clib_memcpy (mp->cmd, vam->input->buffer, len);
4301 mp->length = htonl (len);
4304 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4308 api_create_loopback (vat_main_t * vam)
4310 unformat_input_t *i = vam->input;
4311 vl_api_create_loopback_t *mp;
4316 memset (mac_address, 0, sizeof (mac_address));
4318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4320 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4326 /* Construct the API message */
4327 M (CREATE_LOOPBACK, create_loopback);
4329 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4336 api_delete_loopback (vat_main_t * vam)
4338 unformat_input_t *i = vam->input;
4339 vl_api_delete_loopback_t *mp;
4341 u32 sw_if_index = ~0;
4343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4345 if (unformat (i, "sw_if_index %d", &sw_if_index))
4351 if (sw_if_index == ~0)
4353 errmsg ("missing sw_if_index\n");
4357 /* Construct the API message */
4358 M (DELETE_LOOPBACK, delete_loopback);
4359 mp->sw_if_index = ntohl (sw_if_index);
4366 api_want_stats (vat_main_t * vam)
4368 unformat_input_t *i = vam->input;
4369 vl_api_want_stats_t *mp;
4373 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4375 if (unformat (i, "enable"))
4377 else if (unformat (i, "disable"))
4385 errmsg ("missing enable|disable\n");
4389 M (WANT_STATS, want_stats);
4390 mp->enable_disable = enable;
4397 api_want_interface_events (vat_main_t * vam)
4399 unformat_input_t *i = vam->input;
4400 vl_api_want_interface_events_t *mp;
4404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4406 if (unformat (i, "enable"))
4408 else if (unformat (i, "disable"))
4416 errmsg ("missing enable|disable\n");
4420 M (WANT_INTERFACE_EVENTS, want_interface_events);
4421 mp->enable_disable = enable;
4423 vam->interface_event_display = enable;
4430 /* Note: non-static, called once to set up the initial intfc table */
4432 api_sw_interface_dump (vat_main_t * vam)
4434 vl_api_sw_interface_dump_t *mp;
4437 name_sort_t *nses = 0, *ns;
4438 sw_interface_subif_t *sub = NULL;
4440 /* Toss the old name table */
4442 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4444 vec_add2 (nses, ns, 1);
4445 ns->name = (u8 *)(p->key);
4446 ns->value = (u32) p->value[0];
4450 hash_free (vam->sw_if_index_by_interface_name);
4452 vec_foreach (ns, nses) vec_free (ns->name);
4456 vec_foreach (sub, vam->sw_if_subif_table)
4458 vec_free (sub->interface_name);
4460 vec_free (vam->sw_if_subif_table);
4462 /* recreate the interface name hash table */
4463 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4465 /* Get list of ethernets */
4466 M (SW_INTERFACE_DUMP, sw_interface_dump);
4467 mp->name_filter_valid = 1;
4468 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4471 /* and local / loopback interfaces */
4472 M (SW_INTERFACE_DUMP, sw_interface_dump);
4473 mp->name_filter_valid = 1;
4474 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4477 /* and packet-generator interfaces */
4478 M (SW_INTERFACE_DUMP, sw_interface_dump);
4479 mp->name_filter_valid = 1;
4480 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4483 /* and vxlan-gpe tunnel interfaces */
4484 M (SW_INTERFACE_DUMP, sw_interface_dump);
4485 mp->name_filter_valid = 1;
4486 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4487 sizeof (mp->name_filter) - 1);
4490 /* and vxlan tunnel interfaces */
4491 M (SW_INTERFACE_DUMP, sw_interface_dump);
4492 mp->name_filter_valid = 1;
4493 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4496 /* and host (af_packet) interfaces */
4497 M (SW_INTERFACE_DUMP, sw_interface_dump);
4498 mp->name_filter_valid = 1;
4499 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4502 /* and l2tpv3 tunnel interfaces */
4503 M (SW_INTERFACE_DUMP, sw_interface_dump);
4504 mp->name_filter_valid = 1;
4505 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4506 sizeof (mp->name_filter) - 1);
4509 /* and GRE tunnel interfaces */
4510 M (SW_INTERFACE_DUMP, sw_interface_dump);
4511 mp->name_filter_valid = 1;
4512 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4515 /* and LISP-GPE interfaces */
4516 M (SW_INTERFACE_DUMP, sw_interface_dump);
4517 mp->name_filter_valid = 1;
4518 strncpy ((char *) mp->name_filter, "lisp_gpe",
4519 sizeof (mp->name_filter) - 1);
4522 /* and IPSEC tunnel interfaces */
4523 M (SW_INTERFACE_DUMP, sw_interface_dump);
4524 mp->name_filter_valid = 1;
4525 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4528 /* Use a control ping for synchronization */
4530 vl_api_control_ping_t *mp;
4531 M (CONTROL_PING, control_ping);
4538 api_sw_interface_set_flags (vat_main_t * vam)
4540 unformat_input_t *i = vam->input;
4541 vl_api_sw_interface_set_flags_t *mp;
4544 u8 sw_if_index_set = 0;
4545 u8 admin_up = 0, link_up = 0;
4547 /* Parse args required to build the message */
4548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4550 if (unformat (i, "admin-up"))
4552 else if (unformat (i, "admin-down"))
4554 else if (unformat (i, "link-up"))
4556 else if (unformat (i, "link-down"))
4558 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4559 sw_if_index_set = 1;
4560 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4561 sw_if_index_set = 1;
4566 if (sw_if_index_set == 0)
4568 errmsg ("missing interface name or sw_if_index\n");
4572 /* Construct the API message */
4573 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4574 mp->sw_if_index = ntohl (sw_if_index);
4575 mp->admin_up_down = admin_up;
4576 mp->link_up_down = link_up;
4581 /* Wait for a reply, return the good/bad news... */
4586 api_sw_interface_clear_stats (vat_main_t * vam)
4588 unformat_input_t *i = vam->input;
4589 vl_api_sw_interface_clear_stats_t *mp;
4592 u8 sw_if_index_set = 0;
4594 /* Parse args required to build the message */
4595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4597 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4598 sw_if_index_set = 1;
4599 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4600 sw_if_index_set = 1;
4605 /* Construct the API message */
4606 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4608 if (sw_if_index_set == 1)
4609 mp->sw_if_index = ntohl (sw_if_index);
4611 mp->sw_if_index = ~0;
4616 /* Wait for a reply, return the good/bad news... */
4621 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4623 unformat_input_t *i = vam->input;
4624 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4627 u8 sw_if_index_set = 0;
4635 /* Parse args required to build the message */
4636 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4638 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4639 sw_if_index_set = 1;
4640 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4641 sw_if_index_set = 1;
4642 else if (unformat (i, "subport %u", &subport))
4644 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4645 sw_if_index_set = 1;
4646 else if (unformat (i, "pipe %u", &pipe))
4648 else if (unformat (i, "profile %u", &profile))
4654 if (sw_if_index_set == 0)
4656 errmsg ("missing interface name or sw_if_index\n");
4660 if (subport_set == 0)
4662 errmsg ("missing subport \n");
4668 errmsg ("missing pipe\n");
4672 if (profile_set == 0)
4674 errmsg ("missing profile\n");
4678 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
4680 mp->sw_if_index = ntohl (sw_if_index);
4681 mp->subport = ntohl (subport);
4682 mp->pipe = ntohl (pipe);
4683 mp->profile = ntohl (profile);
4693 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
4695 unformat_input_t *i = vam->input;
4696 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
4699 u8 sw_if_index_set = 0;
4702 u32 tb_rate = 1250000000; /* 10GbE */
4703 u32 tb_size = 1000000;
4704 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
4707 /* Parse args required to build the message */
4708 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4710 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4711 sw_if_index_set = 1;
4712 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4713 sw_if_index_set = 1;
4714 else if (unformat (i, "subport %u", &subport))
4716 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4717 sw_if_index_set = 1;
4718 else if (unformat (i, "rate %u", &tb_rate))
4722 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
4724 tc_rate[tc_id] = tb_rate;
4726 else if (unformat (i, "bktsize %u", &tb_size))
4728 else if (unformat (i, "tc0 %u", &tc_rate[0]))
4730 else if (unformat (i, "tc1 %u", &tc_rate[1]))
4732 else if (unformat (i, "tc2 %u", &tc_rate[2]))
4734 else if (unformat (i, "tc3 %u", &tc_rate[3]))
4736 else if (unformat (i, "period %u", &tc_period))
4742 if (sw_if_index_set == 0)
4744 errmsg ("missing interface name or sw_if_index\n");
4748 if (subport_set == 0)
4750 errmsg ("missing subport \n");
4754 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
4756 mp->sw_if_index = ntohl (sw_if_index);
4757 mp->subport = ntohl (subport);
4758 mp->tb_rate = ntohl (tb_rate);
4759 mp->tb_size = ntohl (tb_size);
4760 mp->tc_rate[0] = ntohl (tc_rate[0]);
4761 mp->tc_rate[1] = ntohl (tc_rate[1]);
4762 mp->tc_rate[2] = ntohl (tc_rate[2]);
4763 mp->tc_rate[3] = ntohl (tc_rate[3]);
4764 mp->tc_period = ntohl (tc_period);
4773 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
4775 unformat_input_t *i = vam->input;
4776 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
4779 u8 sw_if_index_set = 0;
4783 u32 entry, tc, queue;
4785 /* Parse args required to build the message */
4786 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4788 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4789 sw_if_index_set = 1;
4790 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4791 sw_if_index_set = 1;
4792 else if (unformat (i, "entry %d", &entry))
4794 else if (unformat (i, "tc %d", &tc))
4796 else if (unformat (i, "queue %d", &queue))
4802 if (sw_if_index_set == 0)
4804 errmsg ("missing interface name or sw_if_index\n");
4810 errmsg ("missing entry \n");
4816 errmsg ("missing traffic class \n");
4822 errmsg ("missing queue \n");
4826 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
4828 mp->sw_if_index = ntohl (sw_if_index);
4829 mp->entry = ntohl (entry);
4830 mp->tc = ntohl (tc);
4831 mp->queue = ntohl (queue);
4840 api_sw_interface_add_del_address (vat_main_t * vam)
4842 unformat_input_t *i = vam->input;
4843 vl_api_sw_interface_add_del_address_t *mp;
4846 u8 sw_if_index_set = 0;
4847 u8 is_add = 1, del_all = 0;
4848 u32 address_length = 0;
4849 u8 v4_address_set = 0;
4850 u8 v6_address_set = 0;
4851 ip4_address_t v4address;
4852 ip6_address_t v6address;
4854 /* Parse args required to build the message */
4855 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4857 if (unformat (i, "del-all"))
4859 else if (unformat (i, "del"))
4861 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4862 sw_if_index_set = 1;
4863 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4864 sw_if_index_set = 1;
4865 else if (unformat (i, "%U/%d",
4866 unformat_ip4_address, &v4address, &address_length))
4868 else if (unformat (i, "%U/%d",
4869 unformat_ip6_address, &v6address, &address_length))
4875 if (sw_if_index_set == 0)
4877 errmsg ("missing interface name or sw_if_index\n");
4880 if (v4_address_set && v6_address_set)
4882 errmsg ("both v4 and v6 addresses set\n");
4885 if (!v4_address_set && !v6_address_set && !del_all)
4887 errmsg ("no addresses set\n");
4891 /* Construct the API message */
4892 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4894 mp->sw_if_index = ntohl (sw_if_index);
4895 mp->is_add = is_add;
4896 mp->del_all = del_all;
4900 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4904 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4906 mp->address_length = address_length;
4911 /* Wait for a reply, return good/bad news */
4916 api_sw_interface_set_mpls_enable (vat_main_t * vam)
4918 unformat_input_t *i = vam->input;
4919 vl_api_sw_interface_set_mpls_enable_t *mp;
4922 u8 sw_if_index_set = 0;
4925 /* Parse args required to build the message */
4926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4928 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4929 sw_if_index_set = 1;
4930 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4931 sw_if_index_set = 1;
4932 else if (unformat (i, "disable"))
4934 else if (unformat (i, "dis"))
4940 if (sw_if_index_set == 0)
4942 errmsg ("missing interface name or sw_if_index\n");
4946 /* Construct the API message */
4947 M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable);
4949 mp->sw_if_index = ntohl (sw_if_index);
4950 mp->enable = enable;
4955 /* Wait for a reply... */
4960 api_sw_interface_set_table (vat_main_t * vam)
4962 unformat_input_t *i = vam->input;
4963 vl_api_sw_interface_set_table_t *mp;
4965 u32 sw_if_index, vrf_id = 0;
4966 u8 sw_if_index_set = 0;
4969 /* Parse args required to build the message */
4970 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4972 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4973 sw_if_index_set = 1;
4974 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4975 sw_if_index_set = 1;
4976 else if (unformat (i, "vrf %d", &vrf_id))
4978 else if (unformat (i, "ipv6"))
4984 if (sw_if_index_set == 0)
4986 errmsg ("missing interface name or sw_if_index\n");
4990 /* Construct the API message */
4991 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4993 mp->sw_if_index = ntohl (sw_if_index);
4994 mp->is_ipv6 = is_ipv6;
4995 mp->vrf_id = ntohl (vrf_id);
5000 /* Wait for a reply... */
5005 api_sw_interface_set_vpath (vat_main_t * vam)
5007 unformat_input_t *i = vam->input;
5008 vl_api_sw_interface_set_vpath_t *mp;
5010 u32 sw_if_index = 0;
5011 u8 sw_if_index_set = 0;
5014 /* Parse args required to build the message */
5015 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5017 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5018 sw_if_index_set = 1;
5019 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5020 sw_if_index_set = 1;
5021 else if (unformat (i, "enable"))
5023 else if (unformat (i, "disable"))
5029 if (sw_if_index_set == 0)
5031 errmsg ("missing interface name or sw_if_index\n");
5035 /* Construct the API message */
5036 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
5038 mp->sw_if_index = ntohl (sw_if_index);
5039 mp->enable = is_enable;
5044 /* Wait for a reply... */
5049 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5051 unformat_input_t *i = vam->input;
5052 vl_api_sw_interface_set_l2_xconnect_t *mp;
5055 u8 rx_sw_if_index_set = 0;
5057 u8 tx_sw_if_index_set = 0;
5060 /* Parse args required to build the message */
5061 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5063 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5064 rx_sw_if_index_set = 1;
5065 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5066 tx_sw_if_index_set = 1;
5067 else if (unformat (i, "rx"))
5069 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5071 if (unformat (i, "%U", unformat_sw_if_index, vam,
5073 rx_sw_if_index_set = 1;
5078 else if (unformat (i, "tx"))
5080 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5082 if (unformat (i, "%U", unformat_sw_if_index, vam,
5084 tx_sw_if_index_set = 1;
5089 else if (unformat (i, "enable"))
5091 else if (unformat (i, "disable"))
5097 if (rx_sw_if_index_set == 0)
5099 errmsg ("missing rx interface name or rx_sw_if_index\n");
5103 if (enable && (tx_sw_if_index_set == 0))
5105 errmsg ("missing tx interface name or tx_sw_if_index\n");
5109 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
5111 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5112 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5113 mp->enable = enable;
5122 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5124 unformat_input_t *i = vam->input;
5125 vl_api_sw_interface_set_l2_bridge_t *mp;
5128 u8 rx_sw_if_index_set = 0;
5135 /* Parse args required to build the message */
5136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5138 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5139 rx_sw_if_index_set = 1;
5140 else if (unformat (i, "bd_id %d", &bd_id))
5142 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
5143 rx_sw_if_index_set = 1;
5144 else if (unformat (i, "shg %d", &shg))
5146 else if (unformat (i, "bvi"))
5148 else if (unformat (i, "enable"))
5150 else if (unformat (i, "disable"))
5156 if (rx_sw_if_index_set == 0)
5158 errmsg ("missing rx interface name or sw_if_index\n");
5162 if (enable && (bd_id_set == 0))
5164 errmsg ("missing bridge domain\n");
5168 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5170 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5171 mp->bd_id = ntohl (bd_id);
5174 mp->enable = enable;
5183 api_bridge_domain_dump (vat_main_t * vam)
5185 unformat_input_t *i = vam->input;
5186 vl_api_bridge_domain_dump_t *mp;
5190 /* Parse args required to build the message */
5191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5193 if (unformat (i, "bd_id %d", &bd_id))
5199 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5200 mp->bd_id = ntohl (bd_id);
5203 /* Use a control ping for synchronization */
5205 vl_api_control_ping_t *mp;
5206 M (CONTROL_PING, control_ping);
5216 api_bridge_domain_add_del (vat_main_t * vam)
5218 unformat_input_t *i = vam->input;
5219 vl_api_bridge_domain_add_del_t *mp;
5223 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5225 /* Parse args required to build the message */
5226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5228 if (unformat (i, "bd_id %d", &bd_id))
5230 else if (unformat (i, "flood %d", &flood))
5232 else if (unformat (i, "uu-flood %d", &uu_flood))
5234 else if (unformat (i, "forward %d", &forward))
5236 else if (unformat (i, "learn %d", &learn))
5238 else if (unformat (i, "arp-term %d", &arp_term))
5240 else if (unformat (i, "del"))
5243 flood = uu_flood = forward = learn = 0;
5251 errmsg ("missing bridge domain\n");
5255 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5257 mp->bd_id = ntohl (bd_id);
5259 mp->uu_flood = uu_flood;
5260 mp->forward = forward;
5262 mp->arp_term = arp_term;
5263 mp->is_add = is_add;
5272 api_l2fib_add_del (vat_main_t * vam)
5274 unformat_input_t *i = vam->input;
5275 vl_api_l2fib_add_del_t *mp;
5282 u8 sw_if_index_set = 0;
5291 /* Parse args required to build the message */
5292 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5294 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5296 else if (unformat (i, "bd_id %d", &bd_id))
5298 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5299 sw_if_index_set = 1;
5300 else if (unformat (i, "sw_if"))
5302 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5304 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5305 sw_if_index_set = 1;
5310 else if (unformat (i, "static"))
5312 else if (unformat (i, "filter"))
5317 else if (unformat (i, "bvi"))
5322 else if (unformat (i, "del"))
5324 else if (unformat (i, "count %d", &count))
5332 errmsg ("missing mac address\n");
5338 errmsg ("missing bridge domain\n");
5342 if (is_add && (sw_if_index_set == 0))
5344 errmsg ("missing interface name or sw_if_index\n");
5350 /* Turn on async mode */
5351 vam->async_mode = 1;
5352 vam->async_errors = 0;
5353 before = vat_time_now (vam);
5356 for (j = 0; j < count; j++)
5358 M (L2FIB_ADD_DEL, l2fib_add_del);
5361 mp->bd_id = ntohl (bd_id);
5362 mp->is_add = is_add;
5366 mp->sw_if_index = ntohl (sw_if_index);
5367 mp->static_mac = static_mac;
5368 mp->filter_mac = filter_mac;
5369 mp->bvi_mac = bvi_mac;
5371 increment_mac_address (&mac);
5378 vl_api_control_ping_t *mp;
5381 /* Shut off async mode */
5382 vam->async_mode = 0;
5384 M (CONTROL_PING, control_ping);
5387 timeout = vat_time_now (vam) + 1.0;
5388 while (vat_time_now (vam) < timeout)
5389 if (vam->result_ready == 1)
5394 if (vam->retval == -99)
5395 errmsg ("timeout\n");
5397 if (vam->async_errors > 0)
5399 errmsg ("%d asynchronous errors\n", vam->async_errors);
5402 vam->async_errors = 0;
5403 after = vat_time_now (vam);
5405 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5406 count, after - before, count / (after - before));
5410 /* Wait for a reply... */
5413 /* Return the good/bad news */
5414 return (vam->retval);
5418 api_l2_flags (vat_main_t * vam)
5420 unformat_input_t *i = vam->input;
5421 vl_api_l2_flags_t *mp;
5424 u32 feature_bitmap = 0;
5425 u8 sw_if_index_set = 0;
5427 /* Parse args required to build the message */
5428 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5430 if (unformat (i, "sw_if_index %d", &sw_if_index))
5431 sw_if_index_set = 1;
5432 else if (unformat (i, "sw_if"))
5434 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5436 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5437 sw_if_index_set = 1;
5442 else if (unformat (i, "learn"))
5443 feature_bitmap |= L2INPUT_FEAT_LEARN;
5444 else if (unformat (i, "forward"))
5445 feature_bitmap |= L2INPUT_FEAT_FWD;
5446 else if (unformat (i, "flood"))
5447 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5448 else if (unformat (i, "uu-flood"))
5449 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5454 if (sw_if_index_set == 0)
5456 errmsg ("missing interface name or sw_if_index\n");
5460 M (L2_FLAGS, l2_flags);
5462 mp->sw_if_index = ntohl (sw_if_index);
5463 mp->feature_bitmap = ntohl (feature_bitmap);
5472 api_bridge_flags (vat_main_t * vam)
5474 unformat_input_t *i = vam->input;
5475 vl_api_bridge_flags_t *mp;
5482 /* Parse args required to build the message */
5483 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5485 if (unformat (i, "bd_id %d", &bd_id))
5487 else if (unformat (i, "learn"))
5489 else if (unformat (i, "forward"))
5491 else if (unformat (i, "flood"))
5493 else if (unformat (i, "uu-flood"))
5494 flags |= L2_UU_FLOOD;
5495 else if (unformat (i, "arp-term"))
5496 flags |= L2_ARP_TERM;
5497 else if (unformat (i, "off"))
5499 else if (unformat (i, "disable"))
5507 errmsg ("missing bridge domain\n");
5511 M (BRIDGE_FLAGS, bridge_flags);
5513 mp->bd_id = ntohl (bd_id);
5514 mp->feature_bitmap = ntohl (flags);
5515 mp->is_set = is_set;
5524 api_bd_ip_mac_add_del (vat_main_t * vam)
5526 unformat_input_t *i = vam->input;
5527 vl_api_bd_ip_mac_add_del_t *mp;
5535 ip4_address_t v4addr;
5536 ip6_address_t v6addr;
5540 /* Parse args required to build the message */
5541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5543 if (unformat (i, "bd_id %d", &bd_id))
5547 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5551 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5556 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5560 else if (unformat (i, "del"))
5568 errmsg ("missing bridge domain\n");
5571 else if (ip_set == 0)
5573 errmsg ("missing IP address\n");
5576 else if (mac_set == 0)
5578 errmsg ("missing MAC address\n");
5582 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5584 mp->bd_id = ntohl (bd_id);
5585 mp->is_ipv6 = is_ipv6;
5586 mp->is_add = is_add;
5588 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5590 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5591 clib_memcpy (mp->mac_address, macaddr, 6);
5599 api_tap_connect (vat_main_t * vam)
5601 unformat_input_t *i = vam->input;
5602 vl_api_tap_connect_t *mp;
5609 memset (mac_address, 0, sizeof (mac_address));
5611 /* Parse args required to build the message */
5612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5614 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5618 else if (unformat (i, "random-mac"))
5620 else if (unformat (i, "tapname %s", &tap_name))
5628 errmsg ("missing tap name\n");
5631 if (vec_len (tap_name) > 63)
5633 errmsg ("tap name too long\n");
5635 vec_add1 (tap_name, 0);
5637 /* Construct the API message */
5638 M (TAP_CONNECT, tap_connect);
5640 mp->use_random_mac = random_mac;
5641 clib_memcpy (mp->mac_address, mac_address, 6);
5642 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5643 vec_free (tap_name);
5648 /* Wait for a reply... */
5653 api_tap_modify (vat_main_t * vam)
5655 unformat_input_t *i = vam->input;
5656 vl_api_tap_modify_t *mp;
5662 u32 sw_if_index = ~0;
5663 u8 sw_if_index_set = 0;
5665 memset (mac_address, 0, sizeof (mac_address));
5667 /* Parse args required to build the message */
5668 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5670 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5671 sw_if_index_set = 1;
5672 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5673 sw_if_index_set = 1;
5674 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5678 else if (unformat (i, "random-mac"))
5680 else if (unformat (i, "tapname %s", &tap_name))
5686 if (sw_if_index_set == 0)
5688 errmsg ("missing vpp interface name");
5693 errmsg ("missing tap name\n");
5696 if (vec_len (tap_name) > 63)
5698 errmsg ("tap name too long\n");
5700 vec_add1 (tap_name, 0);
5702 /* Construct the API message */
5703 M (TAP_MODIFY, tap_modify);
5705 mp->use_random_mac = random_mac;
5706 mp->sw_if_index = ntohl (sw_if_index);
5707 clib_memcpy (mp->mac_address, mac_address, 6);
5708 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5709 vec_free (tap_name);
5714 /* Wait for a reply... */
5719 api_tap_delete (vat_main_t * vam)
5721 unformat_input_t *i = vam->input;
5722 vl_api_tap_delete_t *mp;
5724 u32 sw_if_index = ~0;
5725 u8 sw_if_index_set = 0;
5727 /* Parse args required to build the message */
5728 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5730 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5731 sw_if_index_set = 1;
5732 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5733 sw_if_index_set = 1;
5738 if (sw_if_index_set == 0)
5740 errmsg ("missing vpp interface name");
5744 /* Construct the API message */
5745 M (TAP_DELETE, tap_delete);
5747 mp->sw_if_index = ntohl (sw_if_index);
5752 /* Wait for a reply... */
5757 api_ip_add_del_route (vat_main_t * vam)
5759 unformat_input_t *i = vam->input;
5760 vl_api_ip_add_del_route_t *mp;
5762 u32 sw_if_index = ~0, vrf_id = 0;
5763 u8 sw_if_index_set = 0;
5765 u8 is_local = 0, is_drop = 0;
5766 u8 is_unreach = 0, is_prohibit = 0;
5767 u8 create_vrf_if_needed = 0;
5769 u8 next_hop_weight = 1;
5771 u8 is_multipath = 0;
5773 u8 address_length_set = 0;
5774 u32 next_hop_table_id = 0;
5775 u32 resolve_attempts = 0;
5776 u32 dst_address_length = 0;
5777 u8 next_hop_set = 0;
5778 ip4_address_t v4_dst_address, v4_next_hop_address;
5779 ip6_address_t v6_dst_address, v6_next_hop_address;
5783 u32 random_add_del = 0;
5784 u32 *random_vector = 0;
5786 u32 random_seed = 0xdeaddabe;
5787 u32 classify_table_index = ~0;
5789 u8 resolve_host = 0, resolve_attached = 0;
5790 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
5792 /* Parse args required to build the message */
5793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5795 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5796 sw_if_index_set = 1;
5797 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5798 sw_if_index_set = 1;
5799 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5804 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5809 else if (unformat (i, "/%d", &dst_address_length))
5811 address_length_set = 1;
5814 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5815 &v4_next_hop_address))
5819 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5820 &v6_next_hop_address))
5824 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5826 else if (unformat (i, "weight %d", &next_hop_weight))
5828 else if (unformat (i, "drop"))
5832 else if (unformat (i, "null-send-unreach"))
5836 else if (unformat (i, "null-send-prohibit"))
5840 else if (unformat (i, "local"))
5844 else if (unformat (i, "classify %d", &classify_table_index))
5848 else if (unformat (i, "del"))
5850 else if (unformat (i, "add"))
5852 else if (unformat (i, "not-last"))
5854 else if (unformat (i, "resolve-via-host"))
5856 else if (unformat (i, "resolve-via-attached"))
5857 resolve_attached = 1;
5858 else if (unformat (i, "multipath"))
5860 else if (unformat (i, "vrf %d", &vrf_id))
5862 else if (unformat (i, "create-vrf"))
5863 create_vrf_if_needed = 1;
5864 else if (unformat (i, "count %d", &count))
5866 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
5868 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
5870 else if (unformat (i, "out-label %d", &next_hop_out_label))
5872 else if (unformat (i, "random"))
5874 else if (unformat (i, "seed %d", &random_seed))
5878 clib_warning ("parse error '%U'", format_unformat_error, i);
5883 if (resolve_attempts > 0 && sw_if_index_set == 0)
5885 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5889 if (!next_hop_set && !is_drop && !is_local &&
5890 !is_classify && !is_unreach && !is_prohibit)
5893 ("next hop / local / drop / unreach / prohibit / classify not set\n");
5897 if (address_set == 0)
5899 errmsg ("missing addresses\n");
5903 if (address_length_set == 0)
5905 errmsg ("missing address length\n");
5909 /* Generate a pile of unique, random routes */
5912 u32 this_random_address;
5913 random_hash = hash_create (count, sizeof (uword));
5915 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5916 for (j = 0; j <= count; j++)
5920 this_random_address = random_u32 (&random_seed);
5921 this_random_address =
5922 clib_host_to_net_u32 (this_random_address);
5924 while (hash_get (random_hash, this_random_address));
5925 vec_add1 (random_vector, this_random_address);
5926 hash_set (random_hash, this_random_address, 1);
5928 hash_free (random_hash);
5929 v4_dst_address.as_u32 = random_vector[0];
5934 /* Turn on async mode */
5935 vam->async_mode = 1;
5936 vam->async_errors = 0;
5937 before = vat_time_now (vam);
5940 for (j = 0; j < count; j++)
5942 /* Construct the API message */
5943 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5945 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5946 mp->table_id = ntohl (vrf_id);
5947 if (resolve_attempts > 0)
5949 mp->resolve_attempts = ntohl (resolve_attempts);
5950 mp->resolve_if_needed = 1;
5952 mp->create_vrf_if_needed = create_vrf_if_needed;
5954 mp->is_add = is_add;
5955 mp->is_drop = is_drop;
5956 mp->is_unreach = is_unreach;
5957 mp->is_prohibit = is_prohibit;
5958 mp->is_ipv6 = is_ipv6;
5959 mp->is_local = is_local;
5960 mp->is_classify = is_classify;
5961 mp->is_multipath = is_multipath;
5962 mp->is_resolve_host = resolve_host;
5963 mp->is_resolve_attached = resolve_attached;
5964 mp->not_last = not_last;
5965 mp->next_hop_weight = next_hop_weight;
5966 mp->dst_address_length = dst_address_length;
5967 mp->next_hop_table_id = ntohl (next_hop_table_id);
5968 mp->classify_table_index = ntohl (classify_table_index);
5969 mp->next_hop_out_label = ntohl (next_hop_out_label);
5973 clib_memcpy (mp->dst_address, &v6_dst_address,
5974 sizeof (v6_dst_address));
5976 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5977 sizeof (v6_next_hop_address));
5978 increment_v6_address (&v6_dst_address);
5982 clib_memcpy (mp->dst_address, &v4_dst_address,
5983 sizeof (v4_dst_address));
5985 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5986 sizeof (v4_next_hop_address));
5988 v4_dst_address.as_u32 = random_vector[j + 1];
5990 increment_v4_address (&v4_dst_address);
5994 /* If we receive SIGTERM, stop now... */
5999 /* When testing multiple add/del ops, use a control-ping to sync */
6002 vl_api_control_ping_t *mp;
6005 /* Shut off async mode */
6006 vam->async_mode = 0;
6008 M (CONTROL_PING, control_ping);
6011 timeout = vat_time_now (vam) + 1.0;
6012 while (vat_time_now (vam) < timeout)
6013 if (vam->result_ready == 1)
6018 if (vam->retval == -99)
6019 errmsg ("timeout\n");
6021 if (vam->async_errors > 0)
6023 errmsg ("%d asynchronous errors\n", vam->async_errors);
6026 vam->async_errors = 0;
6027 after = vat_time_now (vam);
6029 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6033 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6034 count, after - before, count / (after - before));
6038 /* Wait for a reply... */
6042 /* Return the good/bad news */
6043 return (vam->retval);
6047 api_mpls_route_add_del (vat_main_t * vam)
6049 unformat_input_t *i = vam->input;
6050 vl_api_mpls_route_add_del_t *mp;
6052 u32 sw_if_index = ~0, table_id = 0;
6053 u8 create_table_if_needed = 0;
6055 u8 next_hop_weight = 1;
6056 u8 is_multipath = 0;
6057 u32 next_hop_table_id = 0;
6058 u8 next_hop_set = 0;
6059 ip4_address_t v4_next_hop_address = {
6062 ip6_address_t v6_next_hop_address = { {0} };
6066 u32 classify_table_index = ~0;
6068 u8 resolve_host = 0, resolve_attached = 0;
6069 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6070 mpls_label_t local_label = MPLS_LABEL_INVALID;
6072 u8 next_hop_proto_is_ip4 = 1;
6074 /* Parse args required to build the message */
6075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6077 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6081 else if (unformat (i, "%d", &local_label))
6083 else if (unformat (i, "eos"))
6085 else if (unformat (i, "non-eos"))
6087 else if (unformat (i, "via %U", unformat_ip4_address,
6088 &v4_next_hop_address))
6091 next_hop_proto_is_ip4 = 1;
6093 else if (unformat (i, "via %U", unformat_ip6_address,
6094 &v6_next_hop_address))
6097 next_hop_proto_is_ip4 = 0;
6099 else if (unformat (i, "weight %d", &next_hop_weight))
6101 else if (unformat (i, "create-table"))
6102 create_table_if_needed = 1;
6103 else if (unformat (i, "classify %d", &classify_table_index))
6107 else if (unformat (i, "del"))
6109 else if (unformat (i, "add"))
6111 else if (unformat (i, "resolve-via-host"))
6113 else if (unformat (i, "resolve-via-attached"))
6114 resolve_attached = 1;
6115 else if (unformat (i, "multipath"))
6117 else if (unformat (i, "count %d", &count))
6119 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6122 next_hop_proto_is_ip4 = 1;
6124 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6127 next_hop_proto_is_ip4 = 0;
6129 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6131 else if (unformat (i, "out-label %d", &next_hop_out_label))
6135 clib_warning ("parse error '%U'", format_unformat_error, i);
6140 if (!next_hop_set && !is_classify)
6142 errmsg ("next hop / classify not set\n");
6146 if (MPLS_LABEL_INVALID == local_label)
6148 errmsg ("missing label\n");
6154 /* Turn on async mode */
6155 vam->async_mode = 1;
6156 vam->async_errors = 0;
6157 before = vat_time_now (vam);
6160 for (j = 0; j < count; j++)
6162 /* Construct the API message */
6163 M (MPLS_ROUTE_ADD_DEL, mpls_route_add_del);
6165 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6166 mp->mr_table_id = ntohl (table_id);
6167 mp->mr_create_table_if_needed = create_table_if_needed;
6169 mp->mr_is_add = is_add;
6170 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6171 mp->mr_is_classify = is_classify;
6172 mp->mr_is_multipath = is_multipath;
6173 mp->mr_is_resolve_host = resolve_host;
6174 mp->mr_is_resolve_attached = resolve_attached;
6175 mp->mr_next_hop_weight = next_hop_weight;
6176 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6177 mp->mr_classify_table_index = ntohl (classify_table_index);
6178 mp->mr_next_hop_out_label = ntohl (next_hop_out_label);
6179 mp->mr_label = ntohl (local_label);
6180 mp->mr_eos = is_eos;
6184 if (next_hop_proto_is_ip4)
6186 clib_memcpy (mp->mr_next_hop,
6187 &v4_next_hop_address,
6188 sizeof (v4_next_hop_address));
6192 clib_memcpy (mp->mr_next_hop,
6193 &v6_next_hop_address,
6194 sizeof (v6_next_hop_address));
6201 /* If we receive SIGTERM, stop now... */
6206 /* When testing multiple add/del ops, use a control-ping to sync */
6209 vl_api_control_ping_t *mp;
6212 /* Shut off async mode */
6213 vam->async_mode = 0;
6215 M (CONTROL_PING, control_ping);
6218 timeout = vat_time_now (vam) + 1.0;
6219 while (vat_time_now (vam) < timeout)
6220 if (vam->result_ready == 1)
6225 if (vam->retval == -99)
6226 errmsg ("timeout\n");
6228 if (vam->async_errors > 0)
6230 errmsg ("%d asynchronous errors\n", vam->async_errors);
6233 vam->async_errors = 0;
6234 after = vat_time_now (vam);
6236 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6240 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6241 count, after - before, count / (after - before));
6245 /* Wait for a reply... */
6249 /* Return the good/bad news */
6250 return (vam->retval);
6254 api_mpls_ip_bind_unbind (vat_main_t * vam)
6256 unformat_input_t *i = vam->input;
6257 vl_api_mpls_ip_bind_unbind_t *mp;
6259 u32 ip_table_id = 0;
6260 u8 create_table_if_needed = 0;
6263 ip4_address_t v4_address;
6264 ip6_address_t v6_address;
6267 mpls_label_t local_label = MPLS_LABEL_INVALID;
6269 /* Parse args required to build the message */
6270 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6272 if (unformat (i, "%U/%d", unformat_ip4_address,
6273 &v4_address, &address_length))
6278 else if (unformat (i, "%U/%d", unformat_ip6_address,
6279 &v6_address, &address_length))
6284 else if (unformat (i, "%d", &local_label))
6286 else if (unformat (i, "create-table"))
6287 create_table_if_needed = 1;
6288 else if (unformat (i, "table-id %d", &ip_table_id))
6290 else if (unformat (i, "unbind"))
6292 else if (unformat (i, "bind"))
6296 clib_warning ("parse error '%U'", format_unformat_error, i);
6303 errmsg ("IP addres not set\n");
6307 if (MPLS_LABEL_INVALID == local_label)
6309 errmsg ("missing label\n");
6313 /* Construct the API message */
6314 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6316 mp->mb_create_table_if_needed = create_table_if_needed;
6317 mp->mb_is_bind = is_bind;
6318 mp->mb_is_ip4 = is_ip4;
6319 mp->mb_ip_table_id = ntohl (ip_table_id);
6320 mp->mb_mpls_table_id = 0;
6321 mp->mb_label = ntohl (local_label);
6322 mp->mb_address_length = address_length;
6325 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6327 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6332 /* Wait for a reply... */
6337 api_proxy_arp_add_del (vat_main_t * vam)
6339 unformat_input_t *i = vam->input;
6340 vl_api_proxy_arp_add_del_t *mp;
6344 ip4_address_t lo, hi;
6347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6349 if (unformat (i, "vrf %d", &vrf_id))
6351 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6352 unformat_ip4_address, &hi))
6354 else if (unformat (i, "del"))
6358 clib_warning ("parse error '%U'", format_unformat_error, i);
6365 errmsg ("address range not set\n");
6369 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
6371 mp->vrf_id = ntohl (vrf_id);
6372 mp->is_add = is_add;
6373 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6374 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6383 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6385 unformat_input_t *i = vam->input;
6386 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6390 u8 sw_if_index_set = 0;
6392 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6394 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6395 sw_if_index_set = 1;
6396 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6397 sw_if_index_set = 1;
6398 else if (unformat (i, "enable"))
6400 else if (unformat (i, "disable"))
6404 clib_warning ("parse error '%U'", format_unformat_error, i);
6409 if (sw_if_index_set == 0)
6411 errmsg ("missing interface name or sw_if_index\n");
6415 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
6417 mp->sw_if_index = ntohl (sw_if_index);
6418 mp->enable_disable = enable;
6427 api_mpls_add_del_encap (vat_main_t * vam)
6429 unformat_input_t *i = vam->input;
6430 vl_api_mpls_add_del_encap_t *mp;
6435 ip4_address_t dst_address;
6438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6440 if (unformat (i, "vrf %d", &vrf_id))
6442 else if (unformat (i, "label %d", &label))
6443 vec_add1 (labels, ntohl (label));
6444 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
6446 else if (unformat (i, "del"))
6450 clib_warning ("parse error '%U'", format_unformat_error, i);
6455 if (vec_len (labels) == 0)
6457 errmsg ("missing encap label stack\n");
6461 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
6462 sizeof (u32) * vec_len (labels));
6464 mp->vrf_id = ntohl (vrf_id);
6465 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
6466 mp->is_add = is_add;
6467 mp->nlabels = vec_len (labels);
6468 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
6479 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
6481 unformat_input_t *i = vam->input;
6482 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
6484 u32 inner_vrf_id = 0;
6485 ip4_address_t intfc_address;
6486 u8 dst_mac_address[6];
6489 u8 intfc_address_length = 0;
6493 int tx_sw_if_index_set = 0;
6495 /* Shut up coverity */
6496 memset (dst_mac_address, 0, sizeof (dst_mac_address));
6498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6500 if (unformat (i, "vrf %d", &inner_vrf_id))
6502 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6503 &intfc_address, &tmp))
6504 intfc_address_length = tmp;
6505 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
6506 tx_sw_if_index_set = 1;
6507 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6508 tx_sw_if_index_set = 1;
6509 else if (unformat (i, "dst %U", unformat_ethernet_address,
6512 else if (unformat (i, "l2-only"))
6514 else if (unformat (i, "del"))
6518 clib_warning ("parse error '%U'", format_unformat_error, i);
6525 errmsg ("dst (mac address) not set\n");
6528 if (!tx_sw_if_index_set)
6530 errmsg ("tx-intfc not set\n");
6534 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
6536 mp->vrf_id = ntohl (inner_vrf_id);
6537 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
6538 mp->adj_address_length = intfc_address_length;
6539 clib_memcpy (mp->dst_mac_address, dst_mac_address,
6540 sizeof (dst_mac_address));
6541 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6542 mp->l2_only = l2_only;
6543 mp->is_add = is_add;
6552 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
6554 unformat_input_t *i = vam->input;
6555 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
6557 u32 inner_vrf_id = 0;
6558 u32 outer_vrf_id = 0;
6559 ip4_address_t adj_address;
6560 int adj_address_set = 0;
6561 ip4_address_t next_hop_address;
6562 int next_hop_address_set = 0;
6564 u8 adj_address_length = 0;
6567 u32 resolve_attempts = 5;
6568 u8 resolve_if_needed = 1;
6570 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6572 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
6574 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
6576 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6577 &adj_address, &tmp))
6579 adj_address_length = tmp;
6580 adj_address_set = 1;
6582 else if (unformat (i, "next-hop %U", unformat_ip4_address,
6584 next_hop_address_set = 1;
6585 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6587 else if (unformat (i, "resolve-if-needed %d", &tmp))
6588 resolve_if_needed = tmp;
6589 else if (unformat (i, "l2-only"))
6591 else if (unformat (i, "del"))
6595 clib_warning ("parse error '%U'", format_unformat_error, i);
6600 if (!adj_address_set)
6602 errmsg ("adjacency address/mask not set\n");
6605 if (!next_hop_address_set)
6607 errmsg ("ip4 next hop address (in outer fib) not set\n");
6611 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
6613 mp->inner_vrf_id = ntohl (inner_vrf_id);
6614 mp->outer_vrf_id = ntohl (outer_vrf_id);
6615 mp->resolve_attempts = ntohl (resolve_attempts);
6616 mp->resolve_if_needed = resolve_if_needed;
6617 mp->is_add = is_add;
6618 mp->l2_only = l2_only;
6619 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
6620 mp->adj_address_length = adj_address_length;
6621 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
6622 sizeof (next_hop_address));
6631 api_sw_interface_set_unnumbered (vat_main_t * vam)
6633 unformat_input_t *i = vam->input;
6634 vl_api_sw_interface_set_unnumbered_t *mp;
6637 u32 unnum_sw_index = ~0;
6639 u8 sw_if_index_set = 0;
6641 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6643 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6644 sw_if_index_set = 1;
6645 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6646 sw_if_index_set = 1;
6647 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6649 else if (unformat (i, "del"))
6653 clib_warning ("parse error '%U'", format_unformat_error, i);
6658 if (sw_if_index_set == 0)
6660 errmsg ("missing interface name or sw_if_index\n");
6664 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6666 mp->sw_if_index = ntohl (sw_if_index);
6667 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6668 mp->is_add = is_add;
6677 api_ip_neighbor_add_del (vat_main_t * vam)
6679 unformat_input_t *i = vam->input;
6680 vl_api_ip_neighbor_add_del_t *mp;
6683 u8 sw_if_index_set = 0;
6689 u8 v4_address_set = 0;
6690 u8 v6_address_set = 0;
6691 ip4_address_t v4address;
6692 ip6_address_t v6address;
6694 memset (mac_address, 0, sizeof (mac_address));
6696 /* Parse args required to build the message */
6697 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6699 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6703 else if (unformat (i, "del"))
6705 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6706 sw_if_index_set = 1;
6707 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6708 sw_if_index_set = 1;
6709 else if (unformat (i, "is_static"))
6711 else if (unformat (i, "vrf %d", &vrf_id))
6713 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6715 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6719 clib_warning ("parse error '%U'", format_unformat_error, i);
6724 if (sw_if_index_set == 0)
6726 errmsg ("missing interface name or sw_if_index\n");
6729 if (v4_address_set && v6_address_set)
6731 errmsg ("both v4 and v6 addresses set\n");
6734 if (!v4_address_set && !v6_address_set)
6736 errmsg ("no address set\n");
6740 /* Construct the API message */
6741 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6743 mp->sw_if_index = ntohl (sw_if_index);
6744 mp->is_add = is_add;
6745 mp->vrf_id = ntohl (vrf_id);
6746 mp->is_static = is_static;
6748 clib_memcpy (mp->mac_address, mac_address, 6);
6752 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6756 /* mp->is_ipv6 = 0; via memset in M macro above */
6757 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6763 /* Wait for a reply, return good/bad news */
6771 api_reset_vrf (vat_main_t * vam)
6773 unformat_input_t *i = vam->input;
6774 vl_api_reset_vrf_t *mp;
6780 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6782 if (unformat (i, "vrf %d", &vrf_id))
6784 else if (unformat (i, "ipv6"))
6788 clib_warning ("parse error '%U'", format_unformat_error, i);
6793 if (vrf_id_set == 0)
6795 errmsg ("missing vrf id\n");
6799 M (RESET_VRF, reset_vrf);
6801 mp->vrf_id = ntohl (vrf_id);
6802 mp->is_ipv6 = is_ipv6;
6811 api_create_vlan_subif (vat_main_t * vam)
6813 unformat_input_t *i = vam->input;
6814 vl_api_create_vlan_subif_t *mp;
6817 u8 sw_if_index_set = 0;
6821 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6823 if (unformat (i, "sw_if_index %d", &sw_if_index))
6824 sw_if_index_set = 1;
6825 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6826 sw_if_index_set = 1;
6827 else if (unformat (i, "vlan %d", &vlan_id))
6831 clib_warning ("parse error '%U'", format_unformat_error, i);
6836 if (sw_if_index_set == 0)
6838 errmsg ("missing interface name or sw_if_index\n");
6842 if (vlan_id_set == 0)
6844 errmsg ("missing vlan_id\n");
6847 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6849 mp->sw_if_index = ntohl (sw_if_index);
6850 mp->vlan_id = ntohl (vlan_id);
6858 #define foreach_create_subif_bit \
6865 _(outer_vlan_id_any) \
6866 _(inner_vlan_id_any)
6869 api_create_subif (vat_main_t * vam)
6871 unformat_input_t *i = vam->input;
6872 vl_api_create_subif_t *mp;
6875 u8 sw_if_index_set = 0;
6882 u32 exact_match = 0;
6883 u32 default_sub = 0;
6884 u32 outer_vlan_id_any = 0;
6885 u32 inner_vlan_id_any = 0;
6887 u16 outer_vlan_id = 0;
6888 u16 inner_vlan_id = 0;
6890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6892 if (unformat (i, "sw_if_index %d", &sw_if_index))
6893 sw_if_index_set = 1;
6894 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6895 sw_if_index_set = 1;
6896 else if (unformat (i, "sub_id %d", &sub_id))
6898 else if (unformat (i, "outer_vlan_id %d", &tmp))
6899 outer_vlan_id = tmp;
6900 else if (unformat (i, "inner_vlan_id %d", &tmp))
6901 inner_vlan_id = tmp;
6903 #define _(a) else if (unformat (i, #a)) a = 1 ;
6904 foreach_create_subif_bit
6908 clib_warning ("parse error '%U'", format_unformat_error, i);
6913 if (sw_if_index_set == 0)
6915 errmsg ("missing interface name or sw_if_index\n");
6919 if (sub_id_set == 0)
6921 errmsg ("missing sub_id\n");
6924 M (CREATE_SUBIF, create_subif);
6926 mp->sw_if_index = ntohl (sw_if_index);
6927 mp->sub_id = ntohl (sub_id);
6929 #define _(a) mp->a = a;
6930 foreach_create_subif_bit;
6933 mp->outer_vlan_id = ntohs (outer_vlan_id);
6934 mp->inner_vlan_id = ntohs (inner_vlan_id);
6943 api_oam_add_del (vat_main_t * vam)
6945 unformat_input_t *i = vam->input;
6946 vl_api_oam_add_del_t *mp;
6950 ip4_address_t src, dst;
6954 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6956 if (unformat (i, "vrf %d", &vrf_id))
6958 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6960 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6962 else if (unformat (i, "del"))
6966 clib_warning ("parse error '%U'", format_unformat_error, i);
6973 errmsg ("missing src addr\n");
6979 errmsg ("missing dst addr\n");
6983 M (OAM_ADD_DEL, oam_add_del);
6985 mp->vrf_id = ntohl (vrf_id);
6986 mp->is_add = is_add;
6987 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6988 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6997 api_reset_fib (vat_main_t * vam)
6999 unformat_input_t *i = vam->input;
7000 vl_api_reset_fib_t *mp;
7006 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7008 if (unformat (i, "vrf %d", &vrf_id))
7010 else if (unformat (i, "ipv6"))
7014 clib_warning ("parse error '%U'", format_unformat_error, i);
7019 if (vrf_id_set == 0)
7021 errmsg ("missing vrf id\n");
7025 M (RESET_FIB, reset_fib);
7027 mp->vrf_id = ntohl (vrf_id);
7028 mp->is_ipv6 = is_ipv6;
7037 api_dhcp_proxy_config (vat_main_t * vam)
7039 unformat_input_t *i = vam->input;
7040 vl_api_dhcp_proxy_config_t *mp;
7045 u8 v4_address_set = 0;
7046 u8 v6_address_set = 0;
7047 ip4_address_t v4address;
7048 ip6_address_t v6address;
7049 u8 v4_src_address_set = 0;
7050 u8 v6_src_address_set = 0;
7051 ip4_address_t v4srcaddress;
7052 ip6_address_t v6srcaddress;
7054 /* Parse args required to build the message */
7055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7057 if (unformat (i, "del"))
7059 else if (unformat (i, "vrf %d", &vrf_id))
7061 else if (unformat (i, "insert-cid %d", &insert_cid))
7063 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7065 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7067 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7068 v4_src_address_set = 1;
7069 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7070 v6_src_address_set = 1;
7075 if (v4_address_set && v6_address_set)
7077 errmsg ("both v4 and v6 server addresses set\n");
7080 if (!v4_address_set && !v6_address_set)
7082 errmsg ("no server addresses set\n");
7086 if (v4_src_address_set && v6_src_address_set)
7088 errmsg ("both v4 and v6 src addresses set\n");
7091 if (!v4_src_address_set && !v6_src_address_set)
7093 errmsg ("no src addresses set\n");
7097 if (!(v4_src_address_set && v4_address_set) &&
7098 !(v6_src_address_set && v6_address_set))
7100 errmsg ("no matching server and src addresses set\n");
7104 /* Construct the API message */
7105 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7107 mp->insert_circuit_id = insert_cid;
7108 mp->is_add = is_add;
7109 mp->vrf_id = ntohl (vrf_id);
7113 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7114 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7118 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7119 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7125 /* Wait for a reply, return good/bad news */
7132 api_dhcp_proxy_config_2 (vat_main_t * vam)
7134 unformat_input_t *i = vam->input;
7135 vl_api_dhcp_proxy_config_2_t *mp;
7138 u32 server_vrf_id = 0;
7141 u8 v4_address_set = 0;
7142 u8 v6_address_set = 0;
7143 ip4_address_t v4address;
7144 ip6_address_t v6address;
7145 u8 v4_src_address_set = 0;
7146 u8 v6_src_address_set = 0;
7147 ip4_address_t v4srcaddress;
7148 ip6_address_t v6srcaddress;
7150 /* Parse args required to build the message */
7151 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7153 if (unformat (i, "del"))
7155 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7157 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7159 else if (unformat (i, "insert-cid %d", &insert_cid))
7161 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7163 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7165 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7166 v4_src_address_set = 1;
7167 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7168 v6_src_address_set = 1;
7173 if (v4_address_set && v6_address_set)
7175 errmsg ("both v4 and v6 server addresses set\n");
7178 if (!v4_address_set && !v6_address_set)
7180 errmsg ("no server addresses set\n");
7184 if (v4_src_address_set && v6_src_address_set)
7186 errmsg ("both v4 and v6 src addresses set\n");
7189 if (!v4_src_address_set && !v6_src_address_set)
7191 errmsg ("no src addresses set\n");
7195 if (!(v4_src_address_set && v4_address_set) &&
7196 !(v6_src_address_set && v6_address_set))
7198 errmsg ("no matching server and src addresses set\n");
7202 /* Construct the API message */
7203 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7205 mp->insert_circuit_id = insert_cid;
7206 mp->is_add = is_add;
7207 mp->rx_vrf_id = ntohl (rx_vrf_id);
7208 mp->server_vrf_id = ntohl (server_vrf_id);
7212 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7213 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7217 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7218 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7224 /* Wait for a reply, return good/bad news */
7231 api_dhcp_proxy_set_vss (vat_main_t * vam)
7233 unformat_input_t *i = vam->input;
7234 vl_api_dhcp_proxy_set_vss_t *mp;
7245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7247 if (unformat (i, "tbl_id %d", &tbl_id))
7249 if (unformat (i, "fib_id %d", &fib_id))
7251 if (unformat (i, "oui %d", &oui))
7253 else if (unformat (i, "ipv6"))
7255 else if (unformat (i, "del"))
7259 clib_warning ("parse error '%U'", format_unformat_error, i);
7264 if (tbl_id_set == 0)
7266 errmsg ("missing tbl id\n");
7270 if (fib_id_set == 0)
7272 errmsg ("missing fib id\n");
7277 errmsg ("missing oui\n");
7281 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7282 mp->tbl_id = ntohl (tbl_id);
7283 mp->fib_id = ntohl (fib_id);
7284 mp->oui = ntohl (oui);
7285 mp->is_ipv6 = is_ipv6;
7286 mp->is_add = is_add;
7295 api_dhcp_client_config (vat_main_t * vam)
7297 unformat_input_t *i = vam->input;
7298 vl_api_dhcp_client_config_t *mp;
7301 u8 sw_if_index_set = 0;
7304 u8 disable_event = 0;
7306 /* Parse args required to build the message */
7307 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7309 if (unformat (i, "del"))
7311 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7312 sw_if_index_set = 1;
7313 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7314 sw_if_index_set = 1;
7315 else if (unformat (i, "hostname %s", &hostname))
7317 else if (unformat (i, "disable_event"))
7323 if (sw_if_index_set == 0)
7325 errmsg ("missing interface name or sw_if_index\n");
7329 if (vec_len (hostname) > 63)
7331 errmsg ("hostname too long\n");
7333 vec_add1 (hostname, 0);
7335 /* Construct the API message */
7336 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7338 mp->sw_if_index = ntohl (sw_if_index);
7339 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7340 vec_free (hostname);
7341 mp->is_add = is_add;
7342 mp->want_dhcp_event = disable_event ? 0 : 1;
7343 mp->pid = getpid ();
7348 /* Wait for a reply, return good/bad news */
7355 api_set_ip_flow_hash (vat_main_t * vam)
7357 unformat_input_t *i = vam->input;
7358 vl_api_set_ip_flow_hash_t *mp;
7370 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7372 if (unformat (i, "vrf %d", &vrf_id))
7374 else if (unformat (i, "ipv6"))
7376 else if (unformat (i, "src"))
7378 else if (unformat (i, "dst"))
7380 else if (unformat (i, "sport"))
7382 else if (unformat (i, "dport"))
7384 else if (unformat (i, "proto"))
7386 else if (unformat (i, "reverse"))
7391 clib_warning ("parse error '%U'", format_unformat_error, i);
7396 if (vrf_id_set == 0)
7398 errmsg ("missing vrf id\n");
7402 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7408 mp->reverse = reverse;
7409 mp->vrf_id = ntohl (vrf_id);
7410 mp->is_ipv6 = is_ipv6;
7419 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7421 unformat_input_t *i = vam->input;
7422 vl_api_sw_interface_ip6_enable_disable_t *mp;
7425 u8 sw_if_index_set = 0;
7428 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7430 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7431 sw_if_index_set = 1;
7432 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7433 sw_if_index_set = 1;
7434 else if (unformat (i, "enable"))
7436 else if (unformat (i, "disable"))
7440 clib_warning ("parse error '%U'", format_unformat_error, i);
7445 if (sw_if_index_set == 0)
7447 errmsg ("missing interface name or sw_if_index\n");
7451 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
7453 mp->sw_if_index = ntohl (sw_if_index);
7454 mp->enable = enable;
7463 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7465 unformat_input_t *i = vam->input;
7466 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7469 u8 sw_if_index_set = 0;
7470 u32 address_length = 0;
7471 u8 v6_address_set = 0;
7472 ip6_address_t v6address;
7474 /* Parse args required to build the message */
7475 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7477 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7478 sw_if_index_set = 1;
7479 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7480 sw_if_index_set = 1;
7481 else if (unformat (i, "%U/%d",
7482 unformat_ip6_address, &v6address, &address_length))
7488 if (sw_if_index_set == 0)
7490 errmsg ("missing interface name or sw_if_index\n");
7493 if (!v6_address_set)
7495 errmsg ("no address set\n");
7499 /* Construct the API message */
7500 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
7501 sw_interface_ip6_set_link_local_address);
7503 mp->sw_if_index = ntohl (sw_if_index);
7504 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7505 mp->address_length = address_length;
7510 /* Wait for a reply, return good/bad news */
7519 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7521 unformat_input_t *i = vam->input;
7522 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7525 u8 sw_if_index_set = 0;
7526 u32 address_length = 0;
7527 u8 v6_address_set = 0;
7528 ip6_address_t v6address;
7530 u8 no_advertise = 0;
7532 u8 no_autoconfig = 0;
7535 u32 val_lifetime = 0;
7536 u32 pref_lifetime = 0;
7538 /* Parse args required to build the message */
7539 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7541 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7542 sw_if_index_set = 1;
7543 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7544 sw_if_index_set = 1;
7545 else if (unformat (i, "%U/%d",
7546 unformat_ip6_address, &v6address, &address_length))
7548 else if (unformat (i, "val_life %d", &val_lifetime))
7550 else if (unformat (i, "pref_life %d", &pref_lifetime))
7552 else if (unformat (i, "def"))
7554 else if (unformat (i, "noadv"))
7556 else if (unformat (i, "offl"))
7558 else if (unformat (i, "noauto"))
7560 else if (unformat (i, "nolink"))
7562 else if (unformat (i, "isno"))
7566 clib_warning ("parse error '%U'", format_unformat_error, i);
7571 if (sw_if_index_set == 0)
7573 errmsg ("missing interface name or sw_if_index\n");
7576 if (!v6_address_set)
7578 errmsg ("no address set\n");
7582 /* Construct the API message */
7583 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
7585 mp->sw_if_index = ntohl (sw_if_index);
7586 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7587 mp->address_length = address_length;
7588 mp->use_default = use_default;
7589 mp->no_advertise = no_advertise;
7590 mp->off_link = off_link;
7591 mp->no_autoconfig = no_autoconfig;
7592 mp->no_onlink = no_onlink;
7594 mp->val_lifetime = ntohl (val_lifetime);
7595 mp->pref_lifetime = ntohl (pref_lifetime);
7600 /* Wait for a reply, return good/bad news */
7608 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7610 unformat_input_t *i = vam->input;
7611 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7614 u8 sw_if_index_set = 0;
7619 u8 send_unicast = 0;
7622 u8 default_router = 0;
7623 u32 max_interval = 0;
7624 u32 min_interval = 0;
7626 u32 initial_count = 0;
7627 u32 initial_interval = 0;
7630 /* Parse args required to build the message */
7631 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7633 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7634 sw_if_index_set = 1;
7635 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7636 sw_if_index_set = 1;
7637 else if (unformat (i, "maxint %d", &max_interval))
7639 else if (unformat (i, "minint %d", &min_interval))
7641 else if (unformat (i, "life %d", &lifetime))
7643 else if (unformat (i, "count %d", &initial_count))
7645 else if (unformat (i, "interval %d", &initial_interval))
7647 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7649 else if (unformat (i, "managed"))
7651 else if (unformat (i, "other"))
7653 else if (unformat (i, "ll"))
7655 else if (unformat (i, "send"))
7657 else if (unformat (i, "cease"))
7659 else if (unformat (i, "isno"))
7661 else if (unformat (i, "def"))
7665 clib_warning ("parse error '%U'", format_unformat_error, i);
7670 if (sw_if_index_set == 0)
7672 errmsg ("missing interface name or sw_if_index\n");
7676 /* Construct the API message */
7677 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7679 mp->sw_if_index = ntohl (sw_if_index);
7680 mp->max_interval = ntohl (max_interval);
7681 mp->min_interval = ntohl (min_interval);
7682 mp->lifetime = ntohl (lifetime);
7683 mp->initial_count = ntohl (initial_count);
7684 mp->initial_interval = ntohl (initial_interval);
7685 mp->suppress = suppress;
7686 mp->managed = managed;
7688 mp->ll_option = ll_option;
7689 mp->send_unicast = send_unicast;
7692 mp->default_router = default_router;
7697 /* Wait for a reply, return good/bad news */
7705 api_set_arp_neighbor_limit (vat_main_t * vam)
7707 unformat_input_t *i = vam->input;
7708 vl_api_set_arp_neighbor_limit_t *mp;
7714 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7716 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7718 else if (unformat (i, "ipv6"))
7722 clib_warning ("parse error '%U'", format_unformat_error, i);
7729 errmsg ("missing limit value\n");
7733 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7735 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7736 mp->is_ipv6 = is_ipv6;
7745 api_l2_patch_add_del (vat_main_t * vam)
7747 unformat_input_t *i = vam->input;
7748 vl_api_l2_patch_add_del_t *mp;
7751 u8 rx_sw_if_index_set = 0;
7753 u8 tx_sw_if_index_set = 0;
7756 /* Parse args required to build the message */
7757 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7759 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7760 rx_sw_if_index_set = 1;
7761 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7762 tx_sw_if_index_set = 1;
7763 else if (unformat (i, "rx"))
7765 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7767 if (unformat (i, "%U", unformat_sw_if_index, vam,
7769 rx_sw_if_index_set = 1;
7774 else if (unformat (i, "tx"))
7776 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7778 if (unformat (i, "%U", unformat_sw_if_index, vam,
7780 tx_sw_if_index_set = 1;
7785 else if (unformat (i, "del"))
7791 if (rx_sw_if_index_set == 0)
7793 errmsg ("missing rx interface name or rx_sw_if_index\n");
7797 if (tx_sw_if_index_set == 0)
7799 errmsg ("missing tx interface name or tx_sw_if_index\n");
7803 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7805 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7806 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7807 mp->is_add = is_add;
7816 api_ioam_enable (vat_main_t * vam)
7818 unformat_input_t *input = vam->input;
7819 vl_api_ioam_enable_t *mp;
7822 int has_trace_option = 0;
7823 int has_pot_option = 0;
7824 int has_seqno_option = 0;
7825 int has_analyse_option = 0;
7827 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7829 if (unformat (input, "trace"))
7830 has_trace_option = 1;
7831 else if (unformat (input, "pot"))
7833 else if (unformat (input, "seqno"))
7834 has_seqno_option = 1;
7835 else if (unformat (input, "analyse"))
7836 has_analyse_option = 1;
7840 M (IOAM_ENABLE, ioam_enable);
7841 mp->id = htons (id);
7842 mp->seqno = has_seqno_option;
7843 mp->analyse = has_analyse_option;
7844 mp->pot_enable = has_pot_option;
7845 mp->trace_enable = has_trace_option;
7856 api_ioam_disable (vat_main_t * vam)
7858 vl_api_ioam_disable_t *mp;
7861 M (IOAM_DISABLE, ioam_disable);
7868 api_sr_tunnel_add_del (vat_main_t * vam)
7870 unformat_input_t *i = vam->input;
7871 vl_api_sr_tunnel_add_del_t *mp;
7875 ip6_address_t src_address;
7876 int src_address_set = 0;
7877 ip6_address_t dst_address;
7879 int dst_address_set = 0;
7881 u32 rx_table_id = 0;
7882 u32 tx_table_id = 0;
7883 ip6_address_t *segments = 0;
7884 ip6_address_t *this_seg;
7885 ip6_address_t *tags = 0;
7886 ip6_address_t *this_tag;
7887 ip6_address_t next_address, tag;
7889 u8 *policy_name = 0;
7891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7893 if (unformat (i, "del"))
7895 else if (unformat (i, "name %s", &name))
7897 else if (unformat (i, "policy %s", &policy_name))
7899 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7901 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7903 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7904 src_address_set = 1;
7905 else if (unformat (i, "dst %U/%d",
7906 unformat_ip6_address, &dst_address, &dst_mask_width))
7907 dst_address_set = 1;
7908 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7910 vec_add2 (segments, this_seg, 1);
7911 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7912 sizeof (*this_seg));
7914 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7916 vec_add2 (tags, this_tag, 1);
7917 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7919 else if (unformat (i, "clean"))
7920 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7921 else if (unformat (i, "protected"))
7922 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7923 else if (unformat (i, "InPE %d", &pl_index))
7925 if (pl_index <= 0 || pl_index > 4)
7927 pl_index_range_error:
7928 errmsg ("pl index %d out of range\n", pl_index);
7932 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7934 else if (unformat (i, "EgPE %d", &pl_index))
7936 if (pl_index <= 0 || pl_index > 4)
7937 goto pl_index_range_error;
7939 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7941 else if (unformat (i, "OrgSrc %d", &pl_index))
7943 if (pl_index <= 0 || pl_index > 4)
7944 goto pl_index_range_error;
7946 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7952 if (!src_address_set)
7954 errmsg ("src address required\n");
7958 if (!dst_address_set)
7960 errmsg ("dst address required\n");
7966 errmsg ("at least one sr segment required\n");
7970 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7971 vec_len (segments) * sizeof (ip6_address_t)
7972 + vec_len (tags) * sizeof (ip6_address_t));
7974 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7975 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7976 mp->dst_mask_width = dst_mask_width;
7977 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7978 mp->n_segments = vec_len (segments);
7979 mp->n_tags = vec_len (tags);
7980 mp->is_add = is_del == 0;
7981 clib_memcpy (mp->segs_and_tags, segments,
7982 vec_len (segments) * sizeof (ip6_address_t));
7983 clib_memcpy (mp->segs_and_tags +
7984 vec_len (segments) * sizeof (ip6_address_t), tags,
7985 vec_len (tags) * sizeof (ip6_address_t));
7987 mp->outer_vrf_id = ntohl (rx_table_id);
7988 mp->inner_vrf_id = ntohl (tx_table_id);
7989 memcpy (mp->name, name, vec_len (name));
7990 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7992 vec_free (segments);
8001 api_sr_policy_add_del (vat_main_t * vam)
8003 unformat_input_t *input = vam->input;
8004 vl_api_sr_policy_add_del_t *mp;
8008 u8 *tunnel_name = 0;
8009 u8 **tunnel_names = 0;
8014 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8015 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8017 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8019 if (unformat (input, "del"))
8021 else if (unformat (input, "name %s", &name))
8023 else if (unformat (input, "tunnel %s", &tunnel_name))
8027 vec_add1 (tunnel_names, tunnel_name);
8029 - length = #bytes to store in serial vector
8030 - +1 = byte to store that length
8032 tunnel_names_length += (vec_len (tunnel_name) + 1);
8043 errmsg ("policy name required\n");
8047 if ((!tunnel_set) && (!is_del))
8049 errmsg ("tunnel name required\n");
8053 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
8057 mp->is_add = !is_del;
8059 memcpy (mp->name, name, vec_len (name));
8060 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8061 u8 *serial_orig = 0;
8062 vec_validate (serial_orig, tunnel_names_length);
8063 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8064 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8066 for (j = 0; j < vec_len (tunnel_names); j++)
8068 tun_name_len = vec_len (tunnel_names[j]);
8069 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8070 serial_orig += 1; // Move along one byte to store the actual tunnel name
8071 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8072 serial_orig += tun_name_len; // Advance past the copy
8074 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8076 vec_free (tunnel_names);
8077 vec_free (tunnel_name);
8085 api_sr_multicast_map_add_del (vat_main_t * vam)
8087 unformat_input_t *input = vam->input;
8088 vl_api_sr_multicast_map_add_del_t *mp;
8091 ip6_address_t multicast_address;
8092 u8 *policy_name = 0;
8093 int multicast_address_set = 0;
8095 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8097 if (unformat (input, "del"))
8101 (input, "address %U", unformat_ip6_address, &multicast_address))
8102 multicast_address_set = 1;
8103 else if (unformat (input, "sr-policy %s", &policy_name))
8109 if (!is_del && !policy_name)
8111 errmsg ("sr-policy name required\n");
8116 if (!multicast_address_set)
8118 errmsg ("address required\n");
8122 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8124 mp->is_add = !is_del;
8125 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8126 clib_memcpy (mp->multicast_address, &multicast_address,
8127 sizeof (mp->multicast_address));
8130 vec_free (policy_name);
8138 #define foreach_tcp_proto_field \
8142 #define foreach_udp_proto_field \
8146 #define foreach_ip4_proto_field \
8157 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8159 u8 **maskp = va_arg (*args, u8 **);
8161 u8 found_something = 0;
8164 #define _(a) u8 a=0;
8165 foreach_tcp_proto_field;
8168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8171 #define _(a) else if (unformat (input, #a)) a=1;
8172 foreach_tcp_proto_field
8178 #define _(a) found_something += a;
8179 foreach_tcp_proto_field;
8182 if (found_something == 0)
8185 vec_validate (mask, sizeof (*tcp) - 1);
8187 tcp = (tcp_header_t *) mask;
8189 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8190 foreach_tcp_proto_field;
8198 unformat_udp_mask (unformat_input_t * input, va_list * args)
8200 u8 **maskp = va_arg (*args, u8 **);
8202 u8 found_something = 0;
8205 #define _(a) u8 a=0;
8206 foreach_udp_proto_field;
8209 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8212 #define _(a) else if (unformat (input, #a)) a=1;
8213 foreach_udp_proto_field
8219 #define _(a) found_something += a;
8220 foreach_udp_proto_field;
8223 if (found_something == 0)
8226 vec_validate (mask, sizeof (*udp) - 1);
8228 udp = (udp_header_t *) mask;
8230 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8231 foreach_udp_proto_field;
8240 u16 src_port, dst_port;
8244 unformat_l4_mask (unformat_input_t * input, va_list * args)
8246 u8 **maskp = va_arg (*args, u8 **);
8247 u16 src_port = 0, dst_port = 0;
8248 tcpudp_header_t *tcpudp;
8250 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8252 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8254 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8256 else if (unformat (input, "src_port"))
8258 else if (unformat (input, "dst_port"))
8264 if (!src_port && !dst_port)
8268 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8270 tcpudp = (tcpudp_header_t *) mask;
8271 tcpudp->src_port = src_port;
8272 tcpudp->dst_port = dst_port;
8280 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8282 u8 **maskp = va_arg (*args, u8 **);
8284 u8 found_something = 0;
8287 #define _(a) u8 a=0;
8288 foreach_ip4_proto_field;
8294 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8296 if (unformat (input, "version"))
8298 else if (unformat (input, "hdr_length"))
8300 else if (unformat (input, "src"))
8302 else if (unformat (input, "dst"))
8304 else if (unformat (input, "proto"))
8307 #define _(a) else if (unformat (input, #a)) a=1;
8308 foreach_ip4_proto_field
8314 #define _(a) found_something += a;
8315 foreach_ip4_proto_field;
8318 if (found_something == 0)
8321 vec_validate (mask, sizeof (*ip) - 1);
8323 ip = (ip4_header_t *) mask;
8325 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8326 foreach_ip4_proto_field;
8329 ip->ip_version_and_header_length = 0;
8332 ip->ip_version_and_header_length |= 0xF0;
8335 ip->ip_version_and_header_length |= 0x0F;
8341 #define foreach_ip6_proto_field \
8349 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8351 u8 **maskp = va_arg (*args, u8 **);
8353 u8 found_something = 0;
8355 u32 ip_version_traffic_class_and_flow_label;
8357 #define _(a) u8 a=0;
8358 foreach_ip6_proto_field;
8361 u8 traffic_class = 0;
8364 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8366 if (unformat (input, "version"))
8368 else if (unformat (input, "traffic-class"))
8370 else if (unformat (input, "flow-label"))
8372 else if (unformat (input, "src"))
8374 else if (unformat (input, "dst"))
8376 else if (unformat (input, "proto"))
8379 #define _(a) else if (unformat (input, #a)) a=1;
8380 foreach_ip6_proto_field
8386 #define _(a) found_something += a;
8387 foreach_ip6_proto_field;
8390 if (found_something == 0)
8393 vec_validate (mask, sizeof (*ip) - 1);
8395 ip = (ip6_header_t *) mask;
8397 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8398 foreach_ip6_proto_field;
8401 ip_version_traffic_class_and_flow_label = 0;
8404 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8407 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8410 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8412 ip->ip_version_traffic_class_and_flow_label =
8413 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8420 unformat_l3_mask (unformat_input_t * input, va_list * args)
8422 u8 **maskp = va_arg (*args, u8 **);
8424 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8426 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8428 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8437 unformat_l2_mask (unformat_input_t * input, va_list * args)
8439 u8 **maskp = va_arg (*args, u8 **);
8454 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8456 if (unformat (input, "src"))
8458 else if (unformat (input, "dst"))
8460 else if (unformat (input, "proto"))
8462 else if (unformat (input, "tag1"))
8464 else if (unformat (input, "tag2"))
8466 else if (unformat (input, "ignore-tag1"))
8468 else if (unformat (input, "ignore-tag2"))
8470 else if (unformat (input, "cos1"))
8472 else if (unformat (input, "cos2"))
8474 else if (unformat (input, "dot1q"))
8476 else if (unformat (input, "dot1ad"))
8481 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8482 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8485 if (tag1 || ignore_tag1 || cos1 || dot1q)
8487 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8490 vec_validate (mask, len - 1);
8493 memset (mask, 0xff, 6);
8496 memset (mask + 6, 0xff, 6);
8500 /* inner vlan tag */
8509 mask[21] = mask[20] = 0xff;
8530 mask[16] = mask[17] = 0xff;
8540 mask[12] = mask[13] = 0xff;
8547 unformat_classify_mask (unformat_input_t * input, va_list * args)
8549 u8 **maskp = va_arg (*args, u8 **);
8550 u32 *skipp = va_arg (*args, u32 *);
8551 u32 *matchp = va_arg (*args, u32 *);
8559 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8561 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8563 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8565 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8567 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8581 if (mask || l2 || l3 || l4)
8585 /* "With a free Ethernet header in every package" */
8587 vec_validate (l2, 13);
8591 vec_append (mask, l3);
8596 vec_append (mask, l4);
8601 /* Scan forward looking for the first significant mask octet */
8602 for (i = 0; i < vec_len (mask); i++)
8606 /* compute (skip, match) params */
8607 *skipp = i / sizeof (u32x4);
8608 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8610 /* Pad mask to an even multiple of the vector size */
8611 while (vec_len (mask) % sizeof (u32x4))
8614 match = vec_len (mask) / sizeof (u32x4);
8616 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8618 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8619 if (*tmp || *(tmp + 1))
8624 clib_warning ("BUG: match 0");
8626 _vec_len (mask) = match * sizeof (u32x4);
8637 #define foreach_l2_next \
8639 _(ethernet, ETHERNET_INPUT) \
8644 unformat_l2_next_index (unformat_input_t * input, va_list * args)
8646 u32 *miss_next_indexp = va_arg (*args, u32 *);
8651 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8655 if (unformat (input, "%d", &tmp))
8664 *miss_next_indexp = next_index;
8668 #define foreach_ip_next \
8674 unformat_ip_next_index (unformat_input_t * input, va_list * args)
8676 u32 *miss_next_indexp = va_arg (*args, u32 *);
8681 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8685 if (unformat (input, "%d", &tmp))
8694 *miss_next_indexp = next_index;
8698 #define foreach_acl_next \
8702 unformat_acl_next_index (unformat_input_t * input, va_list * args)
8704 u32 *miss_next_indexp = va_arg (*args, u32 *);
8709 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8713 if (unformat (input, "permit"))
8718 else if (unformat (input, "%d", &tmp))
8727 *miss_next_indexp = next_index;
8732 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8734 u32 *r = va_arg (*args, u32 *);
8736 if (unformat (input, "conform-color"))
8737 *r = POLICE_CONFORM;
8738 else if (unformat (input, "exceed-color"))
8747 api_classify_add_del_table (vat_main_t * vam)
8749 unformat_input_t *i = vam->input;
8750 vl_api_classify_add_del_table_t *mp;
8756 u32 table_index = ~0;
8757 u32 next_table_index = ~0;
8758 u32 miss_next_index = ~0;
8759 u32 memory_size = 32 << 20;
8762 u32 current_data_flag = 0;
8763 int current_data_offset = 0;
8765 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8767 if (unformat (i, "del"))
8769 else if (unformat (i, "buckets %d", &nbuckets))
8771 else if (unformat (i, "memory_size %d", &memory_size))
8773 else if (unformat (i, "skip %d", &skip))
8775 else if (unformat (i, "match %d", &match))
8777 else if (unformat (i, "table %d", &table_index))
8779 else if (unformat (i, "mask %U", unformat_classify_mask,
8780 &mask, &skip, &match))
8782 else if (unformat (i, "next-table %d", &next_table_index))
8784 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8787 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8790 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8793 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
8795 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
8801 if (is_add && mask == 0)
8803 errmsg ("Mask required\n");
8807 if (is_add && skip == ~0)
8809 errmsg ("skip count required\n");
8813 if (is_add && match == ~0)
8815 errmsg ("match count required\n");
8819 if (!is_add && table_index == ~0)
8821 errmsg ("table index required for delete\n");
8825 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8827 mp->is_add = is_add;
8828 mp->table_index = ntohl (table_index);
8829 mp->nbuckets = ntohl (nbuckets);
8830 mp->memory_size = ntohl (memory_size);
8831 mp->skip_n_vectors = ntohl (skip);
8832 mp->match_n_vectors = ntohl (match);
8833 mp->next_table_index = ntohl (next_table_index);
8834 mp->miss_next_index = ntohl (miss_next_index);
8835 mp->current_data_flag = ntohl (current_data_flag);
8836 mp->current_data_offset = ntohl (current_data_offset);
8837 clib_memcpy (mp->mask, mask, vec_len (mask));
8847 unformat_l4_match (unformat_input_t * input, va_list * args)
8849 u8 **matchp = va_arg (*args, u8 **);
8851 u8 *proto_header = 0;
8857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8859 if (unformat (input, "src_port %d", &src_port))
8861 else if (unformat (input, "dst_port %d", &dst_port))
8867 h.src_port = clib_host_to_net_u16 (src_port);
8868 h.dst_port = clib_host_to_net_u16 (dst_port);
8869 vec_validate (proto_header, sizeof (h) - 1);
8870 memcpy (proto_header, &h, sizeof (h));
8872 *matchp = proto_header;
8878 unformat_ip4_match (unformat_input_t * input, va_list * args)
8880 u8 **matchp = va_arg (*args, u8 **);
8887 int src = 0, dst = 0;
8888 ip4_address_t src_val, dst_val;
8895 int fragment_id = 0;
8896 u32 fragment_id_val;
8902 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8904 if (unformat (input, "version %d", &version_val))
8906 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8908 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8910 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8912 else if (unformat (input, "proto %d", &proto_val))
8914 else if (unformat (input, "tos %d", &tos_val))
8916 else if (unformat (input, "length %d", &length_val))
8918 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8920 else if (unformat (input, "ttl %d", &ttl_val))
8922 else if (unformat (input, "checksum %d", &checksum_val))
8928 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8929 + ttl + checksum == 0)
8933 * Aligned because we use the real comparison functions
8935 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8937 ip = (ip4_header_t *) match;
8939 /* These are realistically matched in practice */
8941 ip->src_address.as_u32 = src_val.as_u32;
8944 ip->dst_address.as_u32 = dst_val.as_u32;
8947 ip->protocol = proto_val;
8950 /* These are not, but they're included for completeness */
8952 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8955 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8961 ip->length = clib_host_to_net_u16 (length_val);
8967 ip->checksum = clib_host_to_net_u16 (checksum_val);
8974 unformat_ip6_match (unformat_input_t * input, va_list * args)
8976 u8 **matchp = va_arg (*args, u8 **);
8981 u8 traffic_class = 0;
8982 u32 traffic_class_val = 0;
8985 int src = 0, dst = 0;
8986 ip6_address_t src_val, dst_val;
8989 int payload_length = 0;
8990 u32 payload_length_val;
8993 u32 ip_version_traffic_class_and_flow_label;
8995 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8997 if (unformat (input, "version %d", &version_val))
8999 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9001 else if (unformat (input, "flow_label %d", &flow_label_val))
9003 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9005 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9007 else if (unformat (input, "proto %d", &proto_val))
9009 else if (unformat (input, "payload_length %d", &payload_length_val))
9011 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9017 if (version + traffic_class + flow_label + src + dst + proto +
9018 payload_length + hop_limit == 0)
9022 * Aligned because we use the real comparison functions
9024 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9026 ip = (ip6_header_t *) match;
9029 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9032 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9035 ip->protocol = proto_val;
9037 ip_version_traffic_class_and_flow_label = 0;
9040 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9043 ip_version_traffic_class_and_flow_label |=
9044 (traffic_class_val & 0xFF) << 20;
9047 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9049 ip->ip_version_traffic_class_and_flow_label =
9050 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9053 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9056 ip->hop_limit = hop_limit_val;
9063 unformat_l3_match (unformat_input_t * input, va_list * args)
9065 u8 **matchp = va_arg (*args, u8 **);
9067 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9069 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9071 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9080 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9082 u8 *tagp = va_arg (*args, u8 *);
9085 if (unformat (input, "%d", &tag))
9087 tagp[0] = (tag >> 8) & 0x0F;
9088 tagp[1] = tag & 0xFF;
9096 unformat_l2_match (unformat_input_t * input, va_list * args)
9098 u8 **matchp = va_arg (*args, u8 **);
9118 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9120 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9123 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9125 else if (unformat (input, "proto %U",
9126 unformat_ethernet_type_host_byte_order, &proto_val))
9128 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9130 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9132 else if (unformat (input, "ignore-tag1"))
9134 else if (unformat (input, "ignore-tag2"))
9136 else if (unformat (input, "cos1 %d", &cos1_val))
9138 else if (unformat (input, "cos2 %d", &cos2_val))
9143 if ((src + dst + proto + tag1 + tag2 +
9144 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9147 if (tag1 || ignore_tag1 || cos1)
9149 if (tag2 || ignore_tag2 || cos2)
9152 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9155 clib_memcpy (match, dst_val, 6);
9158 clib_memcpy (match + 6, src_val, 6);
9162 /* inner vlan tag */
9163 match[19] = tag2_val[1];
9164 match[18] = tag2_val[0];
9166 match[18] |= (cos2_val & 0x7) << 5;
9169 match[21] = proto_val & 0xff;
9170 match[20] = proto_val >> 8;
9174 match[15] = tag1_val[1];
9175 match[14] = tag1_val[0];
9178 match[14] |= (cos1_val & 0x7) << 5;
9184 match[15] = tag1_val[1];
9185 match[14] = tag1_val[0];
9188 match[17] = proto_val & 0xff;
9189 match[16] = proto_val >> 8;
9192 match[14] |= (cos1_val & 0x7) << 5;
9198 match[18] |= (cos2_val & 0x7) << 5;
9200 match[14] |= (cos1_val & 0x7) << 5;
9203 match[13] = proto_val & 0xff;
9204 match[12] = proto_val >> 8;
9213 unformat_classify_match (unformat_input_t * input, va_list * args)
9215 u8 **matchp = va_arg (*args, u8 **);
9216 u32 skip_n_vectors = va_arg (*args, u32);
9217 u32 match_n_vectors = va_arg (*args, u32);
9224 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9226 if (unformat (input, "hex %U", unformat_hex_string, &match))
9228 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9230 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9232 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9246 if (match || l2 || l3 || l4)
9250 /* "Win a free Ethernet header in every packet" */
9252 vec_validate_aligned (l2, 13, sizeof (u32x4));
9256 vec_append_aligned (match, l3, sizeof (u32x4));
9261 vec_append_aligned (match, l4, sizeof (u32x4));
9266 /* Make sure the vector is big enough even if key is all 0's */
9267 vec_validate_aligned
9268 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9271 /* Set size, include skipped vectors */
9272 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9283 api_classify_add_del_session (vat_main_t * vam)
9285 unformat_input_t *i = vam->input;
9286 vl_api_classify_add_del_session_t *mp;
9288 u32 table_index = ~0;
9289 u32 hit_next_index = ~0;
9290 u32 opaque_index = ~0;
9294 u32 skip_n_vectors = 0;
9295 u32 match_n_vectors = 0;
9300 * Warning: you have to supply skip_n and match_n
9301 * because the API client cant simply look at the classify
9305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9307 if (unformat (i, "del"))
9309 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9312 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9315 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9318 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9320 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9322 else if (unformat (i, "opaque-index %d", &opaque_index))
9324 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9326 else if (unformat (i, "match_n %d", &match_n_vectors))
9328 else if (unformat (i, "match %U", unformat_classify_match,
9329 &match, skip_n_vectors, match_n_vectors))
9331 else if (unformat (i, "advance %d", &advance))
9333 else if (unformat (i, "table-index %d", &table_index))
9335 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9337 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9339 else if (unformat (i, "action %d", &action))
9341 else if (unformat (i, "metadata %d", &metadata))
9347 if (table_index == ~0)
9349 errmsg ("Table index required\n");
9353 if (is_add && match == 0)
9355 errmsg ("Match value required\n");
9359 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9361 mp->is_add = is_add;
9362 mp->table_index = ntohl (table_index);
9363 mp->hit_next_index = ntohl (hit_next_index);
9364 mp->opaque_index = ntohl (opaque_index);
9365 mp->advance = ntohl (advance);
9366 mp->action = action;
9367 mp->metadata = ntohl (metadata);
9368 clib_memcpy (mp->match, match, vec_len (match));
9377 api_classify_set_interface_ip_table (vat_main_t * vam)
9379 unformat_input_t *i = vam->input;
9380 vl_api_classify_set_interface_ip_table_t *mp;
9383 int sw_if_index_set;
9384 u32 table_index = ~0;
9387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9389 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9390 sw_if_index_set = 1;
9391 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9392 sw_if_index_set = 1;
9393 else if (unformat (i, "table %d", &table_index))
9397 clib_warning ("parse error '%U'", format_unformat_error, i);
9402 if (sw_if_index_set == 0)
9404 errmsg ("missing interface name or sw_if_index\n");
9409 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9411 mp->sw_if_index = ntohl (sw_if_index);
9412 mp->table_index = ntohl (table_index);
9413 mp->is_ipv6 = is_ipv6;
9422 api_classify_set_interface_l2_tables (vat_main_t * vam)
9424 unformat_input_t *i = vam->input;
9425 vl_api_classify_set_interface_l2_tables_t *mp;
9428 int sw_if_index_set;
9429 u32 ip4_table_index = ~0;
9430 u32 ip6_table_index = ~0;
9431 u32 other_table_index = ~0;
9434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9436 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9437 sw_if_index_set = 1;
9438 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9439 sw_if_index_set = 1;
9440 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9442 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9444 else if (unformat (i, "other-table %d", &other_table_index))
9446 else if (unformat (i, "is-input %d", &is_input))
9450 clib_warning ("parse error '%U'", format_unformat_error, i);
9455 if (sw_if_index_set == 0)
9457 errmsg ("missing interface name or sw_if_index\n");
9462 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
9464 mp->sw_if_index = ntohl (sw_if_index);
9465 mp->ip4_table_index = ntohl (ip4_table_index);
9466 mp->ip6_table_index = ntohl (ip6_table_index);
9467 mp->other_table_index = ntohl (other_table_index);
9468 mp->is_input = (u8) is_input;
9477 api_set_ipfix_exporter (vat_main_t * vam)
9479 unformat_input_t *i = vam->input;
9480 vl_api_set_ipfix_exporter_t *mp;
9481 ip4_address_t collector_address;
9482 u8 collector_address_set = 0;
9483 u32 collector_port = ~0;
9484 ip4_address_t src_address;
9485 u8 src_address_set = 0;
9488 u32 template_interval = ~0;
9489 u8 udp_checksum = 0;
9492 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9494 if (unformat (i, "collector_address %U", unformat_ip4_address,
9495 &collector_address))
9496 collector_address_set = 1;
9497 else if (unformat (i, "collector_port %d", &collector_port))
9499 else if (unformat (i, "src_address %U", unformat_ip4_address,
9501 src_address_set = 1;
9502 else if (unformat (i, "vrf_id %d", &vrf_id))
9504 else if (unformat (i, "path_mtu %d", &path_mtu))
9506 else if (unformat (i, "template_interval %d", &template_interval))
9508 else if (unformat (i, "udp_checksum"))
9514 if (collector_address_set == 0)
9516 errmsg ("collector_address required\n");
9520 if (src_address_set == 0)
9522 errmsg ("src_address required\n");
9526 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
9528 memcpy (mp->collector_address, collector_address.data,
9529 sizeof (collector_address.data));
9530 mp->collector_port = htons ((u16) collector_port);
9531 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9532 mp->vrf_id = htonl (vrf_id);
9533 mp->path_mtu = htonl (path_mtu);
9534 mp->template_interval = htonl (template_interval);
9535 mp->udp_checksum = udp_checksum;
9543 api_set_ipfix_classify_stream (vat_main_t * vam)
9545 unformat_input_t *i = vam->input;
9546 vl_api_set_ipfix_classify_stream_t *mp;
9548 u32 src_port = UDP_DST_PORT_ipfix;
9551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9553 if (unformat (i, "domain %d", &domain_id))
9555 else if (unformat (i, "src_port %d", &src_port))
9559 errmsg ("unknown input `%U'", format_unformat_error, i);
9564 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
9566 mp->domain_id = htonl (domain_id);
9567 mp->src_port = htons ((u16) src_port);
9575 api_ipfix_classify_table_add_del (vat_main_t * vam)
9577 unformat_input_t *i = vam->input;
9578 vl_api_ipfix_classify_table_add_del_t *mp;
9580 u32 classify_table_index = ~0;
9582 u8 transport_protocol = 255;
9585 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9587 if (unformat (i, "add"))
9589 else if (unformat (i, "del"))
9591 else if (unformat (i, "table %d", &classify_table_index))
9593 else if (unformat (i, "ip4"))
9595 else if (unformat (i, "ip6"))
9597 else if (unformat (i, "tcp"))
9598 transport_protocol = 6;
9599 else if (unformat (i, "udp"))
9600 transport_protocol = 17;
9603 errmsg ("unknown input `%U'", format_unformat_error, i);
9610 errmsg ("expecting: add|del");
9613 if (classify_table_index == ~0)
9615 errmsg ("classifier table not specified");
9618 if (ip_version == 0)
9620 errmsg ("IP version not specified");
9624 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
9626 mp->is_add = is_add;
9627 mp->table_id = htonl (classify_table_index);
9628 mp->ip_version = ip_version;
9629 mp->transport_protocol = transport_protocol;
9637 api_get_node_index (vat_main_t * vam)
9639 unformat_input_t *i = vam->input;
9640 vl_api_get_node_index_t *mp;
9644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9646 if (unformat (i, "node %s", &name))
9653 errmsg ("node name required\n");
9656 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9658 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9662 M (GET_NODE_INDEX, get_node_index);
9663 clib_memcpy (mp->node_name, name, vec_len (name));
9673 api_get_next_index (vat_main_t * vam)
9675 unformat_input_t *i = vam->input;
9676 vl_api_get_next_index_t *mp;
9678 u8 *node_name = 0, *next_node_name = 0;
9680 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9682 if (unformat (i, "node-name %s", &node_name))
9684 else if (unformat (i, "next-node-name %s", &next_node_name))
9690 errmsg ("node name required\n");
9693 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9695 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9699 if (next_node_name == 0)
9701 errmsg ("next node name required\n");
9704 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9706 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
9710 M (GET_NEXT_INDEX, get_next_index);
9711 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9712 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9713 vec_free (node_name);
9714 vec_free (next_node_name);
9723 api_add_node_next (vat_main_t * vam)
9725 unformat_input_t *i = vam->input;
9726 vl_api_add_node_next_t *mp;
9731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9733 if (unformat (i, "node %s", &name))
9735 else if (unformat (i, "next %s", &next))
9742 errmsg ("node name required\n");
9745 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9747 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9752 errmsg ("next node required\n");
9755 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9757 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
9761 M (ADD_NODE_NEXT, add_node_next);
9762 clib_memcpy (mp->node_name, name, vec_len (name));
9763 clib_memcpy (mp->next_name, next, vec_len (next));
9774 api_l2tpv3_create_tunnel (vat_main_t * vam)
9776 unformat_input_t *i = vam->input;
9777 ip6_address_t client_address, our_address;
9778 int client_address_set = 0;
9779 int our_address_set = 0;
9780 u32 local_session_id = 0;
9781 u32 remote_session_id = 0;
9782 u64 local_cookie = 0;
9783 u64 remote_cookie = 0;
9784 u8 l2_sublayer_present = 0;
9785 vl_api_l2tpv3_create_tunnel_t *mp;
9788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9790 if (unformat (i, "client_address %U", unformat_ip6_address,
9792 client_address_set = 1;
9793 else if (unformat (i, "our_address %U", unformat_ip6_address,
9795 our_address_set = 1;
9796 else if (unformat (i, "local_session_id %d", &local_session_id))
9798 else if (unformat (i, "remote_session_id %d", &remote_session_id))
9800 else if (unformat (i, "local_cookie %lld", &local_cookie))
9802 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
9804 else if (unformat (i, "l2-sublayer-present"))
9805 l2_sublayer_present = 1;
9810 if (client_address_set == 0)
9812 errmsg ("client_address required\n");
9816 if (our_address_set == 0)
9818 errmsg ("our_address required\n");
9822 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9824 clib_memcpy (mp->client_address, client_address.as_u8,
9825 sizeof (mp->client_address));
9827 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9829 mp->local_session_id = ntohl (local_session_id);
9830 mp->remote_session_id = ntohl (remote_session_id);
9831 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9832 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9833 mp->l2_sublayer_present = l2_sublayer_present;
9843 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9845 unformat_input_t *i = vam->input;
9847 u8 sw_if_index_set = 0;
9848 u64 new_local_cookie = 0;
9849 u64 new_remote_cookie = 0;
9850 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9855 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9856 sw_if_index_set = 1;
9857 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9858 sw_if_index_set = 1;
9859 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9861 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9867 if (sw_if_index_set == 0)
9869 errmsg ("missing interface name or sw_if_index\n");
9873 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9875 mp->sw_if_index = ntohl (sw_if_index);
9876 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9877 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9886 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9888 unformat_input_t *i = vam->input;
9889 vl_api_l2tpv3_interface_enable_disable_t *mp;
9892 u8 sw_if_index_set = 0;
9893 u8 enable_disable = 1;
9895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9897 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9898 sw_if_index_set = 1;
9899 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9900 sw_if_index_set = 1;
9901 else if (unformat (i, "enable"))
9903 else if (unformat (i, "disable"))
9909 if (sw_if_index_set == 0)
9911 errmsg ("missing interface name or sw_if_index\n");
9915 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9917 mp->sw_if_index = ntohl (sw_if_index);
9918 mp->enable_disable = enable_disable;
9927 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9929 unformat_input_t *i = vam->input;
9930 vl_api_l2tpv3_set_lookup_key_t *mp;
9934 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9936 if (unformat (i, "lookup_v6_src"))
9937 key = L2T_LOOKUP_SRC_ADDRESS;
9938 else if (unformat (i, "lookup_v6_dst"))
9939 key = L2T_LOOKUP_DST_ADDRESS;
9940 else if (unformat (i, "lookup_session_id"))
9941 key = L2T_LOOKUP_SESSION_ID;
9946 if (key == (u8) ~ 0)
9948 errmsg ("l2tp session lookup key unset\n");
9952 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9962 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9963 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9965 vat_main_t *vam = &vat_main;
9967 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9968 format_ip6_address, mp->our_address,
9969 format_ip6_address, mp->client_address,
9970 clib_net_to_host_u32 (mp->sw_if_index));
9973 " local cookies %016llx %016llx remote cookie %016llx\n",
9974 clib_net_to_host_u64 (mp->local_cookie[0]),
9975 clib_net_to_host_u64 (mp->local_cookie[1]),
9976 clib_net_to_host_u64 (mp->remote_cookie));
9978 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9979 clib_net_to_host_u32 (mp->local_session_id),
9980 clib_net_to_host_u32 (mp->remote_session_id));
9982 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9983 mp->l2_sublayer_present ? "preset" : "absent");
9987 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9988 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9990 vat_main_t *vam = &vat_main;
9991 vat_json_node_t *node = NULL;
9992 struct in6_addr addr;
9994 if (VAT_JSON_ARRAY != vam->json_tree.type)
9996 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9997 vat_json_init_array (&vam->json_tree);
9999 node = vat_json_array_add (&vam->json_tree);
10001 vat_json_init_object (node);
10003 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10004 vat_json_object_add_ip6 (node, "our_address", addr);
10005 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10006 vat_json_object_add_ip6 (node, "client_address", addr);
10008 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10009 vat_json_init_array (lc);
10010 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10011 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10012 vat_json_object_add_uint (node, "remote_cookie",
10013 clib_net_to_host_u64 (mp->remote_cookie));
10015 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10016 vat_json_object_add_uint (node, "local_session_id",
10017 clib_net_to_host_u32 (mp->local_session_id));
10018 vat_json_object_add_uint (node, "remote_session_id",
10019 clib_net_to_host_u32 (mp->remote_session_id));
10020 vat_json_object_add_string_copy (node, "l2_sublayer",
10021 mp->l2_sublayer_present ? (u8 *) "present"
10022 : (u8 *) "absent");
10026 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10028 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10031 /* Get list of l2tpv3-tunnel interfaces */
10032 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
10035 /* Use a control ping for synchronization */
10037 vl_api_control_ping_t *mp;
10038 M (CONTROL_PING, control_ping);
10045 static void vl_api_sw_interface_tap_details_t_handler
10046 (vl_api_sw_interface_tap_details_t * mp)
10048 vat_main_t *vam = &vat_main;
10050 fformat (vam->ofp, "%-16s %d\n",
10051 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10054 static void vl_api_sw_interface_tap_details_t_handler_json
10055 (vl_api_sw_interface_tap_details_t * mp)
10057 vat_main_t *vam = &vat_main;
10058 vat_json_node_t *node = NULL;
10060 if (VAT_JSON_ARRAY != vam->json_tree.type)
10062 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10063 vat_json_init_array (&vam->json_tree);
10065 node = vat_json_array_add (&vam->json_tree);
10067 vat_json_init_object (node);
10068 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10069 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10073 api_sw_interface_tap_dump (vat_main_t * vam)
10075 vl_api_sw_interface_tap_dump_t *mp;
10078 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
10079 /* Get list of tap interfaces */
10080 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
10083 /* Use a control ping for synchronization */
10085 vl_api_control_ping_t *mp;
10086 M (CONTROL_PING, control_ping);
10092 static uword unformat_vxlan_decap_next
10093 (unformat_input_t * input, va_list * args)
10095 u32 *result = va_arg (*args, u32 *);
10098 if (unformat (input, "l2"))
10099 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10100 else if (unformat (input, "%d", &tmp))
10108 api_vxlan_add_del_tunnel (vat_main_t * vam)
10110 unformat_input_t *line_input = vam->input;
10111 vl_api_vxlan_add_del_tunnel_t *mp;
10113 ip4_address_t src4, dst4;
10114 ip6_address_t src6, dst6;
10116 u8 ipv4_set = 0, ipv6_set = 0;
10119 u32 encap_vrf_id = 0;
10120 u32 decap_next_index = ~0;
10123 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10125 if (unformat (line_input, "del"))
10127 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10132 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10137 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
10142 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
10147 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10149 else if (unformat (line_input, "decap-next %U",
10150 unformat_vxlan_decap_next, &decap_next_index))
10152 else if (unformat (line_input, "vni %d", &vni))
10156 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10163 errmsg ("tunnel src address not specified\n");
10168 errmsg ("tunnel dst address not specified\n");
10172 if (ipv4_set && ipv6_set)
10174 errmsg ("both IPv4 and IPv6 addresses specified");
10178 if ((vni == 0) || (vni >> 24))
10180 errmsg ("vni not specified or out of range\n");
10184 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10188 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
10189 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
10193 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10194 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10196 mp->encap_vrf_id = ntohl (encap_vrf_id);
10197 mp->decap_next_index = ntohl (decap_next_index);
10198 mp->vni = ntohl (vni);
10199 mp->is_add = is_add;
10200 mp->is_ipv6 = ipv6_set;
10208 static void vl_api_vxlan_tunnel_details_t_handler
10209 (vl_api_vxlan_tunnel_details_t * mp)
10211 vat_main_t *vam = &vat_main;
10213 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
10214 ntohl (mp->sw_if_index),
10215 format_ip46_address, &(mp->src_address[0]),
10217 format_ip46_address, &(mp->dst_address[0]),
10219 ntohl (mp->encap_vrf_id),
10220 ntohl (mp->decap_next_index), ntohl (mp->vni));
10223 static void vl_api_vxlan_tunnel_details_t_handler_json
10224 (vl_api_vxlan_tunnel_details_t * mp)
10226 vat_main_t *vam = &vat_main;
10227 vat_json_node_t *node = NULL;
10228 struct in_addr ip4;
10229 struct in6_addr ip6;
10231 if (VAT_JSON_ARRAY != vam->json_tree.type)
10233 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10234 vat_json_init_array (&vam->json_tree);
10236 node = vat_json_array_add (&vam->json_tree);
10238 vat_json_init_object (node);
10239 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10242 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
10243 vat_json_object_add_ip6 (node, "src_address", ip6);
10244 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
10245 vat_json_object_add_ip6 (node, "dst_address", ip6);
10249 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
10250 vat_json_object_add_ip4 (node, "src_address", ip4);
10251 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
10252 vat_json_object_add_ip4 (node, "dst_address", ip4);
10254 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10255 vat_json_object_add_uint (node, "decap_next_index",
10256 ntohl (mp->decap_next_index));
10257 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10258 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10262 api_vxlan_tunnel_dump (vat_main_t * vam)
10264 unformat_input_t *i = vam->input;
10265 vl_api_vxlan_tunnel_dump_t *mp;
10268 u8 sw_if_index_set = 0;
10270 /* Parse args required to build the message */
10271 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10273 if (unformat (i, "sw_if_index %d", &sw_if_index))
10274 sw_if_index_set = 1;
10279 if (sw_if_index_set == 0)
10284 if (!vam->json_output)
10286 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
10287 "sw_if_index", "src_address", "dst_address",
10288 "encap_vrf_id", "decap_next_index", "vni");
10291 /* Get list of vxlan-tunnel interfaces */
10292 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10294 mp->sw_if_index = htonl (sw_if_index);
10298 /* Use a control ping for synchronization */
10300 vl_api_control_ping_t *mp;
10301 M (CONTROL_PING, control_ping);
10308 api_gre_add_del_tunnel (vat_main_t * vam)
10310 unformat_input_t *line_input = vam->input;
10311 vl_api_gre_add_del_tunnel_t *mp;
10313 ip4_address_t src4, dst4;
10318 u32 outer_fib_id = 0;
10320 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10322 if (unformat (line_input, "del"))
10324 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10326 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10328 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10330 else if (unformat (line_input, "teb"))
10334 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10341 errmsg ("tunnel src address not specified\n");
10346 errmsg ("tunnel dst address not specified\n");
10351 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10353 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10354 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10355 mp->outer_fib_id = ntohl (outer_fib_id);
10356 mp->is_add = is_add;
10365 static void vl_api_gre_tunnel_details_t_handler
10366 (vl_api_gre_tunnel_details_t * mp)
10368 vat_main_t *vam = &vat_main;
10370 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
10371 ntohl (mp->sw_if_index),
10372 format_ip4_address, &mp->src_address,
10373 format_ip4_address, &mp->dst_address,
10374 mp->teb, ntohl (mp->outer_fib_id));
10377 static void vl_api_gre_tunnel_details_t_handler_json
10378 (vl_api_gre_tunnel_details_t * mp)
10380 vat_main_t *vam = &vat_main;
10381 vat_json_node_t *node = NULL;
10382 struct in_addr ip4;
10384 if (VAT_JSON_ARRAY != vam->json_tree.type)
10386 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10387 vat_json_init_array (&vam->json_tree);
10389 node = vat_json_array_add (&vam->json_tree);
10391 vat_json_init_object (node);
10392 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10393 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10394 vat_json_object_add_ip4 (node, "src_address", ip4);
10395 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10396 vat_json_object_add_ip4 (node, "dst_address", ip4);
10397 vat_json_object_add_uint (node, "teb", mp->teb);
10398 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10402 api_gre_tunnel_dump (vat_main_t * vam)
10404 unformat_input_t *i = vam->input;
10405 vl_api_gre_tunnel_dump_t *mp;
10408 u8 sw_if_index_set = 0;
10410 /* Parse args required to build the message */
10411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10413 if (unformat (i, "sw_if_index %d", &sw_if_index))
10414 sw_if_index_set = 1;
10419 if (sw_if_index_set == 0)
10424 if (!vam->json_output)
10426 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
10427 "sw_if_index", "src_address", "dst_address", "teb",
10431 /* Get list of gre-tunnel interfaces */
10432 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
10434 mp->sw_if_index = htonl (sw_if_index);
10438 /* Use a control ping for synchronization */
10440 vl_api_control_ping_t *mp;
10441 M (CONTROL_PING, control_ping);
10448 api_l2_fib_clear_table (vat_main_t * vam)
10450 // unformat_input_t * i = vam->input;
10451 vl_api_l2_fib_clear_table_t *mp;
10454 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
10463 api_l2_interface_efp_filter (vat_main_t * vam)
10465 unformat_input_t *i = vam->input;
10466 vl_api_l2_interface_efp_filter_t *mp;
10470 u8 sw_if_index_set = 0;
10472 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10474 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10475 sw_if_index_set = 1;
10476 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10477 sw_if_index_set = 1;
10478 else if (unformat (i, "enable"))
10480 else if (unformat (i, "disable"))
10484 clib_warning ("parse error '%U'", format_unformat_error, i);
10489 if (sw_if_index_set == 0)
10491 errmsg ("missing sw_if_index\n");
10495 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
10497 mp->sw_if_index = ntohl (sw_if_index);
10498 mp->enable_disable = enable;
10506 #define foreach_vtr_op \
10507 _("disable", L2_VTR_DISABLED) \
10508 _("push-1", L2_VTR_PUSH_1) \
10509 _("push-2", L2_VTR_PUSH_2) \
10510 _("pop-1", L2_VTR_POP_1) \
10511 _("pop-2", L2_VTR_POP_2) \
10512 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10513 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10514 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10515 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10518 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10520 unformat_input_t *i = vam->input;
10521 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10524 u8 sw_if_index_set = 0;
10527 u32 push_dot1q = 1;
10531 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10533 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10534 sw_if_index_set = 1;
10535 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10536 sw_if_index_set = 1;
10537 else if (unformat (i, "vtr_op %d", &vtr_op))
10539 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10542 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10544 else if (unformat (i, "tag1 %d", &tag1))
10546 else if (unformat (i, "tag2 %d", &tag2))
10550 clib_warning ("parse error '%U'", format_unformat_error, i);
10555 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10557 errmsg ("missing vtr operation or sw_if_index\n");
10561 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
10562 mp->sw_if_index = ntohl (sw_if_index);
10563 mp->vtr_op = ntohl (vtr_op);
10564 mp->push_dot1q = ntohl (push_dot1q);
10565 mp->tag1 = ntohl (tag1);
10566 mp->tag2 = ntohl (tag2);
10575 api_create_vhost_user_if (vat_main_t * vam)
10577 unformat_input_t *i = vam->input;
10578 vl_api_create_vhost_user_if_t *mp;
10582 u8 file_name_set = 0;
10583 u32 custom_dev_instance = ~0;
10585 u8 use_custom_mac = 0;
10587 /* Shut up coverity */
10588 memset (hwaddr, 0, sizeof (hwaddr));
10590 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10592 if (unformat (i, "socket %s", &file_name))
10596 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10598 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10599 use_custom_mac = 1;
10600 else if (unformat (i, "server"))
10606 if (file_name_set == 0)
10608 errmsg ("missing socket file name\n");
10612 if (vec_len (file_name) > 255)
10614 errmsg ("socket file name too long\n");
10617 vec_add1 (file_name, 0);
10619 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
10621 mp->is_server = is_server;
10622 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10623 vec_free (file_name);
10624 if (custom_dev_instance != ~0)
10627 mp->custom_dev_instance = ntohl (custom_dev_instance);
10629 mp->use_custom_mac = use_custom_mac;
10630 clib_memcpy (mp->mac_address, hwaddr, 6);
10639 api_modify_vhost_user_if (vat_main_t * vam)
10641 unformat_input_t *i = vam->input;
10642 vl_api_modify_vhost_user_if_t *mp;
10646 u8 file_name_set = 0;
10647 u32 custom_dev_instance = ~0;
10648 u8 sw_if_index_set = 0;
10649 u32 sw_if_index = (u32) ~ 0;
10651 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10653 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10654 sw_if_index_set = 1;
10655 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10656 sw_if_index_set = 1;
10657 else if (unformat (i, "socket %s", &file_name))
10661 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10663 else if (unformat (i, "server"))
10669 if (sw_if_index_set == 0)
10671 errmsg ("missing sw_if_index or interface name\n");
10675 if (file_name_set == 0)
10677 errmsg ("missing socket file name\n");
10681 if (vec_len (file_name) > 255)
10683 errmsg ("socket file name too long\n");
10686 vec_add1 (file_name, 0);
10688 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
10690 mp->sw_if_index = ntohl (sw_if_index);
10691 mp->is_server = is_server;
10692 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10693 vec_free (file_name);
10694 if (custom_dev_instance != ~0)
10697 mp->custom_dev_instance = ntohl (custom_dev_instance);
10707 api_delete_vhost_user_if (vat_main_t * vam)
10709 unformat_input_t *i = vam->input;
10710 vl_api_delete_vhost_user_if_t *mp;
10712 u32 sw_if_index = ~0;
10713 u8 sw_if_index_set = 0;
10715 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10717 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10718 sw_if_index_set = 1;
10719 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10720 sw_if_index_set = 1;
10725 if (sw_if_index_set == 0)
10727 errmsg ("missing sw_if_index or interface name\n");
10732 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
10734 mp->sw_if_index = ntohl (sw_if_index);
10742 static void vl_api_sw_interface_vhost_user_details_t_handler
10743 (vl_api_sw_interface_vhost_user_details_t * mp)
10745 vat_main_t *vam = &vat_main;
10747 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
10748 (char *) mp->interface_name,
10749 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10750 clib_net_to_host_u64 (mp->features), mp->is_server,
10751 ntohl (mp->num_regions), (char *) mp->sock_filename);
10752 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
10755 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10756 (vl_api_sw_interface_vhost_user_details_t * mp)
10758 vat_main_t *vam = &vat_main;
10759 vat_json_node_t *node = NULL;
10761 if (VAT_JSON_ARRAY != vam->json_tree.type)
10763 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10764 vat_json_init_array (&vam->json_tree);
10766 node = vat_json_array_add (&vam->json_tree);
10768 vat_json_init_object (node);
10769 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10770 vat_json_object_add_string_copy (node, "interface_name",
10771 mp->interface_name);
10772 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10773 ntohl (mp->virtio_net_hdr_sz));
10774 vat_json_object_add_uint (node, "features",
10775 clib_net_to_host_u64 (mp->features));
10776 vat_json_object_add_uint (node, "is_server", mp->is_server);
10777 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10778 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10779 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10783 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10785 vl_api_sw_interface_vhost_user_dump_t *mp;
10788 "Interface name idx hdr_sz features server regions filename\n");
10790 /* Get list of vhost-user interfaces */
10791 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
10794 /* Use a control ping for synchronization */
10796 vl_api_control_ping_t *mp;
10797 M (CONTROL_PING, control_ping);
10804 api_show_version (vat_main_t * vam)
10806 vl_api_show_version_t *mp;
10809 M (SHOW_VERSION, show_version);
10819 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10821 unformat_input_t *line_input = vam->input;
10822 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10824 ip4_address_t local4, remote4;
10825 ip6_address_t local6, remote6;
10827 u8 ipv4_set = 0, ipv6_set = 0;
10830 u32 encap_vrf_id = 0;
10831 u32 decap_vrf_id = 0;
10836 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10838 if (unformat (line_input, "del"))
10840 else if (unformat (line_input, "local %U",
10841 unformat_ip4_address, &local4))
10846 else if (unformat (line_input, "remote %U",
10847 unformat_ip4_address, &remote4))
10852 else if (unformat (line_input, "local %U",
10853 unformat_ip6_address, &local6))
10858 else if (unformat (line_input, "remote %U",
10859 unformat_ip6_address, &remote6))
10864 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10866 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10868 else if (unformat (line_input, "vni %d", &vni))
10870 else if (unformat (line_input, "next-ip4"))
10872 else if (unformat (line_input, "next-ip6"))
10874 else if (unformat (line_input, "next-ethernet"))
10876 else if (unformat (line_input, "next-nsh"))
10880 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10885 if (local_set == 0)
10887 errmsg ("tunnel local address not specified\n");
10890 if (remote_set == 0)
10892 errmsg ("tunnel remote address not specified\n");
10895 if (ipv4_set && ipv6_set)
10897 errmsg ("both IPv4 and IPv6 addresses specified");
10903 errmsg ("vni not specified\n");
10907 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10912 clib_memcpy (&mp->local, &local6, sizeof (local6));
10913 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10917 clib_memcpy (&mp->local, &local4, sizeof (local4));
10918 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10921 mp->encap_vrf_id = ntohl (encap_vrf_id);
10922 mp->decap_vrf_id = ntohl (decap_vrf_id);
10923 mp->protocol = ntohl (protocol);
10924 mp->vni = ntohl (vni);
10925 mp->is_add = is_add;
10926 mp->is_ipv6 = ipv6_set;
10934 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10935 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10937 vat_main_t *vam = &vat_main;
10939 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10940 ntohl (mp->sw_if_index),
10941 format_ip46_address, &(mp->local[0]),
10942 format_ip46_address, &(mp->remote[0]),
10944 ntohl (mp->protocol),
10945 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10948 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10949 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10951 vat_main_t *vam = &vat_main;
10952 vat_json_node_t *node = NULL;
10953 struct in_addr ip4;
10954 struct in6_addr ip6;
10956 if (VAT_JSON_ARRAY != vam->json_tree.type)
10958 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10959 vat_json_init_array (&vam->json_tree);
10961 node = vat_json_array_add (&vam->json_tree);
10963 vat_json_init_object (node);
10964 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10967 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10968 vat_json_object_add_ip6 (node, "local", ip6);
10969 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10970 vat_json_object_add_ip6 (node, "remote", ip6);
10974 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10975 vat_json_object_add_ip4 (node, "local", ip4);
10976 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10977 vat_json_object_add_ip4 (node, "remote", ip4);
10979 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10980 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10981 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10982 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10983 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10987 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10989 unformat_input_t *i = vam->input;
10990 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10993 u8 sw_if_index_set = 0;
10995 /* Parse args required to build the message */
10996 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10998 if (unformat (i, "sw_if_index %d", &sw_if_index))
10999 sw_if_index_set = 1;
11004 if (sw_if_index_set == 0)
11009 if (!vam->json_output)
11011 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
11012 "sw_if_index", "local", "remote", "vni",
11013 "protocol", "encap_vrf_id", "decap_vrf_id");
11016 /* Get list of vxlan-tunnel interfaces */
11017 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
11019 mp->sw_if_index = htonl (sw_if_index);
11023 /* Use a control ping for synchronization */
11025 vl_api_control_ping_t *mp;
11026 M (CONTROL_PING, control_ping);
11033 format_l2_fib_mac_address (u8 * s, va_list * args)
11035 u8 *a = va_arg (*args, u8 *);
11037 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11038 a[2], a[3], a[4], a[5], a[6], a[7]);
11041 static void vl_api_l2_fib_table_entry_t_handler
11042 (vl_api_l2_fib_table_entry_t * mp)
11044 vat_main_t *vam = &vat_main;
11046 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11048 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11049 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11053 static void vl_api_l2_fib_table_entry_t_handler_json
11054 (vl_api_l2_fib_table_entry_t * mp)
11056 vat_main_t *vam = &vat_main;
11057 vat_json_node_t *node = NULL;
11059 if (VAT_JSON_ARRAY != vam->json_tree.type)
11061 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11062 vat_json_init_array (&vam->json_tree);
11064 node = vat_json_array_add (&vam->json_tree);
11066 vat_json_init_object (node);
11067 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11068 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11069 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11070 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11071 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11072 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11076 api_l2_fib_table_dump (vat_main_t * vam)
11078 unformat_input_t *i = vam->input;
11079 vl_api_l2_fib_table_dump_t *mp;
11084 /* Parse args required to build the message */
11085 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11087 if (unformat (i, "bd_id %d", &bd_id))
11093 if (bd_id_set == 0)
11095 errmsg ("missing bridge domain\n");
11100 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
11102 /* Get list of l2 fib entries */
11103 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11105 mp->bd_id = ntohl (bd_id);
11108 /* Use a control ping for synchronization */
11110 vl_api_control_ping_t *mp;
11111 M (CONTROL_PING, control_ping);
11119 api_interface_name_renumber (vat_main_t * vam)
11121 unformat_input_t *line_input = vam->input;
11122 vl_api_interface_name_renumber_t *mp;
11123 u32 sw_if_index = ~0;
11125 u32 new_show_dev_instance = ~0;
11127 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11129 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
11132 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11134 else if (unformat (line_input, "new_show_dev_instance %d",
11135 &new_show_dev_instance))
11141 if (sw_if_index == ~0)
11143 errmsg ("missing interface name or sw_if_index\n");
11147 if (new_show_dev_instance == ~0)
11149 errmsg ("missing new_show_dev_instance\n");
11153 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11155 mp->sw_if_index = ntohl (sw_if_index);
11156 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11163 api_want_ip4_arp_events (vat_main_t * vam)
11165 unformat_input_t *line_input = vam->input;
11166 vl_api_want_ip4_arp_events_t *mp;
11168 ip4_address_t address;
11169 int address_set = 0;
11170 u32 enable_disable = 1;
11172 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11174 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11176 else if (unformat (line_input, "del"))
11177 enable_disable = 0;
11182 if (address_set == 0)
11184 errmsg ("missing addresses\n");
11188 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11189 mp->enable_disable = enable_disable;
11190 mp->pid = getpid ();
11191 mp->address = address.as_u32;
11198 api_want_ip6_nd_events (vat_main_t * vam)
11200 unformat_input_t *line_input = vam->input;
11201 vl_api_want_ip6_nd_events_t *mp;
11203 ip6_address_t address;
11204 int address_set = 0;
11205 u32 enable_disable = 1;
11207 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11209 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11211 else if (unformat (line_input, "del"))
11212 enable_disable = 0;
11217 if (address_set == 0)
11219 errmsg ("missing addresses\n");
11223 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11224 mp->enable_disable = enable_disable;
11225 mp->pid = getpid ();
11226 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11233 api_input_acl_set_interface (vat_main_t * vam)
11235 unformat_input_t *i = vam->input;
11236 vl_api_input_acl_set_interface_t *mp;
11239 int sw_if_index_set;
11240 u32 ip4_table_index = ~0;
11241 u32 ip6_table_index = ~0;
11242 u32 l2_table_index = ~0;
11245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11247 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11248 sw_if_index_set = 1;
11249 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11250 sw_if_index_set = 1;
11251 else if (unformat (i, "del"))
11253 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11255 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11257 else if (unformat (i, "l2-table %d", &l2_table_index))
11261 clib_warning ("parse error '%U'", format_unformat_error, i);
11266 if (sw_if_index_set == 0)
11268 errmsg ("missing interface name or sw_if_index\n");
11272 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11274 mp->sw_if_index = ntohl (sw_if_index);
11275 mp->ip4_table_index = ntohl (ip4_table_index);
11276 mp->ip6_table_index = ntohl (ip6_table_index);
11277 mp->l2_table_index = ntohl (l2_table_index);
11278 mp->is_add = is_add;
11287 api_ip_address_dump (vat_main_t * vam)
11289 unformat_input_t *i = vam->input;
11290 vl_api_ip_address_dump_t *mp;
11291 u32 sw_if_index = ~0;
11292 u8 sw_if_index_set = 0;
11297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11299 if (unformat (i, "sw_if_index %d", &sw_if_index))
11300 sw_if_index_set = 1;
11301 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11302 sw_if_index_set = 1;
11303 else if (unformat (i, "ipv4"))
11305 else if (unformat (i, "ipv6"))
11311 if (ipv4_set && ipv6_set)
11313 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11317 if ((!ipv4_set) && (!ipv6_set))
11319 errmsg ("no ipv4 nor ipv6 flag set\n");
11323 if (sw_if_index_set == 0)
11325 errmsg ("missing interface name or sw_if_index\n");
11329 vam->current_sw_if_index = sw_if_index;
11330 vam->is_ipv6 = ipv6_set;
11332 M (IP_ADDRESS_DUMP, ip_address_dump);
11333 mp->sw_if_index = ntohl (sw_if_index);
11334 mp->is_ipv6 = ipv6_set;
11337 /* Use a control ping for synchronization */
11339 vl_api_control_ping_t *mp;
11340 M (CONTROL_PING, control_ping);
11347 api_ip_dump (vat_main_t * vam)
11349 vl_api_ip_dump_t *mp;
11350 unformat_input_t *in = vam->input;
11357 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11359 if (unformat (in, "ipv4"))
11361 else if (unformat (in, "ipv6"))
11367 if (ipv4_set && ipv6_set)
11369 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11373 if ((!ipv4_set) && (!ipv6_set))
11375 errmsg ("no ipv4 nor ipv6 flag set\n");
11379 is_ipv6 = ipv6_set;
11380 vam->is_ipv6 = is_ipv6;
11382 /* free old data */
11383 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11385 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11387 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11389 M (IP_DUMP, ip_dump);
11390 mp->is_ipv6 = ipv6_set;
11393 /* Use a control ping for synchronization */
11395 vl_api_control_ping_t *mp;
11396 M (CONTROL_PING, control_ping);
11403 api_ipsec_spd_add_del (vat_main_t * vam)
11406 unformat_input_t *i = vam->input;
11407 vl_api_ipsec_spd_add_del_t *mp;
11412 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11414 if (unformat (i, "spd_id %d", &spd_id))
11416 else if (unformat (i, "del"))
11420 clib_warning ("parse error '%U'", format_unformat_error, i);
11426 errmsg ("spd_id must be set\n");
11430 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
11432 mp->spd_id = ntohl (spd_id);
11433 mp->is_add = is_add;
11440 clib_warning ("unsupported (no dpdk)");
11446 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11449 unformat_input_t *i = vam->input;
11450 vl_api_ipsec_interface_add_del_spd_t *mp;
11453 u8 sw_if_index_set = 0;
11454 u32 spd_id = (u32) ~ 0;
11457 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11459 if (unformat (i, "del"))
11461 else if (unformat (i, "spd_id %d", &spd_id))
11463 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11464 sw_if_index_set = 1;
11465 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11466 sw_if_index_set = 1;
11469 clib_warning ("parse error '%U'", format_unformat_error, i);
11475 if (spd_id == (u32) ~ 0)
11477 errmsg ("spd_id must be set\n");
11481 if (sw_if_index_set == 0)
11483 errmsg ("missing interface name or sw_if_index\n");
11487 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
11489 mp->spd_id = ntohl (spd_id);
11490 mp->sw_if_index = ntohl (sw_if_index);
11491 mp->is_add = is_add;
11498 clib_warning ("unsupported (no dpdk)");
11504 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11507 unformat_input_t *i = vam->input;
11508 vl_api_ipsec_spd_add_del_entry_t *mp;
11510 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11511 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11513 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11514 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11515 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11516 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11518 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11519 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11520 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11521 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11522 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11523 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11527 if (unformat (i, "del"))
11529 if (unformat (i, "outbound"))
11531 if (unformat (i, "inbound"))
11533 else if (unformat (i, "spd_id %d", &spd_id))
11535 else if (unformat (i, "sa_id %d", &sa_id))
11537 else if (unformat (i, "priority %d", &priority))
11539 else if (unformat (i, "protocol %d", &protocol))
11541 else if (unformat (i, "lport_start %d", &lport_start))
11543 else if (unformat (i, "lport_stop %d", &lport_stop))
11545 else if (unformat (i, "rport_start %d", &rport_start))
11547 else if (unformat (i, "rport_stop %d", &rport_stop))
11551 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11557 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11564 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11570 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11577 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11583 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
11590 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
11596 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
11602 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11604 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11606 clib_warning ("unsupported action: 'resolve'");
11612 clib_warning ("parse error '%U'", format_unformat_error, i);
11618 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
11620 mp->spd_id = ntohl (spd_id);
11621 mp->priority = ntohl (priority);
11622 mp->is_outbound = is_outbound;
11624 mp->is_ipv6 = is_ipv6;
11625 if (is_ipv6 || is_ip_any)
11627 clib_memcpy (mp->remote_address_start, &raddr6_start,
11628 sizeof (ip6_address_t));
11629 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
11630 sizeof (ip6_address_t));
11631 clib_memcpy (mp->local_address_start, &laddr6_start,
11632 sizeof (ip6_address_t));
11633 clib_memcpy (mp->local_address_stop, &laddr6_stop,
11634 sizeof (ip6_address_t));
11638 clib_memcpy (mp->remote_address_start, &raddr4_start,
11639 sizeof (ip4_address_t));
11640 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
11641 sizeof (ip4_address_t));
11642 clib_memcpy (mp->local_address_start, &laddr4_start,
11643 sizeof (ip4_address_t));
11644 clib_memcpy (mp->local_address_stop, &laddr4_stop,
11645 sizeof (ip4_address_t));
11647 mp->protocol = (u8) protocol;
11648 mp->local_port_start = ntohs ((u16) lport_start);
11649 mp->local_port_stop = ntohs ((u16) lport_stop);
11650 mp->remote_port_start = ntohs ((u16) rport_start);
11651 mp->remote_port_stop = ntohs ((u16) rport_stop);
11652 mp->policy = (u8) policy;
11653 mp->sa_id = ntohl (sa_id);
11654 mp->is_add = is_add;
11655 mp->is_ip_any = is_ip_any;
11661 clib_warning ("unsupported (no dpdk)");
11667 api_ipsec_sad_add_del_entry (vat_main_t * vam)
11670 unformat_input_t *i = vam->input;
11671 vl_api_ipsec_sad_add_del_entry_t *mp;
11673 u32 sad_id = 0, spi = 0;
11674 u8 *ck = 0, *ik = 0;
11677 u8 protocol = IPSEC_PROTOCOL_AH;
11678 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
11679 u32 crypto_alg = 0, integ_alg = 0;
11680 ip4_address_t tun_src4;
11681 ip4_address_t tun_dst4;
11682 ip6_address_t tun_src6;
11683 ip6_address_t tun_dst6;
11685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11687 if (unformat (i, "del"))
11689 else if (unformat (i, "sad_id %d", &sad_id))
11691 else if (unformat (i, "spi %d", &spi))
11693 else if (unformat (i, "esp"))
11694 protocol = IPSEC_PROTOCOL_ESP;
11695 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
11698 is_tunnel_ipv6 = 0;
11700 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
11703 is_tunnel_ipv6 = 0;
11705 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
11708 is_tunnel_ipv6 = 1;
11710 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
11713 is_tunnel_ipv6 = 1;
11717 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
11719 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
11720 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
11722 clib_warning ("unsupported crypto-alg: '%U'",
11723 format_ipsec_crypto_alg, crypto_alg);
11727 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11731 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
11733 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
11734 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
11736 clib_warning ("unsupported integ-alg: '%U'",
11737 format_ipsec_integ_alg, integ_alg);
11741 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11745 clib_warning ("parse error '%U'", format_unformat_error, i);
11751 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
11753 mp->sad_id = ntohl (sad_id);
11754 mp->is_add = is_add;
11755 mp->protocol = protocol;
11756 mp->spi = ntohl (spi);
11757 mp->is_tunnel = is_tunnel;
11758 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
11759 mp->crypto_algorithm = crypto_alg;
11760 mp->integrity_algorithm = integ_alg;
11761 mp->crypto_key_length = vec_len (ck);
11762 mp->integrity_key_length = vec_len (ik);
11764 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11765 mp->crypto_key_length = sizeof (mp->crypto_key);
11767 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11768 mp->integrity_key_length = sizeof (mp->integrity_key);
11771 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11773 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11777 if (is_tunnel_ipv6)
11779 clib_memcpy (mp->tunnel_src_address, &tun_src6,
11780 sizeof (ip6_address_t));
11781 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
11782 sizeof (ip6_address_t));
11786 clib_memcpy (mp->tunnel_src_address, &tun_src4,
11787 sizeof (ip4_address_t));
11788 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
11789 sizeof (ip4_address_t));
11798 clib_warning ("unsupported (no dpdk)");
11804 api_ipsec_sa_set_key (vat_main_t * vam)
11807 unformat_input_t *i = vam->input;
11808 vl_api_ipsec_sa_set_key_t *mp;
11811 u8 *ck = 0, *ik = 0;
11813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11815 if (unformat (i, "sa_id %d", &sa_id))
11817 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11819 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11823 clib_warning ("parse error '%U'", format_unformat_error, i);
11828 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
11830 mp->sa_id = ntohl (sa_id);
11831 mp->crypto_key_length = vec_len (ck);
11832 mp->integrity_key_length = vec_len (ik);
11834 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11835 mp->crypto_key_length = sizeof (mp->crypto_key);
11837 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11838 mp->integrity_key_length = sizeof (mp->integrity_key);
11841 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11843 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11850 clib_warning ("unsupported (no dpdk)");
11856 api_ikev2_profile_add_del (vat_main_t * vam)
11859 unformat_input_t *i = vam->input;
11860 vl_api_ikev2_profile_add_del_t *mp;
11865 const char *valid_chars = "a-zA-Z0-9_";
11867 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11869 if (unformat (i, "del"))
11871 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11872 vec_add1 (name, 0);
11875 errmsg ("parse error '%U'", format_unformat_error, i);
11880 if (!vec_len (name))
11882 errmsg ("profile name must be specified");
11886 if (vec_len (name) > 64)
11888 errmsg ("profile name too long");
11892 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11894 clib_memcpy (mp->name, name, vec_len (name));
11895 mp->is_add = is_add;
11903 clib_warning ("unsupported (no dpdk)");
11909 api_ikev2_profile_set_auth (vat_main_t * vam)
11912 unformat_input_t *i = vam->input;
11913 vl_api_ikev2_profile_set_auth_t *mp;
11917 u32 auth_method = 0;
11920 const char *valid_chars = "a-zA-Z0-9_";
11922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11924 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11925 vec_add1 (name, 0);
11926 else if (unformat (i, "auth_method %U",
11927 unformat_ikev2_auth_method, &auth_method))
11929 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11931 else if (unformat (i, "auth_data %v", &data))
11935 errmsg ("parse error '%U'", format_unformat_error, i);
11940 if (!vec_len (name))
11942 errmsg ("profile name must be specified");
11946 if (vec_len (name) > 64)
11948 errmsg ("profile name too long");
11952 if (!vec_len (data))
11954 errmsg ("auth_data must be specified");
11960 errmsg ("auth_method must be specified");
11964 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11966 mp->is_hex = is_hex;
11967 mp->auth_method = (u8) auth_method;
11968 mp->data_len = vec_len (data);
11969 clib_memcpy (mp->name, name, vec_len (name));
11970 clib_memcpy (mp->data, data, vec_len (data));
11979 clib_warning ("unsupported (no dpdk)");
11985 api_ikev2_profile_set_id (vat_main_t * vam)
11988 unformat_input_t *i = vam->input;
11989 vl_api_ikev2_profile_set_id_t *mp;
11997 const char *valid_chars = "a-zA-Z0-9_";
11999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12001 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12002 vec_add1 (name, 0);
12003 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12005 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12007 data = vec_new (u8, 4);
12008 clib_memcpy (data, ip4.as_u8, 4);
12010 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12012 else if (unformat (i, "id_data %v", &data))
12014 else if (unformat (i, "local"))
12016 else if (unformat (i, "remote"))
12020 errmsg ("parse error '%U'", format_unformat_error, i);
12025 if (!vec_len (name))
12027 errmsg ("profile name must be specified");
12031 if (vec_len (name) > 64)
12033 errmsg ("profile name too long");
12037 if (!vec_len (data))
12039 errmsg ("id_data must be specified");
12045 errmsg ("id_type must be specified");
12049 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
12051 mp->is_local = is_local;
12052 mp->id_type = (u8) id_type;
12053 mp->data_len = vec_len (data);
12054 clib_memcpy (mp->name, name, vec_len (name));
12055 clib_memcpy (mp->data, data, vec_len (data));
12064 clib_warning ("unsupported (no dpdk)");
12070 api_ikev2_profile_set_ts (vat_main_t * vam)
12073 unformat_input_t *i = vam->input;
12074 vl_api_ikev2_profile_set_ts_t *mp;
12078 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12079 ip4_address_t start_addr, end_addr;
12081 const char *valid_chars = "a-zA-Z0-9_";
12083 start_addr.as_u32 = 0;
12084 end_addr.as_u32 = (u32) ~ 0;
12086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12088 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12089 vec_add1 (name, 0);
12090 else if (unformat (i, "protocol %d", &proto))
12092 else if (unformat (i, "start_port %d", &start_port))
12094 else if (unformat (i, "end_port %d", &end_port))
12097 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12099 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12101 else if (unformat (i, "local"))
12103 else if (unformat (i, "remote"))
12107 errmsg ("parse error '%U'", format_unformat_error, i);
12112 if (!vec_len (name))
12114 errmsg ("profile name must be specified");
12118 if (vec_len (name) > 64)
12120 errmsg ("profile name too long");
12124 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12126 mp->is_local = is_local;
12127 mp->proto = (u8) proto;
12128 mp->start_port = (u16) start_port;
12129 mp->end_port = (u16) end_port;
12130 mp->start_addr = start_addr.as_u32;
12131 mp->end_addr = end_addr.as_u32;
12132 clib_memcpy (mp->name, name, vec_len (name));
12140 clib_warning ("unsupported (no dpdk)");
12146 api_ikev2_set_local_key (vat_main_t * vam)
12149 unformat_input_t *i = vam->input;
12150 vl_api_ikev2_set_local_key_t *mp;
12154 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12156 if (unformat (i, "file %v", &file))
12157 vec_add1 (file, 0);
12160 errmsg ("parse error '%U'", format_unformat_error, i);
12165 if (!vec_len (file))
12167 errmsg ("RSA key file must be specified");
12171 if (vec_len (file) > 256)
12173 errmsg ("file name too long");
12177 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12179 clib_memcpy (mp->key_file, file, vec_len (file));
12187 clib_warning ("unsupported (no dpdk)");
12196 api_map_add_domain (vat_main_t * vam)
12198 unformat_input_t *i = vam->input;
12199 vl_api_map_add_domain_t *mp;
12202 ip4_address_t ip4_prefix;
12203 ip6_address_t ip6_prefix;
12204 ip6_address_t ip6_src;
12205 u32 num_m_args = 0;
12206 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12207 0, psid_length = 0;
12208 u8 is_translation = 0;
12210 u32 ip6_src_len = 128;
12212 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12214 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12215 &ip4_prefix, &ip4_prefix_len))
12217 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12218 &ip6_prefix, &ip6_prefix_len))
12222 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12225 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12227 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12229 else if (unformat (i, "psid-offset %d", &psid_offset))
12231 else if (unformat (i, "psid-len %d", &psid_length))
12233 else if (unformat (i, "mtu %d", &mtu))
12235 else if (unformat (i, "map-t"))
12236 is_translation = 1;
12239 clib_warning ("parse error '%U'", format_unformat_error, i);
12244 if (num_m_args < 3)
12246 errmsg ("mandatory argument(s) missing\n");
12250 /* Construct the API message */
12251 M (MAP_ADD_DOMAIN, map_add_domain);
12253 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12254 mp->ip4_prefix_len = ip4_prefix_len;
12256 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12257 mp->ip6_prefix_len = ip6_prefix_len;
12259 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12260 mp->ip6_src_prefix_len = ip6_src_len;
12262 mp->ea_bits_len = ea_bits_len;
12263 mp->psid_offset = psid_offset;
12264 mp->psid_length = psid_length;
12265 mp->is_translation = is_translation;
12266 mp->mtu = htons (mtu);
12271 /* Wait for a reply, return good/bad news */
12276 api_map_del_domain (vat_main_t * vam)
12278 unformat_input_t *i = vam->input;
12279 vl_api_map_del_domain_t *mp;
12282 u32 num_m_args = 0;
12285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12287 if (unformat (i, "index %d", &index))
12291 clib_warning ("parse error '%U'", format_unformat_error, i);
12296 if (num_m_args != 1)
12298 errmsg ("mandatory argument(s) missing\n");
12302 /* Construct the API message */
12303 M (MAP_DEL_DOMAIN, map_del_domain);
12305 mp->index = ntohl (index);
12310 /* Wait for a reply, return good/bad news */
12315 api_map_add_del_rule (vat_main_t * vam)
12317 unformat_input_t *i = vam->input;
12318 vl_api_map_add_del_rule_t *mp;
12321 ip6_address_t ip6_dst;
12322 u32 num_m_args = 0, index, psid = 0;
12324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12326 if (unformat (i, "index %d", &index))
12328 else if (unformat (i, "psid %d", &psid))
12330 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12332 else if (unformat (i, "del"))
12338 clib_warning ("parse error '%U'", format_unformat_error, i);
12343 /* Construct the API message */
12344 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12346 mp->index = ntohl (index);
12347 mp->is_add = is_add;
12348 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12349 mp->psid = ntohs (psid);
12354 /* Wait for a reply, return good/bad news */
12359 api_map_domain_dump (vat_main_t * vam)
12361 vl_api_map_domain_dump_t *mp;
12364 /* Construct the API message */
12365 M (MAP_DOMAIN_DUMP, map_domain_dump);
12370 /* Use a control ping for synchronization */
12372 vl_api_control_ping_t *mp;
12373 M (CONTROL_PING, control_ping);
12380 api_map_rule_dump (vat_main_t * vam)
12382 unformat_input_t *i = vam->input;
12383 vl_api_map_rule_dump_t *mp;
12385 u32 domain_index = ~0;
12387 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12389 if (unformat (i, "index %u", &domain_index))
12395 if (domain_index == ~0)
12397 clib_warning ("parse error: domain index expected");
12401 /* Construct the API message */
12402 M (MAP_RULE_DUMP, map_rule_dump);
12404 mp->domain_index = htonl (domain_index);
12409 /* Use a control ping for synchronization */
12411 vl_api_control_ping_t *mp;
12412 M (CONTROL_PING, control_ping);
12418 static void vl_api_map_add_domain_reply_t_handler
12419 (vl_api_map_add_domain_reply_t * mp)
12421 vat_main_t *vam = &vat_main;
12422 i32 retval = ntohl (mp->retval);
12424 if (vam->async_mode)
12426 vam->async_errors += (retval < 0);
12430 vam->retval = retval;
12431 vam->result_ready = 1;
12435 static void vl_api_map_add_domain_reply_t_handler_json
12436 (vl_api_map_add_domain_reply_t * mp)
12438 vat_main_t *vam = &vat_main;
12439 vat_json_node_t node;
12441 vat_json_init_object (&node);
12442 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12443 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12445 vat_json_print (vam->ofp, &node);
12446 vat_json_free (&node);
12448 vam->retval = ntohl (mp->retval);
12449 vam->result_ready = 1;
12453 api_get_first_msg_id (vat_main_t * vam)
12455 vl_api_get_first_msg_id_t *mp;
12457 unformat_input_t *i = vam->input;
12461 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12463 if (unformat (i, "client %s", &name))
12471 errmsg ("missing client name\n");
12474 vec_add1 (name, 0);
12476 if (vec_len (name) > 63)
12478 errmsg ("client name too long\n");
12482 M (GET_FIRST_MSG_ID, get_first_msg_id);
12483 clib_memcpy (mp->name, name, vec_len (name));
12491 api_cop_interface_enable_disable (vat_main_t * vam)
12493 unformat_input_t *line_input = vam->input;
12494 vl_api_cop_interface_enable_disable_t *mp;
12496 u32 sw_if_index = ~0;
12497 u8 enable_disable = 1;
12499 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12501 if (unformat (line_input, "disable"))
12502 enable_disable = 0;
12503 if (unformat (line_input, "enable"))
12504 enable_disable = 1;
12505 else if (unformat (line_input, "%U", unformat_sw_if_index,
12506 vam, &sw_if_index))
12508 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12514 if (sw_if_index == ~0)
12516 errmsg ("missing interface name or sw_if_index\n");
12520 /* Construct the API message */
12521 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
12522 mp->sw_if_index = ntohl (sw_if_index);
12523 mp->enable_disable = enable_disable;
12527 /* Wait for the reply */
12532 api_cop_whitelist_enable_disable (vat_main_t * vam)
12534 unformat_input_t *line_input = vam->input;
12535 vl_api_cop_whitelist_enable_disable_t *mp;
12537 u32 sw_if_index = ~0;
12538 u8 ip4 = 0, ip6 = 0, default_cop = 0;
12541 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12543 if (unformat (line_input, "ip4"))
12545 else if (unformat (line_input, "ip6"))
12547 else if (unformat (line_input, "default"))
12549 else if (unformat (line_input, "%U", unformat_sw_if_index,
12550 vam, &sw_if_index))
12552 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12554 else if (unformat (line_input, "fib-id %d", &fib_id))
12560 if (sw_if_index == ~0)
12562 errmsg ("missing interface name or sw_if_index\n");
12566 /* Construct the API message */
12567 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
12568 mp->sw_if_index = ntohl (sw_if_index);
12569 mp->fib_id = ntohl (fib_id);
12572 mp->default_cop = default_cop;
12576 /* Wait for the reply */
12581 api_get_node_graph (vat_main_t * vam)
12583 vl_api_get_node_graph_t *mp;
12586 M (GET_NODE_GRAPH, get_node_graph);
12590 /* Wait for the reply */
12595 /** Used for parsing LISP eids */
12596 typedef CLIB_PACKED(struct{
12597 u8 addr[16]; /**< eid address */
12598 u32 len; /**< prefix length if IP */
12599 u8 type; /**< type of eid */
12604 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
12606 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
12608 memset (a, 0, sizeof (a[0]));
12610 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
12612 a->type = 0; /* ipv4 type */
12614 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
12616 a->type = 1; /* ipv6 type */
12618 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
12620 a->type = 2; /* mac type */
12627 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
12636 lisp_eid_size_vat (u8 type)
12651 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
12653 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
12657 /** Used for transferring locators via VPP API */
12658 typedef CLIB_PACKED(struct
12660 u32 sw_if_index; /**< locator sw_if_index */
12661 u8 priority; /**< locator priority */
12662 u8 weight; /**< locator weight */
12667 api_lisp_add_del_locator_set (vat_main_t * vam)
12669 unformat_input_t *input = vam->input;
12670 vl_api_lisp_add_del_locator_set_t *mp;
12673 u8 *locator_set_name = NULL;
12674 u8 locator_set_name_set = 0;
12675 ls_locator_t locator, *locators = 0;
12676 u32 sw_if_index, priority, weight;
12679 /* Parse args required to build the message */
12680 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12682 if (unformat (input, "del"))
12686 else if (unformat (input, "locator-set %s", &locator_set_name))
12688 locator_set_name_set = 1;
12690 else if (unformat (input, "sw_if_index %u p %u w %u",
12691 &sw_if_index, &priority, &weight))
12693 locator.sw_if_index = htonl (sw_if_index);
12694 locator.priority = priority;
12695 locator.weight = weight;
12696 vec_add1 (locators, locator);
12698 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
12699 vam, &sw_if_index, &priority, &weight))
12701 locator.sw_if_index = htonl (sw_if_index);
12702 locator.priority = priority;
12703 locator.weight = weight;
12704 vec_add1 (locators, locator);
12710 if (locator_set_name_set == 0)
12712 errmsg ("missing locator-set name");
12713 vec_free (locators);
12717 if (vec_len (locator_set_name) > 64)
12719 errmsg ("locator-set name too long\n");
12720 vec_free (locator_set_name);
12721 vec_free (locators);
12724 vec_add1 (locator_set_name, 0);
12726 data_len = sizeof (ls_locator_t) * vec_len (locators);
12728 /* Construct the API message */
12729 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
12731 mp->is_add = is_add;
12732 clib_memcpy (mp->locator_set_name, locator_set_name,
12733 vec_len (locator_set_name));
12734 vec_free (locator_set_name);
12736 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
12738 clib_memcpy (mp->locators, locators, data_len);
12739 vec_free (locators);
12744 /* Wait for a reply... */
12752 api_lisp_add_del_locator (vat_main_t * vam)
12754 unformat_input_t *input = vam->input;
12755 vl_api_lisp_add_del_locator_t *mp;
12757 u32 tmp_if_index = ~0;
12758 u32 sw_if_index = ~0;
12759 u8 sw_if_index_set = 0;
12760 u8 sw_if_index_if_name_set = 0;
12762 u8 priority_set = 0;
12766 u8 *locator_set_name = NULL;
12767 u8 locator_set_name_set = 0;
12769 /* Parse args required to build the message */
12770 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12772 if (unformat (input, "del"))
12776 else if (unformat (input, "locator-set %s", &locator_set_name))
12778 locator_set_name_set = 1;
12780 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
12783 sw_if_index_if_name_set = 1;
12784 sw_if_index = tmp_if_index;
12786 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
12788 sw_if_index_set = 1;
12789 sw_if_index = tmp_if_index;
12791 else if (unformat (input, "p %d", &priority))
12795 else if (unformat (input, "w %d", &weight))
12803 if (locator_set_name_set == 0)
12805 errmsg ("missing locator-set name");
12809 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12811 errmsg ("missing sw_if_index");
12812 vec_free (locator_set_name);
12816 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
12818 errmsg ("cannot use both params interface name and sw_if_index");
12819 vec_free (locator_set_name);
12823 if (priority_set == 0)
12825 errmsg ("missing locator-set priority\n");
12826 vec_free (locator_set_name);
12830 if (weight_set == 0)
12832 errmsg ("missing locator-set weight\n");
12833 vec_free (locator_set_name);
12837 if (vec_len (locator_set_name) > 64)
12839 errmsg ("locator-set name too long\n");
12840 vec_free (locator_set_name);
12843 vec_add1 (locator_set_name, 0);
12845 /* Construct the API message */
12846 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
12848 mp->is_add = is_add;
12849 mp->sw_if_index = ntohl (sw_if_index);
12850 mp->priority = priority;
12851 mp->weight = weight;
12852 clib_memcpy (mp->locator_set_name, locator_set_name,
12853 vec_len (locator_set_name));
12854 vec_free (locator_set_name);
12859 /* Wait for a reply... */
12867 api_lisp_add_del_local_eid (vat_main_t * vam)
12869 unformat_input_t *input = vam->input;
12870 vl_api_lisp_add_del_local_eid_t *mp;
12874 lisp_eid_vat_t _eid, *eid = &_eid;
12875 u8 *locator_set_name = 0;
12876 u8 locator_set_name_set = 0;
12879 /* Parse args required to build the message */
12880 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12882 if (unformat (input, "del"))
12886 else if (unformat (input, "vni %d", &vni))
12890 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12894 else if (unformat (input, "locator-set %s", &locator_set_name))
12896 locator_set_name_set = 1;
12902 if (locator_set_name_set == 0)
12904 errmsg ("missing locator-set name\n");
12910 errmsg ("EID address not set!");
12911 vec_free (locator_set_name);
12915 if (vec_len (locator_set_name) > 64)
12917 errmsg ("locator-set name too long\n");
12918 vec_free (locator_set_name);
12921 vec_add1 (locator_set_name, 0);
12923 /* Construct the API message */
12924 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12926 mp->is_add = is_add;
12927 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12928 mp->eid_type = eid->type;
12929 mp->prefix_len = eid->len;
12930 mp->vni = clib_host_to_net_u32 (vni);
12931 clib_memcpy (mp->locator_set_name, locator_set_name,
12932 vec_len (locator_set_name));
12934 vec_free (locator_set_name);
12939 /* Wait for a reply... */
12947 /** Used for transferring locators via VPP API */
12948 typedef CLIB_PACKED(struct
12950 u8 is_ip4; /**< is locator an IPv4 address? */
12951 u8 priority; /**< locator priority */
12952 u8 weight; /**< locator weight */
12953 u8 addr[16]; /**< IPv4/IPv6 address */
12958 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12960 unformat_input_t *input = vam->input;
12961 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12964 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12965 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12966 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12967 u32 action = ~0, p, w;
12968 ip4_address_t rmt_rloc4, lcl_rloc4;
12969 ip6_address_t rmt_rloc6, lcl_rloc6;
12970 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12972 memset (&rloc, 0, sizeof (rloc));
12974 /* Parse args required to build the message */
12975 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12977 if (unformat (input, "del"))
12981 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12985 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12989 else if (unformat (input, "p %d w %d", &p, &w))
12993 errmsg ("No RLOC configured for setting priority/weight!");
12996 curr_rloc->priority = p;
12997 curr_rloc->weight = w;
12999 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13000 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13004 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13005 rloc.priority = rloc.weight = 0;
13006 vec_add1 (lcl_locs, rloc);
13008 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13009 vec_add1 (rmt_locs, rloc);
13010 /* priority and weight saved in rmt loc */
13011 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13013 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13014 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13017 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13018 rloc.priority = rloc.weight = 0;
13019 vec_add1 (lcl_locs, rloc);
13021 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13022 vec_add1 (rmt_locs, rloc);
13023 /* priority and weight saved in rmt loc */
13024 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13026 else if (unformat (input, "action %d", &action))
13032 clib_warning ("parse error '%U'", format_unformat_error, input);
13039 errmsg ("remote eid addresses not set\n");
13043 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13045 errmsg ("eid types don't match\n");
13049 if (0 == rmt_locs && (u32) ~ 0 == action)
13051 errmsg ("action not set for negative mapping\n");
13055 /* Construct the API message */
13056 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
13058 mp->is_add = is_add;
13059 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13060 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13061 mp->eid_type = rmt_eid->type;
13062 mp->rmt_len = rmt_eid->len;
13063 mp->lcl_len = lcl_eid->len;
13064 mp->action = action;
13066 if (0 != rmt_locs && 0 != lcl_locs)
13068 mp->loc_num = vec_len (rmt_locs);
13069 clib_memcpy (mp->lcl_locs, lcl_locs,
13070 (sizeof (rloc_t) * vec_len (lcl_locs)));
13071 clib_memcpy (mp->rmt_locs, rmt_locs,
13072 (sizeof (rloc_t) * vec_len (rmt_locs)));
13074 vec_free (lcl_locs);
13075 vec_free (rmt_locs);
13080 /* Wait for a reply... */
13088 api_lisp_add_del_map_resolver (vat_main_t * vam)
13090 unformat_input_t *input = vam->input;
13091 vl_api_lisp_add_del_map_resolver_t *mp;
13096 ip4_address_t ipv4;
13097 ip6_address_t ipv6;
13099 /* Parse args required to build the message */
13100 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13102 if (unformat (input, "del"))
13106 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13110 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13118 if (ipv4_set && ipv6_set)
13120 errmsg ("both eid v4 and v6 addresses set\n");
13124 if (!ipv4_set && !ipv6_set)
13126 errmsg ("eid addresses not set\n");
13130 /* Construct the API message */
13131 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13133 mp->is_add = is_add;
13137 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13142 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13148 /* Wait for a reply... */
13156 api_lisp_gpe_enable_disable (vat_main_t * vam)
13158 unformat_input_t *input = vam->input;
13159 vl_api_lisp_gpe_enable_disable_t *mp;
13164 /* Parse args required to build the message */
13165 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13167 if (unformat (input, "enable"))
13172 else if (unformat (input, "disable"))
13183 errmsg ("Value not set\n");
13187 /* Construct the API message */
13188 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13195 /* Wait for a reply... */
13203 api_lisp_enable_disable (vat_main_t * vam)
13205 unformat_input_t *input = vam->input;
13206 vl_api_lisp_enable_disable_t *mp;
13211 /* Parse args required to build the message */
13212 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13214 if (unformat (input, "enable"))
13219 else if (unformat (input, "disable"))
13229 errmsg ("Value not set\n");
13233 /* Construct the API message */
13234 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
13241 /* Wait for a reply... */
13249 api_show_lisp_map_request_mode (vat_main_t * vam)
13252 vl_api_show_lisp_map_request_mode_t *mp;
13254 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
13259 /* wait for reply */
13266 api_lisp_map_request_mode (vat_main_t * vam)
13269 unformat_input_t *input = vam->input;
13270 vl_api_lisp_map_request_mode_t *mp;
13273 /* Parse args required to build the message */
13274 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13276 if (unformat (input, "dst-only"))
13278 else if (unformat (input, "src-dst"))
13282 errmsg ("parse error '%U'", format_unformat_error, input);
13287 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
13294 /* wait for reply */
13302 * Enable/disable LISP proxy ITR.
13304 * @param vam vpp API test context
13305 * @return return code
13308 api_lisp_pitr_set_locator_set (vat_main_t * vam)
13311 u8 ls_name_set = 0;
13312 unformat_input_t *input = vam->input;
13313 vl_api_lisp_pitr_set_locator_set_t *mp;
13317 /* Parse args required to build the message */
13318 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13320 if (unformat (input, "del"))
13322 else if (unformat (input, "locator-set %s", &ls_name))
13326 errmsg ("parse error '%U'", format_unformat_error, input);
13333 errmsg ("locator-set name not set!");
13337 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
13339 mp->is_add = is_add;
13340 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
13341 vec_free (ls_name);
13346 /* wait for reply */
13354 api_show_lisp_pitr (vat_main_t * vam)
13356 vl_api_show_lisp_pitr_t *mp;
13359 if (!vam->json_output)
13361 fformat (vam->ofp, "%=20s\n", "lisp status:");
13364 M (SHOW_LISP_PITR, show_lisp_pitr);
13368 /* Wait for a reply... */
13376 * Add/delete mapping between vni and vrf
13379 api_lisp_eid_table_add_del_map (vat_main_t * vam)
13382 unformat_input_t *input = vam->input;
13383 vl_api_lisp_eid_table_add_del_map_t *mp;
13384 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
13385 u32 vni, vrf, bd_index;
13387 /* Parse args required to build the message */
13388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13390 if (unformat (input, "del"))
13392 else if (unformat (input, "vrf %d", &vrf))
13394 else if (unformat (input, "bd_index %d", &bd_index))
13396 else if (unformat (input, "vni %d", &vni))
13402 if (!vni_set || (!vrf_set && !bd_index_set))
13404 errmsg ("missing arguments!");
13408 if (vrf_set && bd_index_set)
13410 errmsg ("error: both vrf and bd entered!");
13414 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
13416 mp->is_add = is_add;
13417 mp->vni = htonl (vni);
13418 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
13419 mp->is_l2 = bd_index_set;
13424 /* wait for reply */
13432 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
13434 u32 *action = va_arg (*args, u32 *);
13437 if (unformat (input, "%s", &s))
13439 if (!strcmp ((char *) s, "no-action"))
13441 else if (!strcmp ((char *) s, "natively-forward"))
13443 else if (!strcmp ((char *) s, "send-map-request"))
13445 else if (!strcmp ((char *) s, "drop"))
13449 clib_warning ("invalid action: '%s'", s);
13461 * Add/del remote mapping to/from LISP control plane
13463 * @param vam vpp API test context
13464 * @return return code
13467 api_lisp_add_del_remote_mapping (vat_main_t * vam)
13469 unformat_input_t *input = vam->input;
13470 vl_api_lisp_add_del_remote_mapping_t *mp;
13473 lisp_eid_vat_t _eid, *eid = &_eid;
13474 lisp_eid_vat_t _seid, *seid = &_seid;
13475 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
13476 u32 action = ~0, p, w, data_len;
13477 ip4_address_t rloc4;
13478 ip6_address_t rloc6;
13479 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
13481 memset (&rloc, 0, sizeof (rloc));
13483 /* Parse args required to build the message */
13484 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13486 if (unformat (input, "del-all"))
13490 else if (unformat (input, "del"))
13494 else if (unformat (input, "add"))
13498 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13502 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
13506 else if (unformat (input, "vni %d", &vni))
13510 else if (unformat (input, "p %d w %d", &p, &w))
13514 errmsg ("No RLOC configured for setting priority/weight!");
13517 curr_rloc->priority = p;
13518 curr_rloc->weight = w;
13520 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
13523 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
13524 vec_add1 (rlocs, rloc);
13525 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13527 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
13530 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
13531 vec_add1 (rlocs, rloc);
13532 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13534 else if (unformat (input, "action %U",
13535 unformat_negative_mapping_action, &action))
13541 clib_warning ("parse error '%U'", format_unformat_error, input);
13548 errmsg ("missing params!");
13552 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
13554 errmsg ("no action set for negative map-reply!");
13558 data_len = vec_len (rlocs) * sizeof (rloc_t);
13560 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
13561 mp->is_add = is_add;
13562 mp->vni = htonl (vni);
13563 mp->action = (u8) action;
13564 mp->is_src_dst = seid_set;
13565 mp->eid_len = eid->len;
13566 mp->seid_len = seid->len;
13567 mp->del_all = del_all;
13568 mp->eid_type = eid->type;
13569 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13570 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
13572 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
13573 clib_memcpy (mp->rlocs, rlocs, data_len);
13579 /* Wait for a reply... */
13587 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
13588 * forwarding entries in data-plane accordingly.
13590 * @param vam vpp API test context
13591 * @return return code
13594 api_lisp_add_del_adjacency (vat_main_t * vam)
13596 unformat_input_t *input = vam->input;
13597 vl_api_lisp_add_del_adjacency_t *mp;
13600 ip4_address_t leid4, reid4;
13601 ip6_address_t leid6, reid6;
13602 u8 reid_mac[6] = { 0 };
13603 u8 leid_mac[6] = { 0 };
13604 u8 reid_type, leid_type;
13605 u32 leid_len = 0, reid_len = 0, len;
13608 leid_type = reid_type = (u8) ~ 0;
13610 /* Parse args required to build the message */
13611 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13613 if (unformat (input, "del"))
13617 else if (unformat (input, "add"))
13621 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
13624 reid_type = 0; /* ipv4 */
13627 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
13630 reid_type = 1; /* ipv6 */
13633 else if (unformat (input, "reid %U", unformat_ethernet_address,
13636 reid_type = 2; /* mac */
13638 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
13641 leid_type = 0; /* ipv4 */
13644 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
13647 leid_type = 1; /* ipv6 */
13650 else if (unformat (input, "leid %U", unformat_ethernet_address,
13653 leid_type = 2; /* mac */
13655 else if (unformat (input, "vni %d", &vni))
13661 errmsg ("parse error '%U'", format_unformat_error, input);
13666 if ((u8) ~ 0 == reid_type)
13668 errmsg ("missing params!");
13672 if (leid_type != reid_type)
13674 errmsg ("remote and local EIDs are of different types!");
13678 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
13679 mp->is_add = is_add;
13680 mp->vni = htonl (vni);
13681 mp->leid_len = leid_len;
13682 mp->reid_len = reid_len;
13683 mp->eid_type = reid_type;
13685 switch (mp->eid_type)
13688 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
13689 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
13692 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
13693 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
13696 clib_memcpy (mp->leid, leid_mac, 6);
13697 clib_memcpy (mp->reid, reid_mac, 6);
13700 errmsg ("unknown EID type %d!", mp->eid_type);
13707 /* Wait for a reply... */
13715 api_lisp_gpe_add_del_iface (vat_main_t * vam)
13717 unformat_input_t *input = vam->input;
13718 vl_api_lisp_gpe_add_del_iface_t *mp;
13720 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
13721 u32 dp_table = 0, vni = 0;
13723 /* Parse args required to build the message */
13724 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13726 if (unformat (input, "up"))
13731 else if (unformat (input, "down"))
13736 else if (unformat (input, "table_id %d", &dp_table))
13740 else if (unformat (input, "bd_id %d", &dp_table))
13745 else if (unformat (input, "vni %d", &vni))
13753 if (action_set == 0)
13755 errmsg ("Action not set\n");
13758 if (dp_table_set == 0 || vni_set == 0)
13760 errmsg ("vni and dp_table must be set\n");
13764 /* Construct the API message */
13765 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
13767 mp->is_add = is_add;
13768 mp->dp_table = dp_table;
13775 /* Wait for a reply... */
13783 * Add/del map request itr rlocs from LISP control plane and updates
13785 * @param vam vpp API test context
13786 * @return return code
13789 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
13791 unformat_input_t *input = vam->input;
13792 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
13794 u8 *locator_set_name = 0;
13795 u8 locator_set_name_set = 0;
13798 /* Parse args required to build the message */
13799 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13801 if (unformat (input, "del"))
13805 else if (unformat (input, "%_%v%_", &locator_set_name))
13807 locator_set_name_set = 1;
13811 clib_warning ("parse error '%U'", format_unformat_error, input);
13816 if (is_add && !locator_set_name_set)
13818 errmsg ("itr-rloc is not set!");
13822 if (is_add && vec_len (locator_set_name) > 64)
13824 errmsg ("itr-rloc locator-set name too long\n");
13825 vec_free (locator_set_name);
13829 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
13830 mp->is_add = is_add;
13833 clib_memcpy (mp->locator_set_name, locator_set_name,
13834 vec_len (locator_set_name));
13838 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
13840 vec_free (locator_set_name);
13845 /* Wait for a reply... */
13853 api_lisp_locator_dump (vat_main_t * vam)
13855 unformat_input_t *input = vam->input;
13856 vl_api_lisp_locator_dump_t *mp;
13858 u8 is_index_set = 0, is_name_set = 0;
13862 /* Parse args required to build the message */
13863 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13865 if (unformat (input, "ls_name %_%v%_", &ls_name))
13869 else if (unformat (input, "ls_index %d", &ls_index))
13875 errmsg ("parse error '%U'", format_unformat_error, input);
13880 if (!is_index_set && !is_name_set)
13882 errmsg ("error: expected one of index or name!\n");
13886 if (is_index_set && is_name_set)
13888 errmsg ("error: only one param expected!\n");
13892 if (vec_len (ls_name) > 62)
13894 errmsg ("error: locator set name too long!");
13898 if (!vam->json_output)
13900 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
13904 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
13905 mp->is_index_set = is_index_set;
13908 mp->ls_index = clib_host_to_net_u32 (ls_index);
13911 vec_add1 (ls_name, 0);
13912 strncpy ((char *) mp->ls_name, (char *) ls_name,
13913 sizeof (mp->ls_name) - 1);
13919 /* Use a control ping for synchronization */
13921 vl_api_control_ping_t *mp;
13922 M (CONTROL_PING, control_ping);
13925 /* Wait for a reply... */
13933 api_lisp_locator_set_dump (vat_main_t * vam)
13935 vl_api_lisp_locator_set_dump_t *mp;
13936 unformat_input_t *input = vam->input;
13940 /* Parse args required to build the message */
13941 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13943 if (unformat (input, "local"))
13947 else if (unformat (input, "remote"))
13953 errmsg ("parse error '%U'", format_unformat_error, input);
13958 if (!vam->json_output)
13960 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13963 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13965 mp->filter = filter;
13970 /* Use a control ping for synchronization */
13972 vl_api_control_ping_t *mp;
13973 M (CONTROL_PING, control_ping);
13976 /* Wait for a reply... */
13984 api_lisp_eid_table_map_dump (vat_main_t * vam)
13988 unformat_input_t *input = vam->input;
13989 vl_api_lisp_eid_table_map_dump_t *mp;
13992 /* Parse args required to build the message */
13993 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13995 if (unformat (input, "l2"))
14000 else if (unformat (input, "l3"))
14007 errmsg ("parse error '%U'", format_unformat_error, input);
14014 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
14018 if (!vam->json_output)
14020 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
14023 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
14029 /* Use a control ping for synchronization */
14031 vl_api_control_ping_t *mp;
14032 M (CONTROL_PING, control_ping);
14035 /* Wait for a reply... */
14043 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14045 vl_api_lisp_eid_table_vni_dump_t *mp;
14048 if (!vam->json_output)
14050 fformat (vam->ofp, "VNI\n");
14053 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
14058 /* Use a control ping for synchronization */
14060 vl_api_control_ping_t *mp;
14061 M (CONTROL_PING, control_ping);
14064 /* Wait for a reply... */
14072 api_lisp_eid_table_dump (vat_main_t * vam)
14074 unformat_input_t *i = vam->input;
14075 vl_api_lisp_eid_table_dump_t *mp;
14077 struct in_addr ip4;
14078 struct in6_addr ip6;
14080 u8 eid_type = ~0, eid_set = 0;
14081 u32 prefix_length = ~0, t, vni = 0;
14084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14086 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14092 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14098 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14103 else if (unformat (i, "vni %d", &t))
14107 else if (unformat (i, "local"))
14111 else if (unformat (i, "remote"))
14117 errmsg ("parse error '%U'", format_unformat_error, i);
14122 if (!vam->json_output)
14124 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
14125 "ls_index", "ttl", "authoritative");
14128 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14130 mp->filter = filter;
14134 mp->vni = htonl (vni);
14135 mp->eid_type = eid_type;
14139 mp->prefix_length = prefix_length;
14140 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14143 mp->prefix_length = prefix_length;
14144 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14147 clib_memcpy (mp->eid, mac, sizeof (mac));
14150 errmsg ("unknown EID type %d!", eid_type);
14158 /* Use a control ping for synchronization */
14160 vl_api_control_ping_t *mp;
14161 M (CONTROL_PING, control_ping);
14165 /* Wait for a reply... */
14173 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
14175 vl_api_lisp_gpe_tunnel_dump_t *mp;
14178 if (!vam->json_output)
14180 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
14181 "%=16s%=16s%=16s%=16s%=16s\n",
14182 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
14183 "Decap next", "Lisp version", "Flags", "Next protocol",
14184 "ver_res", "res", "iid");
14187 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
14191 /* Use a control ping for synchronization */
14193 vl_api_control_ping_t *mp;
14194 M (CONTROL_PING, control_ping);
14197 /* Wait for a reply... */
14205 api_lisp_adjacencies_get (vat_main_t * vam)
14207 unformat_input_t *i = vam->input;
14208 vl_api_lisp_adjacencies_get_t *mp;
14213 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14215 if (unformat (i, "vni %d", &vni))
14221 errmsg ("parse error '%U'\n", format_unformat_error, i);
14228 errmsg ("vni not set!\n");
14232 if (!vam->json_output)
14234 fformat (vam->ofp, "%s %40s\n", "leid", "reid");
14237 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
14238 mp->vni = clib_host_to_net_u32 (vni);
14243 /* Wait for a reply... */
14251 api_lisp_map_resolver_dump (vat_main_t * vam)
14253 vl_api_lisp_map_resolver_dump_t *mp;
14256 if (!vam->json_output)
14258 fformat (vam->ofp, "%=20s\n", "Map resolver");
14261 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
14265 /* Use a control ping for synchronization */
14267 vl_api_control_ping_t *mp;
14268 M (CONTROL_PING, control_ping);
14271 /* Wait for a reply... */
14279 api_show_lisp_status (vat_main_t * vam)
14281 vl_api_show_lisp_status_t *mp;
14284 if (!vam->json_output)
14286 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
14289 M (SHOW_LISP_STATUS, show_lisp_status);
14292 /* Wait for a reply... */
14300 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
14302 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
14305 if (!vam->json_output)
14307 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
14310 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
14313 /* Wait for a reply... */
14321 api_af_packet_create (vat_main_t * vam)
14323 unformat_input_t *i = vam->input;
14324 vl_api_af_packet_create_t *mp;
14326 u8 *host_if_name = 0;
14328 u8 random_hw_addr = 1;
14330 memset (hw_addr, 0, sizeof (hw_addr));
14332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14334 if (unformat (i, "name %s", &host_if_name))
14335 vec_add1 (host_if_name, 0);
14336 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14337 random_hw_addr = 0;
14342 if (!vec_len (host_if_name))
14344 errmsg ("host-interface name must be specified");
14348 if (vec_len (host_if_name) > 64)
14350 errmsg ("host-interface name too long");
14354 M (AF_PACKET_CREATE, af_packet_create);
14356 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14357 clib_memcpy (mp->hw_addr, hw_addr, 6);
14358 mp->use_random_hw_addr = random_hw_addr;
14359 vec_free (host_if_name);
14362 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
14368 api_af_packet_delete (vat_main_t * vam)
14370 unformat_input_t *i = vam->input;
14371 vl_api_af_packet_delete_t *mp;
14373 u8 *host_if_name = 0;
14375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14377 if (unformat (i, "name %s", &host_if_name))
14378 vec_add1 (host_if_name, 0);
14383 if (!vec_len (host_if_name))
14385 errmsg ("host-interface name must be specified");
14389 if (vec_len (host_if_name) > 64)
14391 errmsg ("host-interface name too long");
14395 M (AF_PACKET_DELETE, af_packet_delete);
14397 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14398 vec_free (host_if_name);
14407 api_policer_add_del (vat_main_t * vam)
14409 unformat_input_t *i = vam->input;
14410 vl_api_policer_add_del_t *mp;
14421 u8 color_aware = 0;
14422 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
14424 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
14425 conform_action.dscp = 0;
14426 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
14427 exceed_action.dscp = 0;
14428 violate_action.action_type = SSE2_QOS_ACTION_DROP;
14429 violate_action.dscp = 0;
14431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14433 if (unformat (i, "del"))
14435 else if (unformat (i, "name %s", &name))
14436 vec_add1 (name, 0);
14437 else if (unformat (i, "cir %u", &cir))
14439 else if (unformat (i, "eir %u", &eir))
14441 else if (unformat (i, "cb %u", &cb))
14443 else if (unformat (i, "eb %u", &eb))
14445 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
14448 else if (unformat (i, "round_type %U", unformat_policer_round_type,
14451 else if (unformat (i, "type %U", unformat_policer_type, &type))
14453 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
14456 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
14459 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
14462 else if (unformat (i, "color-aware"))
14468 if (!vec_len (name))
14470 errmsg ("policer name must be specified");
14474 if (vec_len (name) > 64)
14476 errmsg ("policer name too long");
14480 M (POLICER_ADD_DEL, policer_add_del);
14482 clib_memcpy (mp->name, name, vec_len (name));
14484 mp->is_add = is_add;
14489 mp->rate_type = rate_type;
14490 mp->round_type = round_type;
14492 mp->conform_action_type = conform_action.action_type;
14493 mp->conform_dscp = conform_action.dscp;
14494 mp->exceed_action_type = exceed_action.action_type;
14495 mp->exceed_dscp = exceed_action.dscp;
14496 mp->violate_action_type = violate_action.action_type;
14497 mp->violate_dscp = violate_action.dscp;
14498 mp->color_aware = color_aware;
14507 api_policer_dump (vat_main_t * vam)
14509 unformat_input_t *i = vam->input;
14510 vl_api_policer_dump_t *mp;
14512 u8 *match_name = 0;
14513 u8 match_name_valid = 0;
14515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14517 if (unformat (i, "name %s", &match_name))
14519 vec_add1 (match_name, 0);
14520 match_name_valid = 1;
14526 M (POLICER_DUMP, policer_dump);
14527 mp->match_name_valid = match_name_valid;
14528 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
14529 vec_free (match_name);
14533 /* Use a control ping for synchronization */
14535 vl_api_control_ping_t *mp;
14536 M (CONTROL_PING, control_ping);
14539 /* Wait for a reply... */
14547 api_policer_classify_set_interface (vat_main_t * vam)
14549 unformat_input_t *i = vam->input;
14550 vl_api_policer_classify_set_interface_t *mp;
14553 int sw_if_index_set;
14554 u32 ip4_table_index = ~0;
14555 u32 ip6_table_index = ~0;
14556 u32 l2_table_index = ~0;
14559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14561 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
14562 sw_if_index_set = 1;
14563 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14564 sw_if_index_set = 1;
14565 else if (unformat (i, "del"))
14567 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14569 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14571 else if (unformat (i, "l2-table %d", &l2_table_index))
14575 clib_warning ("parse error '%U'", format_unformat_error, i);
14580 if (sw_if_index_set == 0)
14582 errmsg ("missing interface name or sw_if_index\n");
14586 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
14588 mp->sw_if_index = ntohl (sw_if_index);
14589 mp->ip4_table_index = ntohl (ip4_table_index);
14590 mp->ip6_table_index = ntohl (ip6_table_index);
14591 mp->l2_table_index = ntohl (l2_table_index);
14592 mp->is_add = is_add;
14601 api_policer_classify_dump (vat_main_t * vam)
14603 unformat_input_t *i = vam->input;
14604 vl_api_policer_classify_dump_t *mp;
14606 u8 type = POLICER_CLASSIFY_N_TABLES;
14608 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
14612 errmsg ("classify table type must be specified\n");
14616 if (!vam->json_output)
14618 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14621 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14626 /* Use a control ping for synchronization */
14628 vl_api_control_ping_t *mp;
14629 M (CONTROL_PING, control_ping);
14632 /* Wait for a reply... */
14640 api_netmap_create (vat_main_t * vam)
14642 unformat_input_t *i = vam->input;
14643 vl_api_netmap_create_t *mp;
14647 u8 random_hw_addr = 1;
14651 memset (hw_addr, 0, sizeof (hw_addr));
14653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14655 if (unformat (i, "name %s", &if_name))
14656 vec_add1 (if_name, 0);
14657 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14658 random_hw_addr = 0;
14659 else if (unformat (i, "pipe"))
14661 else if (unformat (i, "master"))
14663 else if (unformat (i, "slave"))
14669 if (!vec_len (if_name))
14671 errmsg ("interface name must be specified");
14675 if (vec_len (if_name) > 64)
14677 errmsg ("interface name too long");
14681 M (NETMAP_CREATE, netmap_create);
14683 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14684 clib_memcpy (mp->hw_addr, hw_addr, 6);
14685 mp->use_random_hw_addr = random_hw_addr;
14686 mp->is_pipe = is_pipe;
14687 mp->is_master = is_master;
14688 vec_free (if_name);
14697 api_netmap_delete (vat_main_t * vam)
14699 unformat_input_t *i = vam->input;
14700 vl_api_netmap_delete_t *mp;
14704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14706 if (unformat (i, "name %s", &if_name))
14707 vec_add1 (if_name, 0);
14712 if (!vec_len (if_name))
14714 errmsg ("interface name must be specified");
14718 if (vec_len (if_name) > 64)
14720 errmsg ("interface name too long");
14724 M (NETMAP_DELETE, netmap_delete);
14726 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14727 vec_free (if_name);
14735 static void vl_api_mpls_eth_tunnel_details_t_handler
14736 (vl_api_mpls_eth_tunnel_details_t * mp)
14738 vat_main_t *vam = &vat_main;
14740 i32 len = ntohl (mp->nlabels);
14742 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14743 ntohl (mp->tunnel_index),
14744 format_ethernet_address, &mp->tunnel_dst_mac,
14745 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14746 for (i = 0; i < len; i++)
14748 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14750 fformat (vam->ofp, "\n");
14751 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14752 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14755 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14756 (vl_api_mpls_eth_tunnel_details_t * mp)
14758 vat_main_t *vam = &vat_main;
14759 vat_json_node_t *node = NULL;
14760 struct in_addr ip4;
14762 i32 len = ntohl (mp->nlabels);
14764 if (VAT_JSON_ARRAY != vam->json_tree.type)
14766 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14767 vat_json_init_array (&vam->json_tree);
14769 node = vat_json_array_add (&vam->json_tree);
14771 vat_json_init_object (node);
14772 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14773 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14774 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14775 vat_json_object_add_uint (node, "inner_fib_index",
14776 ntohl (mp->inner_fib_index));
14777 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14778 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14779 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14780 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14781 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14782 format (0, "%U", format_ethernet_address,
14783 &mp->tunnel_dst_mac));
14784 vat_json_object_add_uint (node, "tx_sw_if_index",
14785 ntohl (mp->tx_sw_if_index));
14786 vat_json_object_add_uint (node, "label_count", len);
14787 for (i = 0; i < len; i++)
14789 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14794 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14796 vl_api_mpls_eth_tunnel_dump_t *mp;
14800 /* Parse args required to build the message */
14801 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14803 if (!unformat (vam->input, "tunnel_index %d", &index))
14810 fformat (vam->ofp, " tunnel_index %d\n", index);
14812 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14813 mp->tunnel_index = htonl (index);
14816 /* Use a control ping for synchronization */
14818 vl_api_control_ping_t *mp;
14819 M (CONTROL_PING, control_ping);
14825 static void vl_api_mpls_fib_encap_details_t_handler
14826 (vl_api_mpls_fib_encap_details_t * mp)
14828 vat_main_t *vam = &vat_main;
14830 i32 len = ntohl (mp->nlabels);
14832 fformat (vam->ofp, "table %d, dest %U, label ",
14833 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14834 for (i = 0; i < len; i++)
14836 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14838 fformat (vam->ofp, "\n");
14841 static void vl_api_mpls_fib_encap_details_t_handler_json
14842 (vl_api_mpls_fib_encap_details_t * mp)
14844 vat_main_t *vam = &vat_main;
14845 vat_json_node_t *node = NULL;
14847 i32 len = ntohl (mp->nlabels);
14848 struct in_addr ip4;
14850 if (VAT_JSON_ARRAY != vam->json_tree.type)
14852 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14853 vat_json_init_array (&vam->json_tree);
14855 node = vat_json_array_add (&vam->json_tree);
14857 vat_json_init_object (node);
14858 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14859 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14860 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14861 vat_json_object_add_ip4 (node, "dest", ip4);
14862 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14863 vat_json_object_add_uint (node, "label_count", len);
14864 for (i = 0; i < len; i++)
14866 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14871 api_mpls_fib_encap_dump (vat_main_t * vam)
14873 vl_api_mpls_fib_encap_dump_t *mp;
14876 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14879 /* Use a control ping for synchronization */
14881 vl_api_control_ping_t *mp;
14882 M (CONTROL_PING, control_ping);
14888 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
14889 #define vl_api_mpls_fib_details_t_print vl_noop_handler
14892 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
14894 vat_main_t *vam = &vat_main;
14895 int count = ntohl (mp->count);
14896 vl_api_fib_path_t *fp;
14900 "table-id %d, label %u, ess_bit %u\n",
14901 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
14903 for (i = 0; i < count; i++)
14905 if (fp->afi == IP46_TYPE_IP6)
14907 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
14908 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
14909 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
14910 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
14911 format_ip6_address, fp->next_hop);
14912 else if (fp->afi == IP46_TYPE_IP4)
14914 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
14915 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
14916 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
14917 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
14918 format_ip4_address, fp->next_hop);
14923 static void vl_api_mpls_fib_details_t_handler_json
14924 (vl_api_mpls_fib_details_t * mp)
14926 vat_main_t *vam = &vat_main;
14927 int count = ntohl (mp->count);
14928 vat_json_node_t *node = NULL;
14929 struct in_addr ip4;
14930 struct in6_addr ip6;
14931 vl_api_fib_path_t *fp;
14934 if (VAT_JSON_ARRAY != vam->json_tree.type)
14936 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14937 vat_json_init_array (&vam->json_tree);
14939 node = vat_json_array_add (&vam->json_tree);
14941 vat_json_init_object (node);
14942 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
14943 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
14944 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14945 vat_json_object_add_uint (node, "path_count", count);
14947 for (i = 0; i < count; i++)
14949 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
14950 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
14951 vat_json_object_add_uint (node, "is_local", fp->is_local);
14952 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
14953 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
14954 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
14955 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
14956 if (fp->afi == IP46_TYPE_IP4)
14958 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
14959 vat_json_object_add_ip4 (node, "next_hop", ip4);
14961 else if (fp->afi == IP46_TYPE_IP6)
14963 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
14964 vat_json_object_add_ip6 (node, "next_hop", ip6);
14970 api_mpls_fib_dump (vat_main_t * vam)
14972 vl_api_mpls_fib_dump_t *mp;
14975 M (MPLS_FIB_DUMP, mpls_fib_dump);
14978 /* Use a control ping for synchronization */
14980 vl_api_control_ping_t *mp;
14981 M (CONTROL_PING, control_ping);
14987 #define vl_api_ip_fib_details_t_endian vl_noop_handler
14988 #define vl_api_ip_fib_details_t_print vl_noop_handler
14991 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
14993 vat_main_t *vam = &vat_main;
14994 int count = ntohl (mp->count);
14995 vl_api_fib_path_t *fp;
14999 "table-id %d, prefix %U/%d\n",
15000 ntohl (mp->table_id), format_ip4_address, mp->address,
15001 mp->address_length);
15003 for (i = 0; i < count; i++)
15005 if (fp->afi == IP46_TYPE_IP6)
15007 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15008 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15009 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15010 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15011 format_ip6_address, fp->next_hop);
15012 else if (fp->afi == IP46_TYPE_IP4)
15014 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15015 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15016 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15017 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15018 format_ip4_address, fp->next_hop);
15023 static void vl_api_ip_fib_details_t_handler_json
15024 (vl_api_ip_fib_details_t * mp)
15026 vat_main_t *vam = &vat_main;
15027 int count = ntohl (mp->count);
15028 vat_json_node_t *node = NULL;
15029 struct in_addr ip4;
15030 struct in6_addr ip6;
15031 vl_api_fib_path_t *fp;
15034 if (VAT_JSON_ARRAY != vam->json_tree.type)
15036 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15037 vat_json_init_array (&vam->json_tree);
15039 node = vat_json_array_add (&vam->json_tree);
15041 vat_json_init_object (node);
15042 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15043 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15044 vat_json_object_add_ip4 (node, "prefix", ip4);
15045 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15046 vat_json_object_add_uint (node, "path_count", count);
15048 for (i = 0; i < count; i++)
15050 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15051 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15052 vat_json_object_add_uint (node, "is_local", fp->is_local);
15053 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15054 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15055 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15056 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15057 if (fp->afi == IP46_TYPE_IP4)
15059 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15060 vat_json_object_add_ip4 (node, "next_hop", ip4);
15062 else if (fp->afi == IP46_TYPE_IP6)
15064 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15065 vat_json_object_add_ip6 (node, "next_hop", ip6);
15071 api_ip_fib_dump (vat_main_t * vam)
15073 vl_api_ip_fib_dump_t *mp;
15076 M (IP_FIB_DUMP, ip_fib_dump);
15079 /* Use a control ping for synchronization */
15081 vl_api_control_ping_t *mp;
15082 M (CONTROL_PING, control_ping);
15088 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15089 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15092 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15094 vat_main_t *vam = &vat_main;
15095 int count = ntohl (mp->count);
15096 vl_api_fib_path_t *fp;
15100 "table-id %d, prefix %U/%d\n",
15101 ntohl (mp->table_id), format_ip6_address, mp->address,
15102 mp->address_length);
15104 for (i = 0; i < count; i++)
15106 if (fp->afi == IP46_TYPE_IP6)
15108 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15109 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15110 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15111 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15112 format_ip6_address, fp->next_hop);
15113 else if (fp->afi == IP46_TYPE_IP4)
15115 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15116 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15117 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15118 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15119 format_ip4_address, fp->next_hop);
15124 static void vl_api_ip6_fib_details_t_handler_json
15125 (vl_api_ip6_fib_details_t * mp)
15127 vat_main_t *vam = &vat_main;
15128 int count = ntohl (mp->count);
15129 vat_json_node_t *node = NULL;
15130 struct in_addr ip4;
15131 struct in6_addr ip6;
15132 vl_api_fib_path_t *fp;
15135 if (VAT_JSON_ARRAY != vam->json_tree.type)
15137 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15138 vat_json_init_array (&vam->json_tree);
15140 node = vat_json_array_add (&vam->json_tree);
15142 vat_json_init_object (node);
15143 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15144 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15145 vat_json_object_add_ip6 (node, "prefix", ip6);
15146 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15147 vat_json_object_add_uint (node, "path_count", count);
15149 for (i = 0; i < count; i++)
15151 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15152 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15153 vat_json_object_add_uint (node, "is_local", fp->is_local);
15154 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15155 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15156 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15157 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15158 if (fp->afi == IP46_TYPE_IP4)
15160 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15161 vat_json_object_add_ip4 (node, "next_hop", ip4);
15163 else if (fp->afi == IP46_TYPE_IP6)
15165 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15166 vat_json_object_add_ip6 (node, "next_hop", ip6);
15172 api_ip6_fib_dump (vat_main_t * vam)
15174 vl_api_ip6_fib_dump_t *mp;
15177 M (IP6_FIB_DUMP, ip6_fib_dump);
15180 /* Use a control ping for synchronization */
15182 vl_api_control_ping_t *mp;
15183 M (CONTROL_PING, control_ping);
15190 api_classify_table_ids (vat_main_t * vam)
15192 vl_api_classify_table_ids_t *mp;
15195 /* Construct the API message */
15196 M (CLASSIFY_TABLE_IDS, classify_table_ids);
15206 api_classify_table_by_interface (vat_main_t * vam)
15208 unformat_input_t *input = vam->input;
15209 vl_api_classify_table_by_interface_t *mp;
15212 u32 sw_if_index = ~0;
15213 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15215 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15217 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15222 if (sw_if_index == ~0)
15224 errmsg ("missing interface name or sw_if_index\n");
15228 /* Construct the API message */
15229 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
15231 mp->sw_if_index = ntohl (sw_if_index);
15240 api_classify_table_info (vat_main_t * vam)
15242 unformat_input_t *input = vam->input;
15243 vl_api_classify_table_info_t *mp;
15247 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15249 if (unformat (input, "table_id %d", &table_id))
15254 if (table_id == ~0)
15256 errmsg ("missing table id\n");
15260 /* Construct the API message */
15261 M (CLASSIFY_TABLE_INFO, classify_table_info);
15263 mp->table_id = ntohl (table_id);
15272 api_classify_session_dump (vat_main_t * vam)
15274 unformat_input_t *input = vam->input;
15275 vl_api_classify_session_dump_t *mp;
15279 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15281 if (unformat (input, "table_id %d", &table_id))
15286 if (table_id == ~0)
15288 errmsg ("missing table id\n");
15292 /* Construct the API message */
15293 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
15295 mp->table_id = ntohl (table_id);
15298 /* Use a control ping for synchronization */
15300 vl_api_control_ping_t *mp;
15301 M (CONTROL_PING, control_ping);
15310 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
15312 vat_main_t *vam = &vat_main;
15314 fformat (vam->ofp, "collector_address %U, collector_port %d, "
15315 "src_address %U, vrf_id %d, path_mtu %u, "
15316 "template_interval %u, udp_checksum %d\n",
15317 format_ip4_address, mp->collector_address,
15318 ntohs (mp->collector_port),
15319 format_ip4_address, mp->src_address,
15320 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
15321 ntohl (mp->template_interval), mp->udp_checksum);
15324 vam->result_ready = 1;
15328 vl_api_ipfix_exporter_details_t_handler_json
15329 (vl_api_ipfix_exporter_details_t * mp)
15331 vat_main_t *vam = &vat_main;
15332 vat_json_node_t node;
15333 struct in_addr collector_address;
15334 struct in_addr src_address;
15336 vat_json_init_object (&node);
15337 clib_memcpy (&collector_address, &mp->collector_address,
15338 sizeof (collector_address));
15339 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
15340 vat_json_object_add_uint (&node, "collector_port",
15341 ntohs (mp->collector_port));
15342 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
15343 vat_json_object_add_ip4 (&node, "src_address", src_address);
15344 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
15345 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
15346 vat_json_object_add_uint (&node, "template_interval",
15347 ntohl (mp->template_interval));
15348 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
15350 vat_json_print (vam->ofp, &node);
15351 vat_json_free (&node);
15353 vam->result_ready = 1;
15357 api_ipfix_exporter_dump (vat_main_t * vam)
15359 vl_api_ipfix_exporter_dump_t *mp;
15362 /* Construct the API message */
15363 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
15373 api_ipfix_classify_stream_dump (vat_main_t * vam)
15375 vl_api_ipfix_classify_stream_dump_t *mp;
15378 /* Construct the API message */
15379 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
15389 vl_api_ipfix_classify_stream_details_t_handler
15390 (vl_api_ipfix_classify_stream_details_t * mp)
15392 vat_main_t *vam = &vat_main;
15393 fformat (vam->ofp, "domain_id %d, src_port %d\n",
15394 ntohl (mp->domain_id), ntohs (mp->src_port));
15396 vam->result_ready = 1;
15400 vl_api_ipfix_classify_stream_details_t_handler_json
15401 (vl_api_ipfix_classify_stream_details_t * mp)
15403 vat_main_t *vam = &vat_main;
15404 vat_json_node_t node;
15406 vat_json_init_object (&node);
15407 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
15408 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
15410 vat_json_print (vam->ofp, &node);
15411 vat_json_free (&node);
15413 vam->result_ready = 1;
15417 api_ipfix_classify_table_dump (vat_main_t * vam)
15419 vl_api_ipfix_classify_table_dump_t *mp;
15422 if (!vam->json_output)
15424 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
15425 "transport_protocol");
15428 /* Construct the API message */
15429 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
15434 /* Use a control ping for synchronization */
15436 vl_api_control_ping_t *mp;
15437 M (CONTROL_PING, control_ping);
15444 vl_api_ipfix_classify_table_details_t_handler
15445 (vl_api_ipfix_classify_table_details_t * mp)
15447 vat_main_t *vam = &vat_main;
15448 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
15449 mp->transport_protocol);
15453 vl_api_ipfix_classify_table_details_t_handler_json
15454 (vl_api_ipfix_classify_table_details_t * mp)
15456 vat_json_node_t *node = NULL;
15457 vat_main_t *vam = &vat_main;
15459 if (VAT_JSON_ARRAY != vam->json_tree.type)
15461 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15462 vat_json_init_array (&vam->json_tree);
15465 node = vat_json_array_add (&vam->json_tree);
15466 vat_json_init_object (node);
15468 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
15469 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
15470 vat_json_object_add_uint (node, "transport_protocol",
15471 mp->transport_protocol);
15475 api_sw_interface_span_enable_disable (vat_main_t * vam)
15477 unformat_input_t *i = vam->input;
15478 vl_api_sw_interface_span_enable_disable_t *mp;
15480 u32 src_sw_if_index = ~0;
15481 u32 dst_sw_if_index = ~0;
15484 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15486 if (unformat (i, "src %U", unformat_sw_if_index, vam, &src_sw_if_index))
15488 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
15492 (i, "dst %U", unformat_sw_if_index, vam, &dst_sw_if_index))
15494 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
15496 else if (unformat (i, "disable"))
15502 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable);
15504 mp->sw_if_index_from = htonl (src_sw_if_index);
15505 mp->sw_if_index_to = htonl (dst_sw_if_index);
15506 mp->enable = enable;
15515 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
15518 vat_main_t *vam = &vat_main;
15520 fformat (vam->ofp, "%u => %u\n",
15521 ntohl (mp->sw_if_index_from), ntohl (mp->sw_if_index_to));
15525 vl_api_sw_interface_span_details_t_handler_json
15526 (vl_api_sw_interface_span_details_t * mp)
15528 vat_main_t *vam = &vat_main;
15529 vat_json_node_t *node = NULL;
15531 if (VAT_JSON_ARRAY != vam->json_tree.type)
15533 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15534 vat_json_init_array (&vam->json_tree);
15536 node = vat_json_array_add (&vam->json_tree);
15538 vat_json_init_object (node);
15539 vat_json_object_add_uint (node, "src-if-index",
15540 ntohl (mp->sw_if_index_from));
15541 vat_json_object_add_uint (node, "dst-if-index", ntohl (mp->sw_if_index_to));
15545 api_sw_interface_span_dump (vat_main_t * vam)
15547 vl_api_sw_interface_span_dump_t *mp;
15550 M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump);
15553 /* Use a control ping for synchronization */
15555 vl_api_control_ping_t *mp;
15556 M (CONTROL_PING, control_ping);
15563 api_pg_create_interface (vat_main_t * vam)
15565 unformat_input_t *input = vam->input;
15566 vl_api_pg_create_interface_t *mp;
15570 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15572 if (unformat (input, "if_id %d", &if_id))
15579 errmsg ("missing pg interface index\n");
15583 /* Construct the API message */
15584 M (PG_CREATE_INTERFACE, pg_create_interface);
15586 mp->interface_id = ntohl (if_id);
15595 api_pg_capture (vat_main_t * vam)
15597 unformat_input_t *input = vam->input;
15598 vl_api_pg_capture_t *mp;
15604 u8 pcap_file_set = 0;
15606 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15608 if (unformat (input, "if_id %d", &if_id))
15610 else if (unformat (input, "pcap %s", &pcap_file))
15612 else if (unformat (input, "count %d", &count))
15614 else if (unformat (input, "disable"))
15621 errmsg ("missing pg interface index\n");
15624 if (pcap_file_set > 0)
15626 if (vec_len (pcap_file) > 255)
15628 errmsg ("pcap file name is too long\n");
15633 u32 name_len = vec_len (pcap_file);
15634 /* Construct the API message */
15635 M (PG_CAPTURE, pg_capture);
15637 mp->interface_id = ntohl (if_id);
15638 mp->is_enabled = enable;
15639 mp->count = ntohl (count);
15640 mp->pcap_name_length = ntohl (name_len);
15641 if (pcap_file_set != 0)
15643 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
15645 vec_free (pcap_file);
15654 api_pg_enable_disable (vat_main_t * vam)
15656 unformat_input_t *input = vam->input;
15657 vl_api_pg_enable_disable_t *mp;
15661 u8 stream_name_set = 0;
15662 u8 *stream_name = 0;
15663 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15665 if (unformat (input, "stream %s", &stream_name))
15666 stream_name_set = 1;
15667 else if (unformat (input, "disable"))
15673 if (stream_name_set > 0)
15675 if (vec_len (stream_name) > 255)
15677 errmsg ("stream name too long\n");
15682 u32 name_len = vec_len (stream_name);
15683 /* Construct the API message */
15684 M (PG_ENABLE_DISABLE, pg_enable_disable);
15686 mp->is_enabled = enable;
15687 if (stream_name_set != 0)
15689 mp->stream_name_length = ntohl (name_len);
15690 clib_memcpy (mp->stream_name, stream_name, name_len);
15692 vec_free (stream_name);
15701 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
15703 unformat_input_t *input = vam->input;
15704 vl_api_ip_source_and_port_range_check_add_del_t *mp;
15707 u16 *low_ports = 0;
15708 u16 *high_ports = 0;
15711 ip4_address_t ip4_addr;
15712 ip6_address_t ip6_addr;
15720 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15722 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
15728 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
15733 else if (unformat (input, "vrf %d", &vrf_id))
15735 else if (unformat (input, "del"))
15737 else if (unformat (input, "port %d", &tmp))
15739 if (tmp == 0 || tmp > 65535)
15741 errmsg ("port %d out of range", tmp);
15745 this_hi = this_low + 1;
15746 vec_add1 (low_ports, this_low);
15747 vec_add1 (high_ports, this_hi);
15749 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
15751 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
15753 errmsg ("incorrect range parameters\n");
15757 /* Note: in debug CLI +1 is added to high before
15758 passing to real fn that does "the work"
15759 (ip_source_and_port_range_check_add_del).
15760 This fn is a wrapper around the binary API fn a
15761 control plane will call, which expects this increment
15762 to have occurred. Hence letting the binary API control
15763 plane fn do the increment for consistency between VAT
15764 and other control planes.
15767 vec_add1 (low_ports, this_low);
15768 vec_add1 (high_ports, this_hi);
15774 if (prefix_set == 0)
15776 errmsg ("<address>/<mask> not specified\n");
15782 errmsg ("VRF ID required, not specified\n");
15789 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15793 if (vec_len (low_ports) == 0)
15795 errmsg ("At least one port or port range required\n");
15799 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
15800 ip_source_and_port_range_check_add_del);
15802 mp->is_add = is_add;
15807 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
15812 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
15815 mp->mask_length = length;
15816 mp->number_of_ranges = vec_len (low_ports);
15818 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
15819 vec_free (low_ports);
15821 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
15822 vec_free (high_ports);
15824 mp->vrf_id = ntohl (vrf_id);
15833 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
15835 unformat_input_t *input = vam->input;
15836 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
15838 u32 sw_if_index = ~0;
15840 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
15841 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
15844 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15846 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15848 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15850 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
15852 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
15854 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
15856 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15858 else if (unformat (input, "del"))
15864 if (sw_if_index == ~0)
15866 errmsg ("Interface required but not specified\n");
15872 errmsg ("VRF ID required but not specified\n");
15876 if (tcp_out_vrf_id == 0
15877 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15880 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15884 /* Construct the API message */
15885 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15886 ip_source_and_port_range_check_interface_add_del);
15888 mp->sw_if_index = ntohl (sw_if_index);
15889 mp->is_add = is_add;
15890 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15891 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15892 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15893 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15898 /* Wait for a reply... */
15903 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15905 unformat_input_t *i = vam->input;
15906 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15908 u32 local_sa_id = 0;
15909 u32 remote_sa_id = 0;
15910 ip4_address_t src_address;
15911 ip4_address_t dst_address;
15914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15916 if (unformat (i, "local_sa %d", &local_sa_id))
15918 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15920 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15922 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15924 else if (unformat (i, "del"))
15928 clib_warning ("parse error '%U'", format_unformat_error, i);
15933 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15935 mp->local_sa_id = ntohl (local_sa_id);
15936 mp->remote_sa_id = ntohl (remote_sa_id);
15937 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15938 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15939 mp->is_add = is_add;
15948 api_punt (vat_main_t * vam)
15950 unformat_input_t *i = vam->input;
15958 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15960 if (unformat (i, "ip %d", &ipv))
15962 else if (unformat (i, "protocol %d", &protocol))
15964 else if (unformat (i, "port %d", &port))
15966 else if (unformat (i, "del"))
15970 clib_warning ("parse error '%U'", format_unformat_error, i);
15977 mp->is_add = (u8) is_add;
15978 mp->ipv = (u8) ipv;
15979 mp->l4_protocol = (u8) protocol;
15980 mp->l4_port = htons ((u16) port);
15988 static void vl_api_ipsec_gre_tunnel_details_t_handler
15989 (vl_api_ipsec_gre_tunnel_details_t * mp)
15991 vat_main_t *vam = &vat_main;
15993 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15994 ntohl (mp->sw_if_index),
15995 format_ip4_address, &mp->src_address,
15996 format_ip4_address, &mp->dst_address,
15997 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16000 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
16001 (vl_api_ipsec_gre_tunnel_details_t * mp)
16003 vat_main_t *vam = &vat_main;
16004 vat_json_node_t *node = NULL;
16005 struct in_addr ip4;
16007 if (VAT_JSON_ARRAY != vam->json_tree.type)
16009 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16010 vat_json_init_array (&vam->json_tree);
16012 node = vat_json_array_add (&vam->json_tree);
16014 vat_json_init_object (node);
16015 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
16016 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
16017 vat_json_object_add_ip4 (node, "src_address", ip4);
16018 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
16019 vat_json_object_add_ip4 (node, "dst_address", ip4);
16020 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
16021 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
16025 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
16027 unformat_input_t *i = vam->input;
16028 vl_api_ipsec_gre_tunnel_dump_t *mp;
16031 u8 sw_if_index_set = 0;
16033 /* Parse args required to build the message */
16034 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16036 if (unformat (i, "sw_if_index %d", &sw_if_index))
16037 sw_if_index_set = 1;
16042 if (sw_if_index_set == 0)
16047 if (!vam->json_output)
16049 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
16050 "sw_if_index", "src_address", "dst_address",
16051 "local_sa_id", "remote_sa_id");
16054 /* Get list of gre-tunnel interfaces */
16055 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
16057 mp->sw_if_index = htonl (sw_if_index);
16061 /* Use a control ping for synchronization */
16063 vl_api_control_ping_t *mp;
16064 M (CONTROL_PING, control_ping);
16071 api_delete_subif (vat_main_t * vam)
16073 unformat_input_t *i = vam->input;
16074 vl_api_delete_subif_t *mp;
16076 u32 sw_if_index = ~0;
16078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16080 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16082 if (unformat (i, "sw_if_index %d", &sw_if_index))
16088 if (sw_if_index == ~0)
16090 errmsg ("missing sw_if_index\n");
16094 /* Construct the API message */
16095 M (DELETE_SUBIF, delete_subif);
16096 mp->sw_if_index = ntohl (sw_if_index);
16102 #define foreach_pbb_vtr_op \
16103 _("disable", L2_VTR_DISABLED) \
16104 _("pop", L2_VTR_POP_2) \
16105 _("push", L2_VTR_PUSH_2)
16108 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
16110 unformat_input_t *i = vam->input;
16111 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
16113 u32 sw_if_index = ~0, vtr_op = ~0;
16114 u16 outer_tag = ~0;
16115 u8 dmac[6], smac[6];
16116 u8 dmac_set = 0, smac_set = 0;
16121 /* Shut up coverity */
16122 memset (dmac, 0, sizeof (dmac));
16123 memset (smac, 0, sizeof (smac));
16125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16127 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16129 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16131 else if (unformat (i, "vtr_op %d", &vtr_op))
16133 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
16136 else if (unformat (i, "translate_pbb_stag"))
16138 if (unformat (i, "%d", &tmp))
16140 vtr_op = L2_VTR_TRANSLATE_2_1;
16146 ("translate_pbb_stag operation requires outer tag definition\n");
16150 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
16152 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
16154 else if (unformat (i, "sid %d", &sid))
16156 else if (unformat (i, "vlanid %d", &tmp))
16160 clib_warning ("parse error '%U'", format_unformat_error, i);
16165 if ((sw_if_index == ~0) || (vtr_op == ~0))
16167 errmsg ("missing sw_if_index or vtr operation\n");
16170 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
16171 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
16174 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid\n");
16178 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
16179 mp->sw_if_index = ntohl (sw_if_index);
16180 mp->vtr_op = ntohl (vtr_op);
16181 mp->outer_tag = ntohs (outer_tag);
16182 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
16183 clib_memcpy (mp->b_smac, smac, sizeof (smac));
16184 mp->b_vlanid = ntohs (vlanid);
16185 mp->i_sid = ntohl (sid);
16194 api_flow_classify_set_interface (vat_main_t * vam)
16196 unformat_input_t *i = vam->input;
16197 vl_api_flow_classify_set_interface_t *mp;
16200 int sw_if_index_set;
16201 u32 ip4_table_index = ~0;
16202 u32 ip6_table_index = ~0;
16205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16207 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16208 sw_if_index_set = 1;
16209 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16210 sw_if_index_set = 1;
16211 else if (unformat (i, "del"))
16213 else if (unformat (i, "ip4-table %d", &ip4_table_index))
16215 else if (unformat (i, "ip6-table %d", &ip6_table_index))
16219 clib_warning ("parse error '%U'", format_unformat_error, i);
16224 if (sw_if_index_set == 0)
16226 errmsg ("missing interface name or sw_if_index\n");
16230 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
16232 mp->sw_if_index = ntohl (sw_if_index);
16233 mp->ip4_table_index = ntohl (ip4_table_index);
16234 mp->ip6_table_index = ntohl (ip6_table_index);
16235 mp->is_add = is_add;
16244 api_flow_classify_dump (vat_main_t * vam)
16246 unformat_input_t *i = vam->input;
16247 vl_api_flow_classify_dump_t *mp;
16249 u8 type = FLOW_CLASSIFY_N_TABLES;
16251 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
16255 errmsg ("classify table type must be specified\n");
16259 if (!vam->json_output)
16261 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
16264 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
16269 /* Use a control ping for synchronization */
16271 vl_api_control_ping_t *mp;
16272 M (CONTROL_PING, control_ping);
16275 /* Wait for a reply... */
16283 q_or_quit (vat_main_t * vam)
16285 longjmp (vam->jump_buf, 1);
16286 return 0; /* not so much */
16290 q (vat_main_t * vam)
16292 return q_or_quit (vam);
16296 quit (vat_main_t * vam)
16298 return q_or_quit (vam);
16302 comment (vat_main_t * vam)
16308 cmd_cmp (void *a1, void *a2)
16313 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
16317 help (vat_main_t * vam)
16322 unformat_input_t *i = vam->input;
16325 if (unformat (i, "%s", &name))
16329 vec_add1 (name, 0);
16331 hs = hash_get_mem (vam->help_by_name, name);
16333 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
16335 fformat (vam->ofp, "No such msg / command '%s'\n", name);
16340 fformat (vam->ofp, "Help is available for the following:\n");
16343 hash_foreach_pair (p, vam->function_by_name,
16345 vec_add1 (cmds, (u8 *)(p->key));
16349 vec_sort_with_function (cmds, cmd_cmp);
16351 for (j = 0; j < vec_len (cmds); j++)
16352 fformat (vam->ofp, "%s\n", cmds[j]);
16359 set (vat_main_t * vam)
16361 u8 *name = 0, *value = 0;
16362 unformat_input_t *i = vam->input;
16364 if (unformat (i, "%s", &name))
16366 /* The input buffer is a vector, not a string. */
16367 value = vec_dup (i->buffer);
16368 vec_delete (value, i->index, 0);
16369 /* Almost certainly has a trailing newline */
16370 if (value[vec_len (value) - 1] == '\n')
16371 value[vec_len (value) - 1] = 0;
16372 /* Make sure it's a proper string, one way or the other */
16373 vec_add1 (value, 0);
16374 (void) clib_macro_set_value (&vam->macro_main,
16375 (char *) name, (char *) value);
16378 errmsg ("usage: set <name> <value>\n");
16386 unset (vat_main_t * vam)
16390 if (unformat (vam->input, "%s", &name))
16391 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
16392 errmsg ("unset: %s wasn't set\n", name);
16405 macro_sort_cmp (void *a1, void *a2)
16407 macro_sort_t *s1 = a1;
16408 macro_sort_t *s2 = a2;
16410 return strcmp ((char *) (s1->name), (char *) (s2->name));
16414 dump_macro_table (vat_main_t * vam)
16416 macro_sort_t *sort_me = 0, *sm;
16421 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
16423 vec_add2 (sort_me, sm, 1);
16424 sm->name = (u8 *)(p->key);
16425 sm->value = (u8 *) (p->value[0]);
16429 vec_sort_with_function (sort_me, macro_sort_cmp);
16431 if (vec_len (sort_me))
16432 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
16434 fformat (vam->ofp, "The macro table is empty...\n");
16436 for (i = 0; i < vec_len (sort_me); i++)
16437 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
16442 dump_node_table (vat_main_t * vam)
16445 vlib_node_t *node, *next_node;
16447 if (vec_len (vam->graph_nodes) == 0)
16449 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16453 for (i = 0; i < vec_len (vam->graph_nodes); i++)
16455 node = vam->graph_nodes[i];
16456 fformat (vam->ofp, "[%d] %s\n", i, node->name);
16457 for (j = 0; j < vec_len (node->next_nodes); j++)
16459 if (node->next_nodes[j] != ~0)
16461 next_node = vam->graph_nodes[node->next_nodes[j]];
16462 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16470 search_node_table (vat_main_t * vam)
16472 unformat_input_t *line_input = vam->input;
16475 vlib_node_t *node, *next_node;
16478 if (vam->graph_node_index_by_name == 0)
16480 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16484 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16486 if (unformat (line_input, "%s", &node_to_find))
16488 vec_add1 (node_to_find, 0);
16489 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
16492 fformat (vam->ofp, "%s not found...\n", node_to_find);
16495 node = vam->graph_nodes[p[0]];
16496 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
16497 for (j = 0; j < vec_len (node->next_nodes); j++)
16499 if (node->next_nodes[j] != ~0)
16501 next_node = vam->graph_nodes[node->next_nodes[j]];
16502 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16509 clib_warning ("parse error '%U'", format_unformat_error,
16515 vec_free (node_to_find);
16524 script (vat_main_t * vam)
16527 char *save_current_file;
16528 unformat_input_t save_input;
16529 jmp_buf save_jump_buf;
16530 u32 save_line_number;
16532 FILE *new_fp, *save_ifp;
16534 if (unformat (vam->input, "%s", &s))
16536 new_fp = fopen ((char *) s, "r");
16539 errmsg ("Couldn't open script file %s\n", s);
16546 errmsg ("Missing script name\n");
16550 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
16551 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
16552 save_ifp = vam->ifp;
16553 save_line_number = vam->input_line_number;
16554 save_current_file = (char *) vam->current_file;
16556 vam->input_line_number = 0;
16558 vam->current_file = s;
16561 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
16562 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
16563 vam->ifp = save_ifp;
16564 vam->input_line_number = save_line_number;
16565 vam->current_file = (u8 *) save_current_file;
16572 echo (vat_main_t * vam)
16574 fformat (vam->ofp, "%v", vam->input->buffer);
16578 /* List of API message constructors, CLI names map to api_xxx */
16579 #define foreach_vpe_api_msg \
16580 _(create_loopback,"[mac <mac-addr>]") \
16581 _(sw_interface_dump,"") \
16582 _(sw_interface_set_flags, \
16583 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
16584 _(sw_interface_add_del_address, \
16585 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
16586 _(sw_interface_set_table, \
16587 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
16588 _(sw_interface_set_mpls_enable, \
16589 "<intfc> | sw_if_index [disable | dis]") \
16590 _(sw_interface_set_vpath, \
16591 "<intfc> | sw_if_index <id> enable | disable") \
16592 _(sw_interface_set_l2_xconnect, \
16593 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16594 "enable | disable") \
16595 _(sw_interface_set_l2_bridge, \
16596 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
16597 "[shg <split-horizon-group>] [bvi]\n" \
16598 "enable | disable") \
16599 _(sw_interface_set_dpdk_hqos_pipe, \
16600 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
16601 "profile <profile-id>\n") \
16602 _(sw_interface_set_dpdk_hqos_subport, \
16603 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
16604 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
16605 _(sw_interface_set_dpdk_hqos_tctbl, \
16606 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
16607 _(bridge_domain_add_del, \
16608 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
16609 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
16611 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
16613 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
16615 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
16617 "tapname <name> mac <mac-addr> | random-mac") \
16619 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
16621 "<vpp-if-name> | sw_if_index <id>") \
16622 _(sw_interface_tap_dump, "") \
16623 _(ip_add_del_route, \
16624 "<addr>/<mask> via <addr> [table-id <n>]\n" \
16625 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16626 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16627 "[multipath] [count <n>]") \
16628 _(mpls_route_add_del, \
16629 "<label> <eos> via <addr> [table-id <n>]\n" \
16630 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16631 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16632 "[multipath] [count <n>]") \
16633 _(mpls_ip_bind_unbind, \
16634 "<label> <addr/len>") \
16635 _(proxy_arp_add_del, \
16636 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
16637 _(proxy_arp_intfc_enable_disable, \
16638 "<intfc> | sw_if_index <id> enable | disable") \
16639 _(mpls_add_del_encap, \
16640 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
16641 _(sw_interface_set_unnumbered, \
16642 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
16643 _(ip_neighbor_add_del, \
16644 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
16645 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
16646 _(reset_vrf, "vrf <id> [ipv6]") \
16647 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
16648 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
16649 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
16650 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
16651 "[outer_vlan_id_any][inner_vlan_id_any]") \
16652 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
16653 _(reset_fib, "vrf <n> [ipv6]") \
16654 _(dhcp_proxy_config, \
16655 "svr <v46-address> src <v46-address>\n" \
16656 "insert-cid <n> [del]") \
16657 _(dhcp_proxy_config_2, \
16658 "svr <v46-address> src <v46-address>\n" \
16659 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
16660 _(dhcp_proxy_set_vss, \
16661 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
16662 _(dhcp_client_config, \
16663 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
16664 _(set_ip_flow_hash, \
16665 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
16666 _(sw_interface_ip6_enable_disable, \
16667 "<intfc> | sw_if_index <id> enable | disable") \
16668 _(sw_interface_ip6_set_link_local_address, \
16669 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
16670 _(sw_interface_ip6nd_ra_prefix, \
16671 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
16672 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
16673 "[nolink] [isno]") \
16674 _(sw_interface_ip6nd_ra_config, \
16675 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
16676 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
16677 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
16678 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
16679 _(l2_patch_add_del, \
16680 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16681 "enable | disable") \
16682 _(mpls_ethernet_add_del_tunnel, \
16683 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
16684 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
16685 _(mpls_ethernet_add_del_tunnel_2, \
16686 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
16687 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
16688 _(sr_tunnel_add_del, \
16689 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
16690 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
16691 "[policy <policy_name>]") \
16692 _(sr_policy_add_del, \
16693 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
16694 _(sr_multicast_map_add_del, \
16695 "address [ip6 multicast address] sr-policy [policy name] [del]") \
16696 _(classify_add_del_table, \
16697 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
16698 " [del] mask <mask-value>\n" \
16699 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
16700 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
16701 _(classify_add_del_session, \
16702 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
16703 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
16704 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
16705 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
16706 _(classify_set_interface_ip_table, \
16707 "<intfc> | sw_if_index <nn> table <nn>") \
16708 _(classify_set_interface_l2_tables, \
16709 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16710 " [other-table <nn>]") \
16711 _(get_node_index, "node <node-name") \
16712 _(add_node_next, "node <node-name> next <next-node-name>") \
16713 _(l2tpv3_create_tunnel, \
16714 "client_address <ip6-addr> our_address <ip6-addr>\n" \
16715 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
16716 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
16717 _(l2tpv3_set_tunnel_cookies, \
16718 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
16719 "[new_remote_cookie <nn>]\n") \
16720 _(l2tpv3_interface_enable_disable, \
16721 "<intfc> | sw_if_index <nn> enable | disable") \
16722 _(l2tpv3_set_lookup_key, \
16723 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
16724 _(sw_if_l2tpv3_tunnel_dump, "") \
16725 _(vxlan_add_del_tunnel, \
16726 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
16727 " [decap-next l2|ip4|ip6] [del]") \
16728 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16729 _(gre_add_del_tunnel, \
16730 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
16731 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16732 _(l2_fib_clear_table, "") \
16733 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
16734 _(l2_interface_vlan_tag_rewrite, \
16735 "<intfc> | sw_if_index <nn> \n" \
16736 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
16737 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
16738 _(create_vhost_user_if, \
16739 "socket <filename> [server] [renumber <dev_instance>] " \
16740 "[mac <mac_address>]") \
16741 _(modify_vhost_user_if, \
16742 "<intfc> | sw_if_index <nn> socket <filename>\n" \
16743 "[server] [renumber <dev_instance>]") \
16744 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
16745 _(sw_interface_vhost_user_dump, "") \
16746 _(show_version, "") \
16747 _(vxlan_gpe_add_del_tunnel, \
16748 "local <addr> remote <addr> vni <nn>\n" \
16749 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
16750 "[next-ethernet] [next-nsh]\n") \
16751 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16752 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
16753 _(interface_name_renumber, \
16754 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
16755 _(input_acl_set_interface, \
16756 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16757 " [l2-table <nn>] [del]") \
16758 _(want_ip4_arp_events, "address <ip4-address> [del]") \
16759 _(want_ip6_nd_events, "address <ip6-address> [del]") \
16760 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
16761 _(ip_dump, "ipv4 | ipv6") \
16762 _(ipsec_spd_add_del, "spd_id <n> [del]") \
16763 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
16765 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
16766 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
16767 " integ_alg <alg> integ_key <hex>") \
16768 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
16769 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
16770 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
16771 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
16772 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
16773 _(ikev2_profile_add_del, "name <profile_name> [del]") \
16774 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
16775 "(auth_data 0x<data> | auth_data <data>)") \
16776 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
16777 "(id_data 0x<data> | id_data <data>) (local|remote)") \
16778 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
16779 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
16780 "(local|remote)") \
16781 _(ikev2_set_local_key, "file <absolute_file_path>") \
16782 _(delete_loopback,"sw_if_index <nn>") \
16783 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
16784 _(map_add_domain, \
16785 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
16786 "ip6-src <ip6addr> " \
16787 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
16788 _(map_del_domain, "index <n>") \
16789 _(map_add_del_rule, \
16790 "index <n> psid <n> dst <ip6addr> [del]") \
16791 _(map_domain_dump, "") \
16792 _(map_rule_dump, "index <map-domain>") \
16793 _(want_interface_events, "enable|disable") \
16794 _(want_stats,"enable|disable") \
16795 _(get_first_msg_id, "client <name>") \
16796 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
16797 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
16798 "fib-id <nn> [ip4][ip6][default]") \
16799 _(get_node_graph, " ") \
16800 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
16801 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
16802 _(ioam_disable, "") \
16803 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
16804 " sw_if_index <sw_if_index> p <priority> " \
16805 "w <weight>] [del]") \
16806 _(lisp_add_del_locator, "locator-set <locator_name> " \
16807 "iface <intf> | sw_if_index <sw_if_index> " \
16808 "p <priority> w <weight> [del]") \
16809 _(lisp_add_del_local_eid,"vni <vni> eid " \
16810 "<ipv4|ipv6>/<prefix> | <L2 address> " \
16811 "locator-set <locator_name> [del]") \
16812 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
16813 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
16814 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
16815 _(lisp_gpe_enable_disable, "enable|disable") \
16816 _(lisp_enable_disable, "enable|disable") \
16817 _(lisp_gpe_add_del_iface, "up|down") \
16818 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
16820 "rloc <locator> p <prio> " \
16821 "w <weight> [rloc <loc> ... ] " \
16822 "action <action> [del-all]") \
16823 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
16825 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
16826 _(lisp_map_request_mode, "src-dst|dst-only") \
16827 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
16828 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
16829 _(lisp_locator_set_dump, "[local | remote]") \
16830 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
16831 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
16832 "[local] | [remote]") \
16833 _(lisp_eid_table_vni_dump, "") \
16834 _(lisp_eid_table_map_dump, "l2|l3") \
16835 _(lisp_gpe_tunnel_dump, "") \
16836 _(lisp_map_resolver_dump, "") \
16837 _(lisp_adjacencies_get, "vni <vni>") \
16838 _(show_lisp_status, "") \
16839 _(lisp_get_map_request_itr_rlocs, "") \
16840 _(show_lisp_pitr, "") \
16841 _(show_lisp_map_request_mode, "") \
16842 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
16843 _(af_packet_delete, "name <host interface name>") \
16844 _(policer_add_del, "name <policer name> <params> [del]") \
16845 _(policer_dump, "[name <policer name>]") \
16846 _(policer_classify_set_interface, \
16847 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16848 " [l2-table <nn>] [del]") \
16849 _(policer_classify_dump, "type [ip4|ip6|l2]") \
16850 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
16851 "[master|slave]") \
16852 _(netmap_delete, "name <interface name>") \
16853 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
16854 _(mpls_fib_encap_dump, "") \
16855 _(mpls_fib_dump, "") \
16856 _(classify_table_ids, "") \
16857 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
16858 _(classify_table_info, "table_id <nn>") \
16859 _(classify_session_dump, "table_id <nn>") \
16860 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
16861 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
16862 "[template_interval <nn>] [udp_checksum]") \
16863 _(ipfix_exporter_dump, "") \
16864 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
16865 _(ipfix_classify_stream_dump, "") \
16866 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
16867 _(ipfix_classify_table_dump, "") \
16868 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [[dst <intfc> | dst_sw_if_index <id>] | disable]") \
16869 _(sw_interface_span_dump, "") \
16870 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
16871 _(pg_create_interface, "if_id <nn>") \
16872 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
16873 _(pg_enable_disable, "[stream <id>] disable") \
16874 _(ip_source_and_port_range_check_add_del, \
16875 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
16876 _(ip_source_and_port_range_check_interface_add_del, \
16877 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
16878 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
16879 _(ipsec_gre_add_del_tunnel, \
16880 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
16881 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
16882 _(delete_subif,"<intfc> | sw_if_index <nn>") \
16883 _(l2_interface_pbb_tag_rewrite, \
16884 "<intfc> | sw_if_index <nn> \n" \
16885 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
16886 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
16887 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
16888 _(flow_classify_set_interface, \
16889 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
16890 _(flow_classify_dump, "type [ip4|ip6]") \
16891 _(ip_fib_dump, "") \
16892 _(ip6_fib_dump, "")
16894 /* List of command functions, CLI names map directly to functions */
16895 #define foreach_cli_function \
16896 _(comment, "usage: comment <ignore-rest-of-line>") \
16897 _(dump_interface_table, "usage: dump_interface_table") \
16898 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
16899 _(dump_ipv4_table, "usage: dump_ipv4_table") \
16900 _(dump_ipv6_table, "usage: dump_ipv6_table") \
16901 _(dump_stats_table, "usage: dump_stats_table") \
16902 _(dump_macro_table, "usage: dump_macro_table ") \
16903 _(dump_node_table, "usage: dump_node_table") \
16904 _(echo, "usage: echo <message>") \
16905 _(exec, "usage: exec <vpe-debug-CLI-command>") \
16906 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
16907 _(help, "usage: help") \
16908 _(q, "usage: quit") \
16909 _(quit, "usage: quit") \
16910 _(search_node_table, "usage: search_node_table <name>...") \
16911 _(set, "usage: set <variable-name> <value>") \
16912 _(script, "usage: script <file-name>") \
16913 _(unset, "usage: unset <variable-name>")
16916 static void vl_api_##n##_t_handler_uni \
16917 (vl_api_##n##_t * mp) \
16919 vat_main_t * vam = &vat_main; \
16920 if (vam->json_output) { \
16921 vl_api_##n##_t_handler_json(mp); \
16923 vl_api_##n##_t_handler(mp); \
16926 foreach_vpe_api_reply_msg;
16930 vat_api_hookup (vat_main_t * vam)
16933 vl_msg_api_set_handlers(VL_API_##N, #n, \
16934 vl_api_##n##_t_handler_uni, \
16936 vl_api_##n##_t_endian, \
16937 vl_api_##n##_t_print, \
16938 sizeof(vl_api_##n##_t), 1);
16939 foreach_vpe_api_reply_msg;
16942 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
16944 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
16946 vam->function_by_name = hash_create_string (0, sizeof (uword));
16948 vam->help_by_name = hash_create_string (0, sizeof (uword));
16950 /* API messages we can send */
16951 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
16952 foreach_vpe_api_msg;
16956 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16957 foreach_vpe_api_msg;
16960 /* CLI functions */
16961 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
16962 foreach_cli_function;
16966 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16967 foreach_cli_function;
16971 #undef vl_api_version
16972 #define vl_api_version(n,v) static u32 vpe_api_version = v;
16973 #include <vpp-api/vpe.api.h>
16974 #undef vl_api_version
16977 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
16980 * Send the main API signature in slot 0. This bit of code must
16981 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
16983 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
16987 * fd.io coding-style-patch-verification: ON
16990 * eval: (c-set-style "gnu")