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/policer/policer.h>
52 #include <vnet/policer/police.h>
54 #include "vat/json_format.h"
58 #define vl_typedefs /* define message structures */
59 #include <vpp-api/vpe_all_api_h.h>
62 /* declare message handlers for each api */
64 #define vl_endianfun /* define message structures */
65 #include <vpp-api/vpe_all_api_h.h>
68 /* instantiate all the print functions we know about */
69 #define vl_print(handle, ...)
71 #include <vpp-api/vpe_all_api_h.h>
75 unformat_sw_if_index (unformat_input_t * input, va_list * args)
77 vat_main_t *vam = va_arg (*args, vat_main_t *);
78 u32 *result = va_arg (*args, u32 *);
82 if (!unformat (input, "%s", &if_name))
85 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
92 /* Parse an IP4 address %d.%d.%d.%d. */
94 unformat_ip4_address (unformat_input_t * input, va_list * args)
96 u8 *result = va_arg (*args, u8 *);
99 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
102 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
115 unformat_ethernet_address (unformat_input_t * input, va_list * args)
117 u8 *result = va_arg (*args, u8 *);
120 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
121 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
125 for (i = 0; i < 6; i++)
126 if (a[i] >= (1 << 8))
129 for (i = 0; i < 6; i++)
135 /* Returns ethernet type as an int in host byte order. */
137 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
140 u16 *result = va_arg (*args, u16 *);
144 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
146 if (type >= (1 << 16))
154 /* Parse an IP6 address. */
156 unformat_ip6_address (unformat_input_t * input, va_list * args)
158 ip6_address_t *result = va_arg (*args, ip6_address_t *);
160 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
161 uword c, n_colon, double_colon_index;
163 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
164 double_colon_index = ARRAY_LEN (hex_quads);
165 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
168 if (c >= '0' && c <= '9')
170 else if (c >= 'a' && c <= 'f')
171 hex_digit = c + 10 - 'a';
172 else if (c >= 'A' && c <= 'F')
173 hex_digit = c + 10 - 'A';
174 else if (c == ':' && n_colon < 2)
178 unformat_put_input (input);
182 /* Too many hex quads. */
183 if (n_hex_quads >= ARRAY_LEN (hex_quads))
188 hex_quad = (hex_quad << 4) | hex_digit;
190 /* Hex quad must fit in 16 bits. */
191 if (n_hex_digits >= 4)
198 /* Save position of :: */
201 /* More than one :: ? */
202 if (double_colon_index < ARRAY_LEN (hex_quads))
204 double_colon_index = n_hex_quads;
207 if (n_colon > 0 && n_hex_digits > 0)
209 hex_quads[n_hex_quads++] = hex_quad;
215 if (n_hex_digits > 0)
216 hex_quads[n_hex_quads++] = hex_quad;
221 /* Expand :: to appropriate number of zero hex quads. */
222 if (double_colon_index < ARRAY_LEN (hex_quads))
224 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
226 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
227 hex_quads[n_zero + i] = hex_quads[i];
229 for (i = 0; i < n_zero; i++)
230 hex_quads[double_colon_index + i] = 0;
232 n_hex_quads = ARRAY_LEN (hex_quads);
235 /* Too few hex quads given. */
236 if (n_hex_quads < ARRAY_LEN (hex_quads))
239 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
240 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
247 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
250 u32 *r = va_arg (*args, u32 *);
253 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
254 foreach_ipsec_policy_action
265 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
268 u32 *r = va_arg (*args, u32 *);
271 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
272 foreach_ipsec_crypto_alg
283 format_ipsec_crypto_alg (u8 * s, va_list * args)
286 u32 i = va_arg (*args, u32);
291 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
292 foreach_ipsec_crypto_alg
295 return format (s, "unknown");
297 return format (s, "%s", t);
299 return format (s, "Unimplemented");
304 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
307 u32 *r = va_arg (*args, u32 *);
310 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
311 foreach_ipsec_integ_alg
322 format_ipsec_integ_alg (u8 * s, va_list * args)
325 u32 i = va_arg (*args, u32);
330 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
331 foreach_ipsec_integ_alg
334 return format (s, "unknown");
336 return format (s, "%s", t);
338 return format (s, "Unsupported");
343 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
346 u32 *r = va_arg (*args, u32 *);
349 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
350 foreach_ikev2_auth_method
361 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
364 u32 *r = va_arg (*args, u32 *);
367 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
368 foreach_ikev2_id_type
379 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
381 u8 *r = va_arg (*args, u8 *);
383 if (unformat (input, "kbps"))
384 *r = SSE2_QOS_RATE_KBPS;
385 else if (unformat (input, "pps"))
386 *r = SSE2_QOS_RATE_PPS;
393 unformat_policer_round_type (unformat_input_t * input, va_list * args)
395 u8 *r = va_arg (*args, u8 *);
397 if (unformat (input, "closest"))
398 *r = SSE2_QOS_ROUND_TO_CLOSEST;
399 else if (unformat (input, "up"))
400 *r = SSE2_QOS_ROUND_TO_UP;
401 else if (unformat (input, "down"))
402 *r = SSE2_QOS_ROUND_TO_DOWN;
409 unformat_policer_type (unformat_input_t * input, va_list * args)
411 u8 *r = va_arg (*args, u8 *);
413 if (unformat (input, "1r2c"))
414 *r = SSE2_QOS_POLICER_TYPE_1R2C;
415 else if (unformat (input, "1r3c"))
416 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
417 else if (unformat (input, "2r3c-2698"))
418 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
419 else if (unformat (input, "2r3c-4115"))
420 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
421 else if (unformat (input, "2r3c-mef5cf1"))
422 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
429 unformat_dscp (unformat_input_t * input, va_list * va)
431 u8 *r = va_arg (*va, u8 *);
434 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
443 unformat_policer_action_type (unformat_input_t * input, va_list * va)
445 sse2_qos_pol_action_params_st *a
446 = va_arg (*va, sse2_qos_pol_action_params_st *);
448 if (unformat (input, "drop"))
449 a->action_type = SSE2_QOS_ACTION_DROP;
450 else if (unformat (input, "transmit"))
451 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
452 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
453 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
460 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
462 u32 *r = va_arg (*va, u32 *);
465 if (unformat (input, "ip4"))
466 tid = POLICER_CLASSIFY_TABLE_IP4;
467 else if (unformat (input, "ip6"))
468 tid = POLICER_CLASSIFY_TABLE_IP6;
469 else if (unformat (input, "l2"))
470 tid = POLICER_CLASSIFY_TABLE_L2;
479 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
481 u32 *r = va_arg (*va, u32 *);
484 if (unformat (input, "ip4"))
485 tid = FLOW_CLASSIFY_TABLE_IP4;
486 else if (unformat (input, "ip6"))
487 tid = FLOW_CLASSIFY_TABLE_IP6;
496 format_ip4_address (u8 * s, va_list * args)
498 u8 *a = va_arg (*args, u8 *);
499 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
503 format_ip6_address (u8 * s, va_list * args)
505 ip6_address_t *a = va_arg (*args, ip6_address_t *);
506 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
508 i_max_n_zero = ARRAY_LEN (a->as_u16);
510 i_first_zero = i_max_n_zero;
512 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
514 u32 is_zero = a->as_u16[i] == 0;
515 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
521 if ((!is_zero && n_zeros > max_n_zeros)
522 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
524 i_max_n_zero = i_first_zero;
525 max_n_zeros = n_zeros;
526 i_first_zero = ARRAY_LEN (a->as_u16);
531 last_double_colon = 0;
532 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
534 if (i == i_max_n_zero && max_n_zeros > 1)
536 s = format (s, "::");
537 i += max_n_zeros - 1;
538 last_double_colon = 1;
542 s = format (s, "%s%x",
543 (last_double_colon || i == 0) ? "" : ":",
544 clib_net_to_host_u16 (a->as_u16[i]));
545 last_double_colon = 0;
552 /* Format an IP46 address. */
554 format_ip46_address (u8 * s, va_list * args)
556 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
557 ip46_type_t type = va_arg (*args, ip46_type_t);
563 is_ip4 = ip46_address_is_ip4 (ip46);
574 format (s, "%U", format_ip4_address, &ip46->ip4) :
575 format (s, "%U", format_ip6_address, &ip46->ip6);
579 format_ethernet_address (u8 * s, va_list * args)
581 u8 *a = va_arg (*args, u8 *);
583 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
584 a[0], a[1], a[2], a[3], a[4], a[5]);
588 increment_v4_address (ip4_address_t * a)
592 v = ntohl (a->as_u32) + 1;
593 a->as_u32 = ntohl (v);
597 increment_v6_address (ip6_address_t * a)
601 v0 = clib_net_to_host_u64 (a->as_u64[0]);
602 v1 = clib_net_to_host_u64 (a->as_u64[1]);
607 a->as_u64[0] = clib_net_to_host_u64 (v0);
608 a->as_u64[1] = clib_net_to_host_u64 (v1);
612 increment_mac_address (u64 * mac)
616 tmp = clib_net_to_host_u64 (tmp);
617 tmp += 1 << 16; /* skip unused (least significant) octets */
618 tmp = clib_host_to_net_u64 (tmp);
622 static void vl_api_create_loopback_reply_t_handler
623 (vl_api_create_loopback_reply_t * mp)
625 vat_main_t *vam = &vat_main;
626 i32 retval = ntohl (mp->retval);
628 vam->retval = retval;
629 vam->regenerate_interface_table = 1;
630 vam->sw_if_index = ntohl (mp->sw_if_index);
631 vam->result_ready = 1;
634 static void vl_api_create_loopback_reply_t_handler_json
635 (vl_api_create_loopback_reply_t * mp)
637 vat_main_t *vam = &vat_main;
638 vat_json_node_t node;
640 vat_json_init_object (&node);
641 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
642 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
644 vat_json_print (vam->ofp, &node);
645 vat_json_free (&node);
646 vam->retval = ntohl (mp->retval);
647 vam->result_ready = 1;
650 static void vl_api_af_packet_create_reply_t_handler
651 (vl_api_af_packet_create_reply_t * mp)
653 vat_main_t *vam = &vat_main;
654 i32 retval = ntohl (mp->retval);
656 vam->retval = retval;
657 vam->regenerate_interface_table = 1;
658 vam->sw_if_index = ntohl (mp->sw_if_index);
659 vam->result_ready = 1;
662 static void vl_api_af_packet_create_reply_t_handler_json
663 (vl_api_af_packet_create_reply_t * mp)
665 vat_main_t *vam = &vat_main;
666 vat_json_node_t node;
668 vat_json_init_object (&node);
669 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
670 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
672 vat_json_print (vam->ofp, &node);
673 vat_json_free (&node);
675 vam->retval = ntohl (mp->retval);
676 vam->result_ready = 1;
679 static void vl_api_create_vlan_subif_reply_t_handler
680 (vl_api_create_vlan_subif_reply_t * mp)
682 vat_main_t *vam = &vat_main;
683 i32 retval = ntohl (mp->retval);
685 vam->retval = retval;
686 vam->regenerate_interface_table = 1;
687 vam->sw_if_index = ntohl (mp->sw_if_index);
688 vam->result_ready = 1;
691 static void vl_api_create_vlan_subif_reply_t_handler_json
692 (vl_api_create_vlan_subif_reply_t * mp)
694 vat_main_t *vam = &vat_main;
695 vat_json_node_t node;
697 vat_json_init_object (&node);
698 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
699 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
701 vat_json_print (vam->ofp, &node);
702 vat_json_free (&node);
704 vam->retval = ntohl (mp->retval);
705 vam->result_ready = 1;
708 static void vl_api_create_subif_reply_t_handler
709 (vl_api_create_subif_reply_t * mp)
711 vat_main_t *vam = &vat_main;
712 i32 retval = ntohl (mp->retval);
714 vam->retval = retval;
715 vam->regenerate_interface_table = 1;
716 vam->sw_if_index = ntohl (mp->sw_if_index);
717 vam->result_ready = 1;
720 static void vl_api_create_subif_reply_t_handler_json
721 (vl_api_create_subif_reply_t * mp)
723 vat_main_t *vam = &vat_main;
724 vat_json_node_t node;
726 vat_json_init_object (&node);
727 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
728 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
730 vat_json_print (vam->ofp, &node);
731 vat_json_free (&node);
733 vam->retval = ntohl (mp->retval);
734 vam->result_ready = 1;
737 static void vl_api_interface_name_renumber_reply_t_handler
738 (vl_api_interface_name_renumber_reply_t * mp)
740 vat_main_t *vam = &vat_main;
741 i32 retval = ntohl (mp->retval);
743 vam->retval = retval;
744 vam->regenerate_interface_table = 1;
745 vam->result_ready = 1;
748 static void vl_api_interface_name_renumber_reply_t_handler_json
749 (vl_api_interface_name_renumber_reply_t * mp)
751 vat_main_t *vam = &vat_main;
752 vat_json_node_t node;
754 vat_json_init_object (&node);
755 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
757 vat_json_print (vam->ofp, &node);
758 vat_json_free (&node);
760 vam->retval = ntohl (mp->retval);
761 vam->result_ready = 1;
765 * Special-case: build the interface table, maintain
766 * the next loopback sw_if_index vbl.
768 static void vl_api_sw_interface_details_t_handler
769 (vl_api_sw_interface_details_t * mp)
771 vat_main_t *vam = &vat_main;
772 u8 *s = format (0, "%s%c", mp->interface_name, 0);
774 hash_set_mem (vam->sw_if_index_by_interface_name, s,
775 ntohl (mp->sw_if_index));
777 /* In sub interface case, fill the sub interface table entry */
778 if (mp->sw_if_index != mp->sup_sw_if_index)
780 sw_interface_subif_t *sub = NULL;
782 vec_add2 (vam->sw_if_subif_table, sub, 1);
784 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
785 strncpy ((char *) sub->interface_name, (char *) s,
786 vec_len (sub->interface_name));
787 sub->sw_if_index = ntohl (mp->sw_if_index);
788 sub->sub_id = ntohl (mp->sub_id);
790 sub->sub_dot1ad = mp->sub_dot1ad;
791 sub->sub_number_of_tags = mp->sub_number_of_tags;
792 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
793 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
794 sub->sub_exact_match = mp->sub_exact_match;
795 sub->sub_default = mp->sub_default;
796 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
797 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
799 /* vlan tag rewrite */
800 sub->vtr_op = ntohl (mp->vtr_op);
801 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
802 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
803 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
807 static void vl_api_sw_interface_details_t_handler_json
808 (vl_api_sw_interface_details_t * mp)
810 vat_main_t *vam = &vat_main;
811 vat_json_node_t *node = NULL;
813 if (VAT_JSON_ARRAY != vam->json_tree.type)
815 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
816 vat_json_init_array (&vam->json_tree);
818 node = vat_json_array_add (&vam->json_tree);
820 vat_json_init_object (node);
821 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
822 vat_json_object_add_uint (node, "sup_sw_if_index",
823 ntohl (mp->sup_sw_if_index));
824 vat_json_object_add_uint (node, "l2_address_length",
825 ntohl (mp->l2_address_length));
826 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
827 sizeof (mp->l2_address));
828 vat_json_object_add_string_copy (node, "interface_name",
830 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
831 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
832 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
833 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
834 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
835 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
836 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
837 vat_json_object_add_uint (node, "sub_number_of_tags",
838 mp->sub_number_of_tags);
839 vat_json_object_add_uint (node, "sub_outer_vlan_id",
840 ntohs (mp->sub_outer_vlan_id));
841 vat_json_object_add_uint (node, "sub_inner_vlan_id",
842 ntohs (mp->sub_inner_vlan_id));
843 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
844 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
845 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
846 mp->sub_outer_vlan_id_any);
847 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
848 mp->sub_inner_vlan_id_any);
849 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
850 vat_json_object_add_uint (node, "vtr_push_dot1q",
851 ntohl (mp->vtr_push_dot1q));
852 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
853 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
856 static void vl_api_sw_interface_set_flags_t_handler
857 (vl_api_sw_interface_set_flags_t * mp)
859 vat_main_t *vam = &vat_main;
860 if (vam->interface_event_display)
861 errmsg ("interface flags: sw_if_index %d %s %s\n",
862 ntohl (mp->sw_if_index),
863 mp->admin_up_down ? "admin-up" : "admin-down",
864 mp->link_up_down ? "link-up" : "link-down");
867 static void vl_api_sw_interface_set_flags_t_handler_json
868 (vl_api_sw_interface_set_flags_t * mp)
870 /* JSON output not supported */
874 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
876 vat_main_t *vam = &vat_main;
877 i32 retval = ntohl (mp->retval);
879 vam->retval = retval;
880 vam->shmem_result = (u8 *) mp->reply_in_shmem;
881 vam->result_ready = 1;
885 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
887 vat_main_t *vam = &vat_main;
888 vat_json_node_t node;
889 api_main_t *am = &api_main;
893 vat_json_init_object (&node);
894 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
895 vat_json_object_add_uint (&node, "reply_in_shmem",
896 ntohl (mp->reply_in_shmem));
897 /* Toss the shared-memory original... */
898 pthread_mutex_lock (&am->vlib_rp->mutex);
899 oldheap = svm_push_data_heap (am->vlib_rp);
901 reply = (u8 *) (mp->reply_in_shmem);
904 svm_pop_heap (oldheap);
905 pthread_mutex_unlock (&am->vlib_rp->mutex);
907 vat_json_print (vam->ofp, &node);
908 vat_json_free (&node);
910 vam->retval = ntohl (mp->retval);
911 vam->result_ready = 1;
915 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
917 vat_main_t *vam = &vat_main;
918 i32 retval = ntohl (mp->retval);
920 vam->retval = retval;
921 vam->cmd_reply = mp->reply;
922 vam->result_ready = 1;
926 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
928 vat_main_t *vam = &vat_main;
929 vat_json_node_t node;
931 vat_json_init_object (&node);
932 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
933 vat_json_object_add_string_copy (&node, "reply", mp->reply);
935 vat_json_print (vam->ofp, &node);
936 vat_json_free (&node);
938 vam->retval = ntohl (mp->retval);
939 vam->result_ready = 1;
942 static void vl_api_classify_add_del_table_reply_t_handler
943 (vl_api_classify_add_del_table_reply_t * mp)
945 vat_main_t *vam = &vat_main;
946 i32 retval = ntohl (mp->retval);
949 vam->async_errors += (retval < 0);
953 vam->retval = retval;
955 ((mp->new_table_index != 0xFFFFFFFF) ||
956 (mp->skip_n_vectors != 0xFFFFFFFF) ||
957 (mp->match_n_vectors != 0xFFFFFFFF)))
959 * Note: this is just barely thread-safe, depends on
960 * the main thread spinning waiting for an answer...
962 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
963 ntohl (mp->new_table_index),
964 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
965 vam->result_ready = 1;
969 static void vl_api_classify_add_del_table_reply_t_handler_json
970 (vl_api_classify_add_del_table_reply_t * mp)
972 vat_main_t *vam = &vat_main;
973 vat_json_node_t node;
975 vat_json_init_object (&node);
976 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
977 vat_json_object_add_uint (&node, "new_table_index",
978 ntohl (mp->new_table_index));
979 vat_json_object_add_uint (&node, "skip_n_vectors",
980 ntohl (mp->skip_n_vectors));
981 vat_json_object_add_uint (&node, "match_n_vectors",
982 ntohl (mp->match_n_vectors));
984 vat_json_print (vam->ofp, &node);
985 vat_json_free (&node);
987 vam->retval = ntohl (mp->retval);
988 vam->result_ready = 1;
991 static void vl_api_get_node_index_reply_t_handler
992 (vl_api_get_node_index_reply_t * mp)
994 vat_main_t *vam = &vat_main;
995 i32 retval = ntohl (mp->retval);
998 vam->async_errors += (retval < 0);
1002 vam->retval = retval;
1004 errmsg ("node index %d\n", ntohl (mp->node_index));
1005 vam->result_ready = 1;
1009 static void vl_api_get_node_index_reply_t_handler_json
1010 (vl_api_get_node_index_reply_t * mp)
1012 vat_main_t *vam = &vat_main;
1013 vat_json_node_t node;
1015 vat_json_init_object (&node);
1016 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1017 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
1019 vat_json_print (vam->ofp, &node);
1020 vat_json_free (&node);
1022 vam->retval = ntohl (mp->retval);
1023 vam->result_ready = 1;
1026 static void vl_api_get_next_index_reply_t_handler
1027 (vl_api_get_next_index_reply_t * mp)
1029 vat_main_t *vam = &vat_main;
1030 i32 retval = ntohl (mp->retval);
1031 if (vam->async_mode)
1033 vam->async_errors += (retval < 0);
1037 vam->retval = retval;
1039 errmsg ("next node index %d\n", ntohl (mp->next_index));
1040 vam->result_ready = 1;
1044 static void vl_api_get_next_index_reply_t_handler_json
1045 (vl_api_get_next_index_reply_t * mp)
1047 vat_main_t *vam = &vat_main;
1048 vat_json_node_t node;
1050 vat_json_init_object (&node);
1051 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1052 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1054 vat_json_print (vam->ofp, &node);
1055 vat_json_free (&node);
1057 vam->retval = ntohl (mp->retval);
1058 vam->result_ready = 1;
1061 static void vl_api_add_node_next_reply_t_handler
1062 (vl_api_add_node_next_reply_t * mp)
1064 vat_main_t *vam = &vat_main;
1065 i32 retval = ntohl (mp->retval);
1066 if (vam->async_mode)
1068 vam->async_errors += (retval < 0);
1072 vam->retval = retval;
1074 errmsg ("next index %d\n", ntohl (mp->next_index));
1075 vam->result_ready = 1;
1079 static void vl_api_add_node_next_reply_t_handler_json
1080 (vl_api_add_node_next_reply_t * mp)
1082 vat_main_t *vam = &vat_main;
1083 vat_json_node_t node;
1085 vat_json_init_object (&node);
1086 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1087 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1089 vat_json_print (vam->ofp, &node);
1090 vat_json_free (&node);
1092 vam->retval = ntohl (mp->retval);
1093 vam->result_ready = 1;
1096 static void vl_api_show_version_reply_t_handler
1097 (vl_api_show_version_reply_t * mp)
1099 vat_main_t *vam = &vat_main;
1100 i32 retval = ntohl (mp->retval);
1104 errmsg (" program: %s\n", mp->program);
1105 errmsg (" version: %s\n", mp->version);
1106 errmsg (" build date: %s\n", mp->build_date);
1107 errmsg ("build directory: %s\n", mp->build_directory);
1109 vam->retval = retval;
1110 vam->result_ready = 1;
1113 static void vl_api_show_version_reply_t_handler_json
1114 (vl_api_show_version_reply_t * mp)
1116 vat_main_t *vam = &vat_main;
1117 vat_json_node_t node;
1119 vat_json_init_object (&node);
1120 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1121 vat_json_object_add_string_copy (&node, "program", mp->program);
1122 vat_json_object_add_string_copy (&node, "version", mp->version);
1123 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1124 vat_json_object_add_string_copy (&node, "build_directory",
1125 mp->build_directory);
1127 vat_json_print (vam->ofp, &node);
1128 vat_json_free (&node);
1130 vam->retval = ntohl (mp->retval);
1131 vam->result_ready = 1;
1135 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1137 vat_main_t *vam = &vat_main;
1138 errmsg ("arp %s event: address %U new mac %U sw_if_index %d\n",
1139 mp->mac_ip ? "mac/ip binding" : "address resolution",
1140 format_ip4_address, &mp->address,
1141 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1145 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1147 /* JSON output not supported */
1151 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1153 vat_main_t *vam = &vat_main;
1154 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d\n",
1155 mp->mac_ip ? "mac/ip binding" : "address resolution",
1156 format_ip6_address, mp->address,
1157 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1161 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1163 /* JSON output not supported */
1167 * Special-case: build the bridge domain table, maintain
1168 * the next bd id vbl.
1170 static void vl_api_bridge_domain_details_t_handler
1171 (vl_api_bridge_domain_details_t * mp)
1173 vat_main_t *vam = &vat_main;
1174 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1176 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1177 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1179 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1180 ntohl (mp->bd_id), mp->learn, mp->forward,
1181 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1184 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1188 static void vl_api_bridge_domain_details_t_handler_json
1189 (vl_api_bridge_domain_details_t * mp)
1191 vat_main_t *vam = &vat_main;
1192 vat_json_node_t *node, *array = NULL;
1194 if (VAT_JSON_ARRAY != vam->json_tree.type)
1196 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1197 vat_json_init_array (&vam->json_tree);
1199 node = vat_json_array_add (&vam->json_tree);
1201 vat_json_init_object (node);
1202 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1203 vat_json_object_add_uint (node, "flood", mp->flood);
1204 vat_json_object_add_uint (node, "forward", mp->forward);
1205 vat_json_object_add_uint (node, "learn", mp->learn);
1206 vat_json_object_add_uint (node, "bvi_sw_if_index",
1207 ntohl (mp->bvi_sw_if_index));
1208 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1209 array = vat_json_object_add (node, "sw_if");
1210 vat_json_init_array (array);
1214 * Special-case: build the bridge domain sw if table.
1216 static void vl_api_bridge_domain_sw_if_details_t_handler
1217 (vl_api_bridge_domain_sw_if_details_t * mp)
1219 vat_main_t *vam = &vat_main;
1224 sw_if_index = ntohl (mp->sw_if_index);
1226 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1228 if ((u32) p->value[0] == sw_if_index)
1230 sw_if_name = (u8 *)(p->key);
1236 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1237 mp->shg, sw_if_name ? (char *) sw_if_name :
1238 "sw_if_index not found!");
1241 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1242 (vl_api_bridge_domain_sw_if_details_t * mp)
1244 vat_main_t *vam = &vat_main;
1245 vat_json_node_t *node = NULL;
1246 uword last_index = 0;
1248 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1249 ASSERT (vec_len (vam->json_tree.array) >= 1);
1250 last_index = vec_len (vam->json_tree.array) - 1;
1251 node = &vam->json_tree.array[last_index];
1252 node = vat_json_object_get_element (node, "sw_if");
1253 ASSERT (NULL != node);
1254 node = vat_json_array_add (node);
1256 vat_json_init_object (node);
1257 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1258 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1259 vat_json_object_add_uint (node, "shg", mp->shg);
1262 static void vl_api_control_ping_reply_t_handler
1263 (vl_api_control_ping_reply_t * mp)
1265 vat_main_t *vam = &vat_main;
1266 i32 retval = ntohl (mp->retval);
1267 if (vam->async_mode)
1269 vam->async_errors += (retval < 0);
1273 vam->retval = retval;
1274 vam->result_ready = 1;
1278 static void vl_api_control_ping_reply_t_handler_json
1279 (vl_api_control_ping_reply_t * mp)
1281 vat_main_t *vam = &vat_main;
1282 i32 retval = ntohl (mp->retval);
1284 if (VAT_JSON_NONE != vam->json_tree.type)
1286 vat_json_print (vam->ofp, &vam->json_tree);
1287 vat_json_free (&vam->json_tree);
1288 vam->json_tree.type = VAT_JSON_NONE;
1293 vat_json_init_array (&vam->json_tree);
1294 vat_json_print (vam->ofp, &vam->json_tree);
1295 vam->json_tree.type = VAT_JSON_NONE;
1298 vam->retval = retval;
1299 vam->result_ready = 1;
1303 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1305 vat_main_t *vam = &vat_main;
1306 i32 retval = ntohl (mp->retval);
1307 if (vam->async_mode)
1309 vam->async_errors += (retval < 0);
1313 vam->retval = retval;
1314 vam->result_ready = 1;
1318 static void vl_api_l2_flags_reply_t_handler_json
1319 (vl_api_l2_flags_reply_t * mp)
1321 vat_main_t *vam = &vat_main;
1322 vat_json_node_t node;
1324 vat_json_init_object (&node);
1325 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1326 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1327 ntohl (mp->resulting_feature_bitmap));
1329 vat_json_print (vam->ofp, &node);
1330 vat_json_free (&node);
1332 vam->retval = ntohl (mp->retval);
1333 vam->result_ready = 1;
1336 static void vl_api_bridge_flags_reply_t_handler
1337 (vl_api_bridge_flags_reply_t * mp)
1339 vat_main_t *vam = &vat_main;
1340 i32 retval = ntohl (mp->retval);
1341 if (vam->async_mode)
1343 vam->async_errors += (retval < 0);
1347 vam->retval = retval;
1348 vam->result_ready = 1;
1352 static void vl_api_bridge_flags_reply_t_handler_json
1353 (vl_api_bridge_flags_reply_t * mp)
1355 vat_main_t *vam = &vat_main;
1356 vat_json_node_t node;
1358 vat_json_init_object (&node);
1359 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1360 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1361 ntohl (mp->resulting_feature_bitmap));
1363 vat_json_print (vam->ofp, &node);
1364 vat_json_free (&node);
1366 vam->retval = ntohl (mp->retval);
1367 vam->result_ready = 1;
1370 static void vl_api_tap_connect_reply_t_handler
1371 (vl_api_tap_connect_reply_t * mp)
1373 vat_main_t *vam = &vat_main;
1374 i32 retval = ntohl (mp->retval);
1375 if (vam->async_mode)
1377 vam->async_errors += (retval < 0);
1381 vam->retval = retval;
1382 vam->sw_if_index = ntohl (mp->sw_if_index);
1383 vam->result_ready = 1;
1388 static void vl_api_tap_connect_reply_t_handler_json
1389 (vl_api_tap_connect_reply_t * mp)
1391 vat_main_t *vam = &vat_main;
1392 vat_json_node_t node;
1394 vat_json_init_object (&node);
1395 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1396 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1398 vat_json_print (vam->ofp, &node);
1399 vat_json_free (&node);
1401 vam->retval = ntohl (mp->retval);
1402 vam->result_ready = 1;
1407 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1409 vat_main_t *vam = &vat_main;
1410 i32 retval = ntohl (mp->retval);
1411 if (vam->async_mode)
1413 vam->async_errors += (retval < 0);
1417 vam->retval = retval;
1418 vam->sw_if_index = ntohl (mp->sw_if_index);
1419 vam->result_ready = 1;
1423 static void vl_api_tap_modify_reply_t_handler_json
1424 (vl_api_tap_modify_reply_t * mp)
1426 vat_main_t *vam = &vat_main;
1427 vat_json_node_t node;
1429 vat_json_init_object (&node);
1430 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1431 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1433 vat_json_print (vam->ofp, &node);
1434 vat_json_free (&node);
1436 vam->retval = ntohl (mp->retval);
1437 vam->result_ready = 1;
1441 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1443 vat_main_t *vam = &vat_main;
1444 i32 retval = ntohl (mp->retval);
1445 if (vam->async_mode)
1447 vam->async_errors += (retval < 0);
1451 vam->retval = retval;
1452 vam->result_ready = 1;
1456 static void vl_api_tap_delete_reply_t_handler_json
1457 (vl_api_tap_delete_reply_t * mp)
1459 vat_main_t *vam = &vat_main;
1460 vat_json_node_t node;
1462 vat_json_init_object (&node);
1463 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1465 vat_json_print (vam->ofp, &node);
1466 vat_json_free (&node);
1468 vam->retval = ntohl (mp->retval);
1469 vam->result_ready = 1;
1472 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1473 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1475 vat_main_t *vam = &vat_main;
1476 i32 retval = ntohl (mp->retval);
1477 if (vam->async_mode)
1479 vam->async_errors += (retval < 0);
1483 vam->retval = retval;
1484 vam->result_ready = 1;
1488 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1489 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1491 vat_main_t *vam = &vat_main;
1492 vat_json_node_t node;
1494 vat_json_init_object (&node);
1495 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1496 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1497 ntohl (mp->tunnel_sw_if_index));
1499 vat_json_print (vam->ofp, &node);
1500 vat_json_free (&node);
1502 vam->retval = ntohl (mp->retval);
1503 vam->result_ready = 1;
1506 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1507 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1509 vat_main_t *vam = &vat_main;
1510 i32 retval = ntohl (mp->retval);
1511 if (vam->async_mode)
1513 vam->async_errors += (retval < 0);
1517 vam->retval = retval;
1518 vam->sw_if_index = ntohl (mp->sw_if_index);
1519 vam->result_ready = 1;
1523 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1524 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1526 vat_main_t *vam = &vat_main;
1527 vat_json_node_t node;
1529 vat_json_init_object (&node);
1530 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1531 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1533 vat_json_print (vam->ofp, &node);
1534 vat_json_free (&node);
1536 vam->retval = ntohl (mp->retval);
1537 vam->result_ready = 1;
1541 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1542 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1544 vat_main_t *vam = &vat_main;
1545 i32 retval = ntohl (mp->retval);
1546 if (vam->async_mode)
1548 vam->async_errors += (retval < 0);
1552 vam->retval = retval;
1553 vam->result_ready = 1;
1557 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1558 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1560 vat_main_t *vam = &vat_main;
1561 vat_json_node_t node;
1563 vat_json_init_object (&node);
1564 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1565 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1567 vat_json_print (vam->ofp, &node);
1568 vat_json_free (&node);
1570 vam->retval = ntohl (mp->retval);
1571 vam->result_ready = 1;
1574 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1575 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1577 vat_main_t *vam = &vat_main;
1578 i32 retval = ntohl (mp->retval);
1579 if (vam->async_mode)
1581 vam->async_errors += (retval < 0);
1585 vam->retval = retval;
1586 vam->sw_if_index = ntohl (mp->sw_if_index);
1587 vam->result_ready = 1;
1591 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1592 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1594 vat_main_t *vam = &vat_main;
1595 vat_json_node_t node;
1597 vat_json_init_object (&node);
1598 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1599 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1601 vat_json_print (vam->ofp, &node);
1602 vat_json_free (&node);
1604 vam->retval = ntohl (mp->retval);
1605 vam->result_ready = 1;
1608 static void vl_api_gre_add_del_tunnel_reply_t_handler
1609 (vl_api_gre_add_del_tunnel_reply_t * mp)
1611 vat_main_t *vam = &vat_main;
1612 i32 retval = ntohl (mp->retval);
1613 if (vam->async_mode)
1615 vam->async_errors += (retval < 0);
1619 vam->retval = retval;
1620 vam->sw_if_index = ntohl (mp->sw_if_index);
1621 vam->result_ready = 1;
1625 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1626 (vl_api_gre_add_del_tunnel_reply_t * mp)
1628 vat_main_t *vam = &vat_main;
1629 vat_json_node_t node;
1631 vat_json_init_object (&node);
1632 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1633 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1635 vat_json_print (vam->ofp, &node);
1636 vat_json_free (&node);
1638 vam->retval = ntohl (mp->retval);
1639 vam->result_ready = 1;
1642 static void vl_api_create_vhost_user_if_reply_t_handler
1643 (vl_api_create_vhost_user_if_reply_t * mp)
1645 vat_main_t *vam = &vat_main;
1646 i32 retval = ntohl (mp->retval);
1647 if (vam->async_mode)
1649 vam->async_errors += (retval < 0);
1653 vam->retval = retval;
1654 vam->sw_if_index = ntohl (mp->sw_if_index);
1655 vam->result_ready = 1;
1659 static void vl_api_create_vhost_user_if_reply_t_handler_json
1660 (vl_api_create_vhost_user_if_reply_t * mp)
1662 vat_main_t *vam = &vat_main;
1663 vat_json_node_t node;
1665 vat_json_init_object (&node);
1666 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1667 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1669 vat_json_print (vam->ofp, &node);
1670 vat_json_free (&node);
1672 vam->retval = ntohl (mp->retval);
1673 vam->result_ready = 1;
1676 static void vl_api_ip_address_details_t_handler
1677 (vl_api_ip_address_details_t * mp)
1679 vat_main_t *vam = &vat_main;
1680 static ip_address_details_t empty_ip_address_details = { {0} };
1681 ip_address_details_t *address = NULL;
1682 ip_details_t *current_ip_details = NULL;
1683 ip_details_t *details = NULL;
1685 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1687 if (!details || vam->current_sw_if_index >= vec_len (details)
1688 || !details[vam->current_sw_if_index].present)
1690 errmsg ("ip address details arrived but not stored\n");
1691 errmsg ("ip_dump should be called first\n");
1695 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1697 #define addresses (current_ip_details->addr)
1699 vec_validate_init_empty (addresses, vec_len (addresses),
1700 empty_ip_address_details);
1702 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1704 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1705 address->prefix_length = mp->prefix_length;
1709 static void vl_api_ip_address_details_t_handler_json
1710 (vl_api_ip_address_details_t * mp)
1712 vat_main_t *vam = &vat_main;
1713 vat_json_node_t *node = NULL;
1714 struct in6_addr ip6;
1717 if (VAT_JSON_ARRAY != vam->json_tree.type)
1719 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1720 vat_json_init_array (&vam->json_tree);
1722 node = vat_json_array_add (&vam->json_tree);
1724 vat_json_init_object (node);
1727 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1728 vat_json_object_add_ip6 (node, "ip", ip6);
1732 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1733 vat_json_object_add_ip4 (node, "ip", ip4);
1735 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1739 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1741 vat_main_t *vam = &vat_main;
1742 static ip_details_t empty_ip_details = { 0 };
1743 ip_details_t *ip = NULL;
1744 u32 sw_if_index = ~0;
1746 sw_if_index = ntohl (mp->sw_if_index);
1748 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1749 sw_if_index, empty_ip_details);
1751 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1758 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1760 vat_main_t *vam = &vat_main;
1762 if (VAT_JSON_ARRAY != vam->json_tree.type)
1764 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1765 vat_json_init_array (&vam->json_tree);
1767 vat_json_array_add_uint (&vam->json_tree,
1768 clib_net_to_host_u32 (mp->sw_if_index));
1771 static void vl_api_map_domain_details_t_handler_json
1772 (vl_api_map_domain_details_t * mp)
1774 vat_json_node_t *node = NULL;
1775 vat_main_t *vam = &vat_main;
1776 struct in6_addr ip6;
1779 if (VAT_JSON_ARRAY != vam->json_tree.type)
1781 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1782 vat_json_init_array (&vam->json_tree);
1785 node = vat_json_array_add (&vam->json_tree);
1786 vat_json_init_object (node);
1788 vat_json_object_add_uint (node, "domain_index",
1789 clib_net_to_host_u32 (mp->domain_index));
1790 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1791 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1792 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1793 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1794 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1795 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1796 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1797 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1798 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1799 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1800 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1801 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1802 vat_json_object_add_uint (node, "flags", mp->flags);
1803 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1804 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1807 static void vl_api_map_domain_details_t_handler
1808 (vl_api_map_domain_details_t * mp)
1810 vat_main_t *vam = &vat_main;
1812 if (mp->is_translation)
1815 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1816 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1817 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1818 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1819 clib_net_to_host_u32 (mp->domain_index));
1824 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1825 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1826 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1827 format_ip6_address, mp->ip6_src,
1828 clib_net_to_host_u32 (mp->domain_index));
1830 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1831 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1832 mp->is_translation ? "map-t" : "");
1835 static void vl_api_map_rule_details_t_handler_json
1836 (vl_api_map_rule_details_t * mp)
1838 struct in6_addr ip6;
1839 vat_json_node_t *node = NULL;
1840 vat_main_t *vam = &vat_main;
1842 if (VAT_JSON_ARRAY != vam->json_tree.type)
1844 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1845 vat_json_init_array (&vam->json_tree);
1848 node = vat_json_array_add (&vam->json_tree);
1849 vat_json_init_object (node);
1851 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1852 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1853 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1857 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1859 vat_main_t *vam = &vat_main;
1860 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1861 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1865 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1867 vat_main_t *vam = &vat_main;
1868 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1869 "router_addr %U host_mac %U\n",
1870 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1871 format_ip4_address, &mp->host_address,
1872 format_ip4_address, &mp->router_address,
1873 format_ethernet_address, mp->host_mac);
1876 static void vl_api_dhcp_compl_event_t_handler_json
1877 (vl_api_dhcp_compl_event_t * mp)
1879 /* JSON output not supported */
1883 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1886 vat_main_t *vam = &vat_main;
1887 static u64 default_counter = 0;
1889 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1891 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1892 sw_if_index, default_counter);
1893 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1897 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1898 interface_counter_t counter)
1900 vat_main_t *vam = &vat_main;
1901 static interface_counter_t default_counter = { 0, };
1903 vec_validate_init_empty (vam->combined_interface_counters,
1904 vnet_counter_type, NULL);
1905 vec_validate_init_empty (vam->combined_interface_counters
1906 [vnet_counter_type], sw_if_index, default_counter);
1907 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1910 static void vl_api_vnet_interface_counters_t_handler
1911 (vl_api_vnet_interface_counters_t * mp)
1916 static void vl_api_vnet_interface_counters_t_handler_json
1917 (vl_api_vnet_interface_counters_t * mp)
1919 interface_counter_t counter;
1924 u32 first_sw_if_index;
1927 count = ntohl (mp->count);
1928 first_sw_if_index = ntohl (mp->first_sw_if_index);
1930 if (!mp->is_combined)
1932 v_packets = (u64 *) & mp->data;
1933 for (i = 0; i < count; i++)
1936 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1937 set_simple_interface_counter (mp->vnet_counter_type,
1938 first_sw_if_index + i, packets);
1944 v = (vlib_counter_t *) & mp->data;
1945 for (i = 0; i < count; i++)
1948 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1950 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1951 set_combined_interface_counter (mp->vnet_counter_type,
1952 first_sw_if_index + i, counter);
1959 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1961 vat_main_t *vam = &vat_main;
1964 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1966 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1975 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1977 vat_main_t *vam = &vat_main;
1980 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1982 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
1990 static void vl_api_vnet_ip4_fib_counters_t_handler
1991 (vl_api_vnet_ip4_fib_counters_t * mp)
1996 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1997 (vl_api_vnet_ip4_fib_counters_t * mp)
1999 vat_main_t *vam = &vat_main;
2000 vl_api_ip4_fib_counter_t *v;
2001 ip4_fib_counter_t *counter;
2008 vrf_id = ntohl (mp->vrf_id);
2009 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2010 if (~0 == vrf_index)
2012 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
2013 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
2014 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2015 vec_validate (vam->ip4_fib_counters, vrf_index);
2016 vam->ip4_fib_counters[vrf_index] = NULL;
2019 vec_free (vam->ip4_fib_counters[vrf_index]);
2020 v = (vl_api_ip4_fib_counter_t *) & mp->c;
2021 count = ntohl (mp->count);
2022 for (i = 0; i < count; i++)
2024 vec_validate (vam->ip4_fib_counters[vrf_index], i);
2025 counter = &vam->ip4_fib_counters[vrf_index][i];
2026 clib_memcpy (&ip4, &v->address, sizeof (ip4));
2027 counter->address = ip4;
2028 counter->address_length = v->address_length;
2029 counter->packets = clib_net_to_host_u64 (v->packets);
2030 counter->bytes = clib_net_to_host_u64 (v->bytes);
2035 static void vl_api_vnet_ip6_fib_counters_t_handler
2036 (vl_api_vnet_ip6_fib_counters_t * mp)
2041 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2042 (vl_api_vnet_ip6_fib_counters_t * mp)
2044 vat_main_t *vam = &vat_main;
2045 vl_api_ip6_fib_counter_t *v;
2046 ip6_fib_counter_t *counter;
2047 struct in6_addr ip6;
2053 vrf_id = ntohl (mp->vrf_id);
2054 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2055 if (~0 == vrf_index)
2057 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2058 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2059 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2060 vec_validate (vam->ip6_fib_counters, vrf_index);
2061 vam->ip6_fib_counters[vrf_index] = NULL;
2064 vec_free (vam->ip6_fib_counters[vrf_index]);
2065 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2066 count = ntohl (mp->count);
2067 for (i = 0; i < count; i++)
2069 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2070 counter = &vam->ip6_fib_counters[vrf_index][i];
2071 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2072 counter->address = ip6;
2073 counter->address_length = v->address_length;
2074 counter->packets = clib_net_to_host_u64 (v->packets);
2075 counter->bytes = clib_net_to_host_u64 (v->bytes);
2080 static void vl_api_get_first_msg_id_reply_t_handler
2081 (vl_api_get_first_msg_id_reply_t * mp)
2083 vat_main_t *vam = &vat_main;
2084 i32 retval = ntohl (mp->retval);
2086 if (vam->async_mode)
2088 vam->async_errors += (retval < 0);
2092 vam->retval = retval;
2093 vam->result_ready = 1;
2097 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2101 static void vl_api_get_first_msg_id_reply_t_handler_json
2102 (vl_api_get_first_msg_id_reply_t * mp)
2104 vat_main_t *vam = &vat_main;
2105 vat_json_node_t node;
2107 vat_json_init_object (&node);
2108 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2109 vat_json_object_add_uint (&node, "first_msg_id",
2110 (uint) ntohs (mp->first_msg_id));
2112 vat_json_print (vam->ofp, &node);
2113 vat_json_free (&node);
2115 vam->retval = ntohl (mp->retval);
2116 vam->result_ready = 1;
2119 static void vl_api_get_node_graph_reply_t_handler
2120 (vl_api_get_node_graph_reply_t * mp)
2122 vat_main_t *vam = &vat_main;
2123 api_main_t *am = &api_main;
2124 i32 retval = ntohl (mp->retval);
2125 u8 *pvt_copy, *reply;
2130 if (vam->async_mode)
2132 vam->async_errors += (retval < 0);
2136 vam->retval = retval;
2137 vam->result_ready = 1;
2140 /* "Should never happen..." */
2144 reply = (u8 *) (mp->reply_in_shmem);
2145 pvt_copy = vec_dup (reply);
2147 /* Toss the shared-memory original... */
2148 pthread_mutex_lock (&am->vlib_rp->mutex);
2149 oldheap = svm_push_data_heap (am->vlib_rp);
2153 svm_pop_heap (oldheap);
2154 pthread_mutex_unlock (&am->vlib_rp->mutex);
2156 if (vam->graph_nodes)
2158 hash_free (vam->graph_node_index_by_name);
2160 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2162 node = vam->graph_nodes[i];
2163 vec_free (node->name);
2164 vec_free (node->next_nodes);
2167 vec_free (vam->graph_nodes);
2170 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2171 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2172 vec_free (pvt_copy);
2174 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2176 node = vam->graph_nodes[i];
2177 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2181 static void vl_api_get_node_graph_reply_t_handler_json
2182 (vl_api_get_node_graph_reply_t * mp)
2184 vat_main_t *vam = &vat_main;
2185 api_main_t *am = &api_main;
2187 vat_json_node_t node;
2190 /* $$$$ make this real? */
2191 vat_json_init_object (&node);
2192 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2193 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2195 reply = (u8 *) (mp->reply_in_shmem);
2197 /* Toss the shared-memory original... */
2198 pthread_mutex_lock (&am->vlib_rp->mutex);
2199 oldheap = svm_push_data_heap (am->vlib_rp);
2203 svm_pop_heap (oldheap);
2204 pthread_mutex_unlock (&am->vlib_rp->mutex);
2206 vat_json_print (vam->ofp, &node);
2207 vat_json_free (&node);
2209 vam->retval = ntohl (mp->retval);
2210 vam->result_ready = 1;
2214 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2216 vat_main_t *vam = &vat_main;
2221 s = format (s, "%=16d%=16d%=16d\n",
2222 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2226 s = format (s, "%=16U%=16d%=16d\n",
2227 mp->is_ipv6 ? format_ip6_address :
2229 mp->ip_address, mp->priority, mp->weight);
2232 fformat (vam->ofp, "%v", s);
2237 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2240 vat_main_t *vam = &vat_main;
2241 vat_json_node_t *node = NULL;
2242 struct in6_addr ip6;
2245 if (VAT_JSON_ARRAY != vam->json_tree.type)
2247 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2248 vat_json_init_array (&vam->json_tree);
2250 node = vat_json_array_add (&vam->json_tree);
2251 vat_json_init_object (node);
2253 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2254 vat_json_object_add_uint (node, "priority", mp->priority);
2255 vat_json_object_add_uint (node, "weight", mp->weight);
2258 vat_json_object_add_uint (node, "sw_if_index",
2259 clib_net_to_host_u32 (mp->sw_if_index));
2264 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2265 vat_json_object_add_ip6 (node, "address", ip6);
2269 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2270 vat_json_object_add_ip4 (node, "address", ip4);
2276 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2279 vat_main_t *vam = &vat_main;
2282 ls_name = format (0, "%s", mp->ls_name);
2284 fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
2290 vl_api_lisp_locator_set_details_t_handler_json
2291 (vl_api_lisp_locator_set_details_t * mp)
2293 vat_main_t *vam = &vat_main;
2294 vat_json_node_t *node = 0;
2297 ls_name = format (0, "%s", mp->ls_name);
2298 vec_add1 (ls_name, 0);
2300 if (VAT_JSON_ARRAY != vam->json_tree.type)
2302 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2303 vat_json_init_array (&vam->json_tree);
2305 node = vat_json_array_add (&vam->json_tree);
2307 vat_json_init_object (node);
2308 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2309 vat_json_object_add_uint (node, "ls_index",
2310 clib_net_to_host_u32 (mp->ls_index));
2315 format_lisp_flat_eid (u8 * s, va_list * args)
2317 u32 type = va_arg (*args, u32);
2318 u8 *eid = va_arg (*args, u8 *);
2319 u32 eid_len = va_arg (*args, u32);
2324 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2326 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2328 return format (s, "%U", format_ethernet_address, eid);
2334 format_lisp_eid_vat (u8 * s, va_list * args)
2336 u32 type = va_arg (*args, u32);
2337 u8 *eid = va_arg (*args, u8 *);
2338 u32 eid_len = va_arg (*args, u32);
2339 u8 *seid = va_arg (*args, u8 *);
2340 u32 seid_len = va_arg (*args, u32);
2341 u32 is_src_dst = va_arg (*args, u32);
2344 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2346 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2352 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2354 vat_main_t *vam = &vat_main;
2355 u8 *s = 0, *eid = 0;
2357 if (~0 == mp->locator_set_index)
2358 s = format (0, "action: %d", mp->action);
2360 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2362 eid = format (0, "%U", format_lisp_eid_vat,
2366 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2369 fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-d\n",
2370 clib_net_to_host_u32 (mp->vni),
2372 mp->is_local ? "local" : "remote",
2373 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative);
2379 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2382 vat_main_t *vam = &vat_main;
2383 vat_json_node_t *node = 0;
2386 if (VAT_JSON_ARRAY != vam->json_tree.type)
2388 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2389 vat_json_init_array (&vam->json_tree);
2391 node = vat_json_array_add (&vam->json_tree);
2393 vat_json_init_object (node);
2394 if (~0 == mp->locator_set_index)
2395 vat_json_object_add_uint (node, "action", mp->action);
2397 vat_json_object_add_uint (node, "locator_set_index",
2398 clib_net_to_host_u32 (mp->locator_set_index));
2400 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2401 eid = format (0, "%U", format_lisp_eid_vat,
2405 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2407 vat_json_object_add_string_copy (node, "eid", eid);
2408 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2409 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2410 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2415 vl_api_lisp_eid_table_map_details_t_handler
2416 (vl_api_lisp_eid_table_map_details_t * mp)
2418 vat_main_t *vam = &vat_main;
2420 u8 *line = format (0, "%=10d%=10d",
2421 clib_net_to_host_u32 (mp->vni),
2422 clib_net_to_host_u32 (mp->dp_table));
2423 fformat (vam->ofp, "%v\n", line);
2428 vl_api_lisp_eid_table_map_details_t_handler_json
2429 (vl_api_lisp_eid_table_map_details_t * mp)
2431 vat_main_t *vam = &vat_main;
2432 vat_json_node_t *node = NULL;
2434 if (VAT_JSON_ARRAY != vam->json_tree.type)
2436 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2437 vat_json_init_array (&vam->json_tree);
2439 node = vat_json_array_add (&vam->json_tree);
2440 vat_json_init_object (node);
2441 vat_json_object_add_uint (node, "dp_table",
2442 clib_net_to_host_u32 (mp->dp_table));
2443 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2447 vl_api_lisp_eid_table_vni_details_t_handler
2448 (vl_api_lisp_eid_table_vni_details_t * mp)
2450 vat_main_t *vam = &vat_main;
2452 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2453 fformat (vam->ofp, "%v\n", line);
2458 vl_api_lisp_eid_table_vni_details_t_handler_json
2459 (vl_api_lisp_eid_table_vni_details_t * mp)
2461 vat_main_t *vam = &vat_main;
2462 vat_json_node_t *node = NULL;
2464 if (VAT_JSON_ARRAY != vam->json_tree.type)
2466 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2467 vat_json_init_array (&vam->json_tree);
2469 node = vat_json_array_add (&vam->json_tree);
2470 vat_json_init_object (node);
2471 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2475 format_decap_next (u8 * s, va_list * args)
2477 u32 next_index = va_arg (*args, u32);
2481 case LISP_GPE_INPUT_NEXT_DROP:
2482 return format (s, "drop");
2483 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2484 return format (s, "ip4");
2485 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2486 return format (s, "ip6");
2488 return format (s, "unknown %d", next_index);
2494 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2497 vat_main_t *vam = &vat_main;
2499 u8 *flag_str = NULL;
2501 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2503 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2504 foreach_lisp_gpe_flag_bit;
2507 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2508 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2510 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2512 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2514 ntohl (mp->encap_fib_id),
2515 ntohl (mp->decap_fib_id),
2516 format_decap_next, ntohl (mp->dcap_next),
2518 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2524 vl_api_lisp_gpe_tunnel_details_t_handler_json
2525 (vl_api_lisp_gpe_tunnel_details_t * mp)
2527 vat_main_t *vam = &vat_main;
2528 vat_json_node_t *node = NULL;
2529 struct in6_addr ip6;
2533 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2535 if (VAT_JSON_ARRAY != vam->json_tree.type)
2537 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2538 vat_json_init_array (&vam->json_tree);
2540 node = vat_json_array_add (&vam->json_tree);
2542 vat_json_init_object (node);
2543 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2546 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2547 vat_json_object_add_ip6 (node, "source address", ip6);
2548 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2549 vat_json_object_add_ip6 (node, "destination address", ip6);
2553 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2554 vat_json_object_add_ip4 (node, "source address", ip4);
2555 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2556 vat_json_object_add_ip4 (node, "destination address", ip4);
2558 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2559 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2560 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2561 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2562 vat_json_object_add_uint (node, "flags", mp->flags);
2563 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2564 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2565 vat_json_object_add_uint (node, "res", mp->res);
2566 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2568 vec_free (next_decap_str);
2572 vl_api_lisp_adjacencies_get_reply_t_handler
2573 (vl_api_lisp_adjacencies_get_reply_t * mp)
2575 vat_main_t *vam = &vat_main;
2577 int retval = clib_net_to_host_u32 (mp->retval);
2578 vl_api_lisp_adjacency_t *a;
2583 n = clib_net_to_host_u32 (mp->count);
2585 for (i = 0; i < n; i++)
2587 a = &mp->adjacencies[i];
2588 fformat (vam->ofp, "%U %40U\n",
2589 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2590 format_lisp_flat_eid, a->eid_type, a->reid,
2591 a->reid_prefix_len);
2595 vam->retval = retval;
2596 vam->result_ready = 1;
2600 vl_api_lisp_adjacencies_get_reply_t_handler_json
2601 (vl_api_lisp_adjacencies_get_reply_t * mp)
2604 vat_main_t *vam = &vat_main;
2605 vat_json_node_t *e = 0, root;
2607 int retval = clib_net_to_host_u32 (mp->retval);
2608 vl_api_lisp_adjacency_t *a;
2613 n = clib_net_to_host_u32 (mp->count);
2614 vat_json_init_array (&root);
2616 for (i = 0; i < n; i++)
2618 e = vat_json_array_add (&root);
2619 a = &mp->adjacencies[i];
2621 vat_json_init_object (e);
2622 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2623 a->leid_prefix_len);
2625 vat_json_object_add_string_copy (e, "leid", s);
2628 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2629 a->reid_prefix_len);
2631 vat_json_object_add_string_copy (e, "reid", s);
2635 vat_json_print (vam->ofp, &root);
2636 vat_json_free (&root);
2639 vam->retval = retval;
2640 vam->result_ready = 1;
2644 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2647 vat_main_t *vam = &vat_main;
2649 fformat (vam->ofp, "%=20U\n",
2650 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2655 vl_api_lisp_map_resolver_details_t_handler_json
2656 (vl_api_lisp_map_resolver_details_t * mp)
2658 vat_main_t *vam = &vat_main;
2659 vat_json_node_t *node = NULL;
2660 struct in6_addr ip6;
2663 if (VAT_JSON_ARRAY != vam->json_tree.type)
2665 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2666 vat_json_init_array (&vam->json_tree);
2668 node = vat_json_array_add (&vam->json_tree);
2670 vat_json_init_object (node);
2673 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2674 vat_json_object_add_ip6 (node, "map resolver", ip6);
2678 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2679 vat_json_object_add_ip4 (node, "map resolver", ip4);
2684 vl_api_show_lisp_status_reply_t_handler
2685 (vl_api_show_lisp_status_reply_t * mp)
2687 vat_main_t *vam = &vat_main;
2688 i32 retval = ntohl (mp->retval);
2692 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2693 mp->feature_status ? "enabled" : "disabled",
2694 mp->gpe_status ? "enabled" : "disabled");
2697 vam->retval = retval;
2698 vam->result_ready = 1;
2702 vl_api_show_lisp_status_reply_t_handler_json
2703 (vl_api_show_lisp_status_reply_t * mp)
2705 vat_main_t *vam = &vat_main;
2706 vat_json_node_t node;
2707 u8 *gpe_status = NULL;
2708 u8 *feature_status = NULL;
2710 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2711 feature_status = format (0, "%s",
2712 mp->feature_status ? "enabled" : "disabled");
2713 vec_add1 (gpe_status, 0);
2714 vec_add1 (feature_status, 0);
2716 vat_json_init_object (&node);
2717 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2718 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2720 vec_free (gpe_status);
2721 vec_free (feature_status);
2723 vat_json_print (vam->ofp, &node);
2724 vat_json_free (&node);
2726 vam->retval = ntohl (mp->retval);
2727 vam->result_ready = 1;
2731 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2732 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2734 vat_main_t *vam = &vat_main;
2735 i32 retval = ntohl (mp->retval);
2739 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2742 vam->retval = retval;
2743 vam->result_ready = 1;
2747 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2748 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2750 vat_main_t *vam = &vat_main;
2751 vat_json_node_t *node = NULL;
2753 if (VAT_JSON_ARRAY != vam->json_tree.type)
2755 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2756 vat_json_init_array (&vam->json_tree);
2758 node = vat_json_array_add (&vam->json_tree);
2760 vat_json_init_object (node);
2761 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2763 vat_json_print (vam->ofp, node);
2764 vat_json_free (node);
2766 vam->retval = ntohl (mp->retval);
2767 vam->result_ready = 1;
2771 format_lisp_map_request_mode (u8 * s, va_list * args)
2773 u32 mode = va_arg (*args, u32);
2778 return format (0, "dst-only");
2780 return format (0, "src-dst");
2786 vl_api_show_lisp_map_request_mode_reply_t_handler
2787 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2789 vat_main_t *vam = &vat_main;
2790 i32 retval = ntohl (mp->retval);
2794 u32 mode = mp->mode;
2795 fformat (vam->ofp, "map_request_mode: %U\n",
2796 format_lisp_map_request_mode, mode);
2799 vam->retval = retval;
2800 vam->result_ready = 1;
2804 vl_api_show_lisp_map_request_mode_reply_t_handler_json
2805 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2807 vat_main_t *vam = &vat_main;
2808 vat_json_node_t node;
2813 s = format (0, "%U", format_lisp_map_request_mode, mode);
2816 vat_json_init_object (&node);
2817 vat_json_object_add_string_copy (&node, "map_request_mode", s);
2818 vat_json_print (vam->ofp, &node);
2819 vat_json_free (&node);
2822 vam->retval = ntohl (mp->retval);
2823 vam->result_ready = 1;
2827 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2829 vat_main_t *vam = &vat_main;
2830 i32 retval = ntohl (mp->retval);
2834 fformat (vam->ofp, "%-20s%-16s\n",
2835 mp->status ? "enabled" : "disabled",
2836 mp->status ? (char *) mp->locator_set_name : "");
2839 vam->retval = retval;
2840 vam->result_ready = 1;
2844 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2847 vat_main_t *vam = &vat_main;
2848 vat_json_node_t node;
2851 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2852 vec_add1 (status, 0);
2854 vat_json_init_object (&node);
2855 vat_json_object_add_string_copy (&node, "status", status);
2858 vat_json_object_add_string_copy (&node, "locator_set",
2859 mp->locator_set_name);
2864 vat_json_print (vam->ofp, &node);
2865 vat_json_free (&node);
2867 vam->retval = ntohl (mp->retval);
2868 vam->result_ready = 1;
2872 format_policer_type (u8 * s, va_list * va)
2874 u32 i = va_arg (*va, u32);
2876 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2877 s = format (s, "1r2c");
2878 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2879 s = format (s, "1r3c");
2880 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2881 s = format (s, "2r3c-2698");
2882 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2883 s = format (s, "2r3c-4115");
2884 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2885 s = format (s, "2r3c-mef5cf1");
2887 s = format (s, "ILLEGAL");
2892 format_policer_rate_type (u8 * s, va_list * va)
2894 u32 i = va_arg (*va, u32);
2896 if (i == SSE2_QOS_RATE_KBPS)
2897 s = format (s, "kbps");
2898 else if (i == SSE2_QOS_RATE_PPS)
2899 s = format (s, "pps");
2901 s = format (s, "ILLEGAL");
2906 format_policer_round_type (u8 * s, va_list * va)
2908 u32 i = va_arg (*va, u32);
2910 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2911 s = format (s, "closest");
2912 else if (i == SSE2_QOS_ROUND_TO_UP)
2913 s = format (s, "up");
2914 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2915 s = format (s, "down");
2917 s = format (s, "ILLEGAL");
2922 format_policer_action_type (u8 * s, va_list * va)
2924 u32 i = va_arg (*va, u32);
2926 if (i == SSE2_QOS_ACTION_DROP)
2927 s = format (s, "drop");
2928 else if (i == SSE2_QOS_ACTION_TRANSMIT)
2929 s = format (s, "transmit");
2930 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2931 s = format (s, "mark-and-transmit");
2933 s = format (s, "ILLEGAL");
2938 format_dscp (u8 * s, va_list * va)
2940 u32 i = va_arg (*va, u32);
2945 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
2949 return format (s, "ILLEGAL");
2951 s = format (s, "%s", t);
2956 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
2958 vat_main_t *vam = &vat_main;
2959 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
2961 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2962 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
2964 conform_dscp_str = format (0, "");
2966 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2967 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
2969 exceed_dscp_str = format (0, "");
2971 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
2972 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
2974 violate_dscp_str = format (0, "");
2976 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2977 "rate type %U, round type %U, %s rate, %s color-aware, "
2978 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2979 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
2980 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
2982 format_policer_type, mp->type,
2985 clib_net_to_host_u64 (mp->cb),
2986 clib_net_to_host_u64 (mp->eb),
2987 format_policer_rate_type, mp->rate_type,
2988 format_policer_round_type, mp->round_type,
2989 mp->single_rate ? "single" : "dual",
2990 mp->color_aware ? "is" : "not",
2991 ntohl (mp->cir_tokens_per_period),
2992 ntohl (mp->pir_tokens_per_period),
2994 ntohl (mp->current_limit),
2995 ntohl (mp->current_bucket),
2996 ntohl (mp->extended_limit),
2997 ntohl (mp->extended_bucket),
2998 clib_net_to_host_u64 (mp->last_update_time),
2999 format_policer_action_type, mp->conform_action_type,
3001 format_policer_action_type, mp->exceed_action_type,
3003 format_policer_action_type, mp->violate_action_type,
3006 vec_free (conform_dscp_str);
3007 vec_free (exceed_dscp_str);
3008 vec_free (violate_dscp_str);
3011 static void vl_api_policer_details_t_handler_json
3012 (vl_api_policer_details_t * mp)
3014 vat_main_t *vam = &vat_main;
3015 vat_json_node_t *node;
3016 u8 *rate_type_str, *round_type_str, *type_str;
3017 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3019 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3021 format (0, "%U", format_policer_round_type, mp->round_type);
3022 type_str = format (0, "%U", format_policer_type, mp->type);
3023 conform_action_str = format (0, "%U", format_policer_action_type,
3024 mp->conform_action_type);
3025 exceed_action_str = format (0, "%U", format_policer_action_type,
3026 mp->exceed_action_type);
3027 violate_action_str = format (0, "%U", format_policer_action_type,
3028 mp->violate_action_type);
3030 if (VAT_JSON_ARRAY != vam->json_tree.type)
3032 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3033 vat_json_init_array (&vam->json_tree);
3035 node = vat_json_array_add (&vam->json_tree);
3037 vat_json_init_object (node);
3038 vat_json_object_add_string_copy (node, "name", mp->name);
3039 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3040 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3041 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3042 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3043 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3044 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3045 vat_json_object_add_string_copy (node, "type", type_str);
3046 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3047 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3048 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3049 vat_json_object_add_uint (node, "cir_tokens_per_period",
3050 ntohl (mp->cir_tokens_per_period));
3051 vat_json_object_add_uint (node, "eir_tokens_per_period",
3052 ntohl (mp->pir_tokens_per_period));
3053 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3054 vat_json_object_add_uint (node, "current_bucket",
3055 ntohl (mp->current_bucket));
3056 vat_json_object_add_uint (node, "extended_limit",
3057 ntohl (mp->extended_limit));
3058 vat_json_object_add_uint (node, "extended_bucket",
3059 ntohl (mp->extended_bucket));
3060 vat_json_object_add_uint (node, "last_update_time",
3061 ntohl (mp->last_update_time));
3062 vat_json_object_add_string_copy (node, "conform_action",
3063 conform_action_str);
3064 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3066 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3067 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3068 vec_free (dscp_str);
3070 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3071 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3073 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3074 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3075 vec_free (dscp_str);
3077 vat_json_object_add_string_copy (node, "violate_action",
3078 violate_action_str);
3079 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3081 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3082 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3083 vec_free (dscp_str);
3086 vec_free (rate_type_str);
3087 vec_free (round_type_str);
3088 vec_free (type_str);
3089 vec_free (conform_action_str);
3090 vec_free (exceed_action_str);
3091 vec_free (violate_action_str);
3095 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3098 vat_main_t *vam = &vat_main;
3099 int i, count = ntohl (mp->count);
3102 fformat (vam->ofp, "classify table ids (%d) : ", count);
3103 for (i = 0; i < count; i++)
3105 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3106 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3108 vam->retval = ntohl (mp->retval);
3109 vam->result_ready = 1;
3113 vl_api_classify_table_ids_reply_t_handler_json
3114 (vl_api_classify_table_ids_reply_t * mp)
3116 vat_main_t *vam = &vat_main;
3117 int i, count = ntohl (mp->count);
3121 vat_json_node_t node;
3123 vat_json_init_object (&node);
3124 for (i = 0; i < count; i++)
3126 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3128 vat_json_print (vam->ofp, &node);
3129 vat_json_free (&node);
3131 vam->retval = ntohl (mp->retval);
3132 vam->result_ready = 1;
3136 vl_api_classify_table_by_interface_reply_t_handler
3137 (vl_api_classify_table_by_interface_reply_t * mp)
3139 vat_main_t *vam = &vat_main;
3142 table_id = ntohl (mp->l2_table_id);
3144 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3146 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3147 table_id = ntohl (mp->ip4_table_id);
3149 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3151 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3152 table_id = ntohl (mp->ip6_table_id);
3154 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3156 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3157 vam->retval = ntohl (mp->retval);
3158 vam->result_ready = 1;
3162 vl_api_classify_table_by_interface_reply_t_handler_json
3163 (vl_api_classify_table_by_interface_reply_t * mp)
3165 vat_main_t *vam = &vat_main;
3166 vat_json_node_t node;
3168 vat_json_init_object (&node);
3170 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3171 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3172 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3174 vat_json_print (vam->ofp, &node);
3175 vat_json_free (&node);
3177 vam->retval = ntohl (mp->retval);
3178 vam->result_ready = 1;
3181 static void vl_api_policer_add_del_reply_t_handler
3182 (vl_api_policer_add_del_reply_t * mp)
3184 vat_main_t *vam = &vat_main;
3185 i32 retval = ntohl (mp->retval);
3186 if (vam->async_mode)
3188 vam->async_errors += (retval < 0);
3192 vam->retval = retval;
3193 vam->result_ready = 1;
3194 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3196 * Note: this is just barely thread-safe, depends on
3197 * the main thread spinning waiting for an answer...
3199 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3203 static void vl_api_policer_add_del_reply_t_handler_json
3204 (vl_api_policer_add_del_reply_t * mp)
3206 vat_main_t *vam = &vat_main;
3207 vat_json_node_t node;
3209 vat_json_init_object (&node);
3210 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3211 vat_json_object_add_uint (&node, "policer_index",
3212 ntohl (mp->policer_index));
3214 vat_json_print (vam->ofp, &node);
3215 vat_json_free (&node);
3217 vam->retval = ntohl (mp->retval);
3218 vam->result_ready = 1;
3221 /* Format hex dump. */
3223 format_hex_bytes (u8 * s, va_list * va)
3225 u8 *bytes = va_arg (*va, u8 *);
3226 int n_bytes = va_arg (*va, int);
3229 /* Print short or long form depending on byte count. */
3230 uword short_form = n_bytes <= 32;
3231 uword indent = format_get_indent (s);
3236 for (i = 0; i < n_bytes; i++)
3238 if (!short_form && (i % 32) == 0)
3239 s = format (s, "%08x: ", i);
3240 s = format (s, "%02x", bytes[i]);
3241 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3242 s = format (s, "\n%U", format_white_space, indent);
3249 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3252 vat_main_t *vam = &vat_main;
3253 i32 retval = ntohl (mp->retval);
3256 fformat (vam->ofp, "classify table info :\n");
3257 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3258 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3259 ntohl (mp->miss_next_index));
3260 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3261 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3262 ntohl (mp->match_n_vectors));
3263 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3264 ntohl (mp->mask_length));
3266 vam->retval = retval;
3267 vam->result_ready = 1;
3271 vl_api_classify_table_info_reply_t_handler_json
3272 (vl_api_classify_table_info_reply_t * mp)
3274 vat_main_t *vam = &vat_main;
3275 vat_json_node_t node;
3277 i32 retval = ntohl (mp->retval);
3280 vat_json_init_object (&node);
3282 vat_json_object_add_int (&node, "sessions",
3283 ntohl (mp->active_sessions));
3284 vat_json_object_add_int (&node, "nexttbl",
3285 ntohl (mp->next_table_index));
3286 vat_json_object_add_int (&node, "nextnode",
3287 ntohl (mp->miss_next_index));
3288 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3289 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3290 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3291 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3292 ntohl (mp->mask_length), 0);
3293 vat_json_object_add_string_copy (&node, "mask", s);
3295 vat_json_print (vam->ofp, &node);
3296 vat_json_free (&node);
3298 vam->retval = ntohl (mp->retval);
3299 vam->result_ready = 1;
3303 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3306 vat_main_t *vam = &vat_main;
3308 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3309 ntohl (mp->hit_next_index), ntohl (mp->advance),
3310 ntohl (mp->opaque_index));
3311 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3312 ntohl (mp->match_length));
3316 vl_api_classify_session_details_t_handler_json
3317 (vl_api_classify_session_details_t * mp)
3319 vat_main_t *vam = &vat_main;
3320 vat_json_node_t *node = NULL;
3322 if (VAT_JSON_ARRAY != vam->json_tree.type)
3324 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3325 vat_json_init_array (&vam->json_tree);
3327 node = vat_json_array_add (&vam->json_tree);
3329 vat_json_init_object (node);
3330 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3331 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3332 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3334 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3336 vat_json_object_add_string_copy (node, "match", s);
3339 static void vl_api_pg_create_interface_reply_t_handler
3340 (vl_api_pg_create_interface_reply_t * mp)
3342 vat_main_t *vam = &vat_main;
3344 vam->retval = ntohl (mp->retval);
3345 vam->result_ready = 1;
3348 static void vl_api_pg_create_interface_reply_t_handler_json
3349 (vl_api_pg_create_interface_reply_t * mp)
3351 vat_main_t *vam = &vat_main;
3352 vat_json_node_t node;
3354 i32 retval = ntohl (mp->retval);
3357 vat_json_init_object (&node);
3359 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3361 vat_json_print (vam->ofp, &node);
3362 vat_json_free (&node);
3364 vam->retval = ntohl (mp->retval);
3365 vam->result_ready = 1;
3368 static void vl_api_policer_classify_details_t_handler
3369 (vl_api_policer_classify_details_t * mp)
3371 vat_main_t *vam = &vat_main;
3373 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3374 ntohl (mp->table_index));
3377 static void vl_api_policer_classify_details_t_handler_json
3378 (vl_api_policer_classify_details_t * mp)
3380 vat_main_t *vam = &vat_main;
3381 vat_json_node_t *node;
3383 if (VAT_JSON_ARRAY != vam->json_tree.type)
3385 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3386 vat_json_init_array (&vam->json_tree);
3388 node = vat_json_array_add (&vam->json_tree);
3390 vat_json_init_object (node);
3391 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3392 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3395 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3396 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3398 vat_main_t *vam = &vat_main;
3399 i32 retval = ntohl (mp->retval);
3400 if (vam->async_mode)
3402 vam->async_errors += (retval < 0);
3406 vam->retval = retval;
3407 vam->sw_if_index = ntohl (mp->sw_if_index);
3408 vam->result_ready = 1;
3412 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3413 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3415 vat_main_t *vam = &vat_main;
3416 vat_json_node_t node;
3418 vat_json_init_object (&node);
3419 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3420 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3422 vat_json_print (vam->ofp, &node);
3423 vat_json_free (&node);
3425 vam->retval = ntohl (mp->retval);
3426 vam->result_ready = 1;
3429 static void vl_api_flow_classify_details_t_handler
3430 (vl_api_flow_classify_details_t * mp)
3432 vat_main_t *vam = &vat_main;
3434 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3435 ntohl (mp->table_index));
3438 static void vl_api_flow_classify_details_t_handler_json
3439 (vl_api_flow_classify_details_t * mp)
3441 vat_main_t *vam = &vat_main;
3442 vat_json_node_t *node;
3444 if (VAT_JSON_ARRAY != vam->json_tree.type)
3446 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3447 vat_json_init_array (&vam->json_tree);
3449 node = vat_json_array_add (&vam->json_tree);
3451 vat_json_init_object (node);
3452 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3453 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3458 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3459 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3460 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3461 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3462 #define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
3463 #define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
3466 * Generate boilerplate reply handlers, which
3467 * dig the return value out of the xxx_reply_t API message,
3468 * stick it into vam->retval, and set vam->result_ready
3470 * Could also do this by pointing N message decode slots at
3471 * a single function, but that could break in subtle ways.
3474 #define foreach_standard_reply_retval_handler \
3475 _(sw_interface_set_flags_reply) \
3476 _(sw_interface_add_del_address_reply) \
3477 _(sw_interface_set_table_reply) \
3478 _(sw_interface_set_vpath_reply) \
3479 _(sw_interface_set_l2_bridge_reply) \
3480 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3481 _(sw_interface_set_dpdk_hqos_subport_reply) \
3482 _(sw_interface_set_dpdk_hqos_tctbl_reply) \
3483 _(bridge_domain_add_del_reply) \
3484 _(sw_interface_set_l2_xconnect_reply) \
3485 _(l2fib_add_del_reply) \
3486 _(ip_add_del_route_reply) \
3487 _(mpls_route_add_del_reply) \
3488 _(mpls_ip_bind_unbind_reply) \
3489 _(proxy_arp_add_del_reply) \
3490 _(proxy_arp_intfc_enable_disable_reply) \
3491 _(mpls_add_del_encap_reply) \
3492 _(mpls_ethernet_add_del_tunnel_2_reply) \
3493 _(sw_interface_set_unnumbered_reply) \
3494 _(ip_neighbor_add_del_reply) \
3495 _(reset_vrf_reply) \
3496 _(oam_add_del_reply) \
3497 _(reset_fib_reply) \
3498 _(dhcp_proxy_config_reply) \
3499 _(dhcp_proxy_config_2_reply) \
3500 _(dhcp_proxy_set_vss_reply) \
3501 _(dhcp_client_config_reply) \
3502 _(set_ip_flow_hash_reply) \
3503 _(sw_interface_ip6_enable_disable_reply) \
3504 _(sw_interface_ip6_set_link_local_address_reply) \
3505 _(sw_interface_ip6nd_ra_prefix_reply) \
3506 _(sw_interface_ip6nd_ra_config_reply) \
3507 _(set_arp_neighbor_limit_reply) \
3508 _(l2_patch_add_del_reply) \
3509 _(sr_tunnel_add_del_reply) \
3510 _(sr_policy_add_del_reply) \
3511 _(sr_multicast_map_add_del_reply) \
3512 _(classify_add_del_session_reply) \
3513 _(classify_set_interface_ip_table_reply) \
3514 _(classify_set_interface_l2_tables_reply) \
3515 _(l2tpv3_set_tunnel_cookies_reply) \
3516 _(l2tpv3_interface_enable_disable_reply) \
3517 _(l2tpv3_set_lookup_key_reply) \
3518 _(l2_fib_clear_table_reply) \
3519 _(l2_interface_efp_filter_reply) \
3520 _(l2_interface_vlan_tag_rewrite_reply) \
3521 _(modify_vhost_user_if_reply) \
3522 _(delete_vhost_user_if_reply) \
3523 _(want_ip4_arp_events_reply) \
3524 _(want_ip6_nd_events_reply) \
3525 _(input_acl_set_interface_reply) \
3526 _(ipsec_spd_add_del_reply) \
3527 _(ipsec_interface_add_del_spd_reply) \
3528 _(ipsec_spd_add_del_entry_reply) \
3529 _(ipsec_sad_add_del_entry_reply) \
3530 _(ipsec_sa_set_key_reply) \
3531 _(ikev2_profile_add_del_reply) \
3532 _(ikev2_profile_set_auth_reply) \
3533 _(ikev2_profile_set_id_reply) \
3534 _(ikev2_profile_set_ts_reply) \
3535 _(ikev2_set_local_key_reply) \
3536 _(delete_loopback_reply) \
3537 _(bd_ip_mac_add_del_reply) \
3538 _(map_del_domain_reply) \
3539 _(map_add_del_rule_reply) \
3540 _(want_interface_events_reply) \
3541 _(want_stats_reply) \
3542 _(cop_interface_enable_disable_reply) \
3543 _(cop_whitelist_enable_disable_reply) \
3544 _(sw_interface_clear_stats_reply) \
3545 _(ioam_enable_reply) \
3546 _(ioam_disable_reply) \
3547 _(lisp_add_del_locator_reply) \
3548 _(lisp_add_del_local_eid_reply) \
3549 _(lisp_add_del_remote_mapping_reply) \
3550 _(lisp_add_del_adjacency_reply) \
3551 _(lisp_gpe_add_del_fwd_entry_reply) \
3552 _(lisp_add_del_map_resolver_reply) \
3553 _(lisp_gpe_enable_disable_reply) \
3554 _(lisp_gpe_add_del_iface_reply) \
3555 _(lisp_enable_disable_reply) \
3556 _(lisp_pitr_set_locator_set_reply) \
3557 _(lisp_map_request_mode_reply) \
3558 _(lisp_add_del_map_request_itr_rlocs_reply) \
3559 _(lisp_eid_table_add_del_map_reply) \
3560 _(vxlan_gpe_add_del_tunnel_reply) \
3561 _(af_packet_delete_reply) \
3562 _(policer_classify_set_interface_reply) \
3563 _(netmap_create_reply) \
3564 _(netmap_delete_reply) \
3565 _(set_ipfix_exporter_reply) \
3566 _(set_ipfix_classify_stream_reply) \
3567 _(ipfix_classify_table_add_del_reply) \
3568 _(flow_classify_set_interface_reply) \
3569 _(pg_capture_reply) \
3570 _(pg_enable_disable_reply) \
3571 _(ip_source_and_port_range_check_add_del_reply) \
3572 _(ip_source_and_port_range_check_interface_add_del_reply)\
3573 _(delete_subif_reply) \
3574 _(l2_interface_pbb_tag_rewrite_reply) \
3578 static void vl_api_##n##_t_handler \
3579 (vl_api_##n##_t * mp) \
3581 vat_main_t * vam = &vat_main; \
3582 i32 retval = ntohl(mp->retval); \
3583 if (vam->async_mode) { \
3584 vam->async_errors += (retval < 0); \
3586 vam->retval = retval; \
3587 vam->result_ready = 1; \
3590 foreach_standard_reply_retval_handler;
3594 static void vl_api_##n##_t_handler_json \
3595 (vl_api_##n##_t * mp) \
3597 vat_main_t * vam = &vat_main; \
3598 vat_json_node_t node; \
3599 vat_json_init_object(&node); \
3600 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3601 vat_json_print(vam->ofp, &node); \
3602 vam->retval = ntohl(mp->retval); \
3603 vam->result_ready = 1; \
3605 foreach_standard_reply_retval_handler;
3609 * Table of message reply handlers, must include boilerplate handlers
3613 #define foreach_vpe_api_reply_msg \
3614 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3615 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3616 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3617 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3618 _(CONTROL_PING_REPLY, control_ping_reply) \
3619 _(CLI_REPLY, cli_reply) \
3620 _(CLI_INBAND_REPLY, cli_inband_reply) \
3621 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3622 sw_interface_add_del_address_reply) \
3623 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3624 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3625 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3626 sw_interface_set_l2_xconnect_reply) \
3627 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3628 sw_interface_set_l2_bridge_reply) \
3629 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
3630 sw_interface_set_dpdk_hqos_pipe_reply) \
3631 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
3632 sw_interface_set_dpdk_hqos_subport_reply) \
3633 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
3634 sw_interface_set_dpdk_hqos_tctbl_reply) \
3635 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3636 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3637 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3638 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3639 _(L2_FLAGS_REPLY, l2_flags_reply) \
3640 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3641 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3642 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3643 _(TAP_DELETE_REPLY, tap_delete_reply) \
3644 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3645 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3646 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
3647 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
3648 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3649 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3650 proxy_arp_intfc_enable_disable_reply) \
3651 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3652 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3653 mpls_ethernet_add_del_tunnel_reply) \
3654 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3655 mpls_ethernet_add_del_tunnel_2_reply) \
3656 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3657 sw_interface_set_unnumbered_reply) \
3658 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3659 _(RESET_VRF_REPLY, reset_vrf_reply) \
3660 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3661 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3662 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3663 _(RESET_FIB_REPLY, reset_fib_reply) \
3664 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3665 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3666 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3667 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3668 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3669 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3670 sw_interface_ip6_enable_disable_reply) \
3671 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3672 sw_interface_ip6_set_link_local_address_reply) \
3673 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3674 sw_interface_ip6nd_ra_prefix_reply) \
3675 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3676 sw_interface_ip6nd_ra_config_reply) \
3677 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3678 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3679 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3680 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3681 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3682 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3683 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3684 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3685 classify_set_interface_ip_table_reply) \
3686 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3687 classify_set_interface_l2_tables_reply) \
3688 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3689 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3690 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3691 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3692 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3693 l2tpv3_interface_enable_disable_reply) \
3694 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3695 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3696 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3697 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3698 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3699 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3700 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3701 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3702 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3703 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3704 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3705 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3706 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3707 _(SHOW_VERSION_REPLY, show_version_reply) \
3708 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3709 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3710 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3711 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3712 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3713 _(IP4_ARP_EVENT, ip4_arp_event) \
3714 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3715 _(IP6_ND_EVENT, ip6_nd_event) \
3716 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3717 _(IP_ADDRESS_DETAILS, ip_address_details) \
3718 _(IP_DETAILS, ip_details) \
3719 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3720 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3721 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3722 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3723 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3724 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3725 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3726 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3727 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3728 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3729 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3730 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3731 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3732 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3733 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3734 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3735 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3736 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3737 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3738 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3739 _(MAP_RULE_DETAILS, map_rule_details) \
3740 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3741 _(WANT_STATS_REPLY, want_stats_reply) \
3742 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3743 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3744 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3745 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3746 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3747 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3748 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3749 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3750 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3751 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3752 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3753 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3754 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3755 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3756 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3757 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3758 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3759 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3760 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3761 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3762 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3763 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3764 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3765 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3766 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3767 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3768 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3769 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
3770 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3771 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3772 lisp_add_del_map_request_itr_rlocs_reply) \
3773 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3774 lisp_get_map_request_itr_rlocs_reply) \
3775 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3776 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3777 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3778 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3779 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3780 _(POLICER_DETAILS, policer_details) \
3781 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3782 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3783 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3784 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3785 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3786 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3787 _(MPLS_FIB_DETAILS, mpls_fib_details) \
3788 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3789 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3790 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3791 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3792 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3793 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3794 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3795 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3796 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3797 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3798 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
3799 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
3800 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3801 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3802 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3803 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3804 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3805 ip_source_and_port_range_check_add_del_reply) \
3806 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3807 ip_source_and_port_range_check_interface_add_del_reply) \
3808 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3809 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3810 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3811 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3812 _(PUNT_REPLY, punt_reply)
3814 /* M: construct, but don't yet send a message */
3818 vam->result_ready = 0; \
3819 mp = vl_msg_api_alloc(sizeof(*mp)); \
3820 memset (mp, 0, sizeof (*mp)); \
3821 mp->_vl_msg_id = ntohs (VL_API_##T); \
3822 mp->client_index = vam->my_client_index; \
3827 vam->result_ready = 0; \
3828 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3829 memset (mp, 0, sizeof (*mp)); \
3830 mp->_vl_msg_id = ntohs (VL_API_##T); \
3831 mp->client_index = vam->my_client_index; \
3835 /* S: send a message */
3836 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3838 /* W: wait for results, with timeout */
3841 timeout = vat_time_now (vam) + 1.0; \
3843 while (vat_time_now (vam) < timeout) { \
3844 if (vam->result_ready == 1) { \
3845 return (vam->retval); \
3851 /* W2: wait for results, with timeout */
3854 timeout = vat_time_now (vam) + 1.0; \
3856 while (vat_time_now (vam) < timeout) { \
3857 if (vam->result_ready == 1) { \
3859 return (vam->retval); \
3872 #define STR_VTR_OP_CASE(op) \
3873 case L2_VTR_ ## op: \
3877 str_vtr_op (u32 vtr_op)
3881 STR_VTR_OP_CASE (DISABLED);
3882 STR_VTR_OP_CASE (PUSH_1);
3883 STR_VTR_OP_CASE (PUSH_2);
3884 STR_VTR_OP_CASE (POP_1);
3885 STR_VTR_OP_CASE (POP_2);
3886 STR_VTR_OP_CASE (TRANSLATE_1_1);
3887 STR_VTR_OP_CASE (TRANSLATE_1_2);
3888 STR_VTR_OP_CASE (TRANSLATE_2_1);
3889 STR_VTR_OP_CASE (TRANSLATE_2_2);
3896 dump_sub_interface_table (vat_main_t * vam)
3898 const sw_interface_subif_t *sub = NULL;
3900 if (vam->json_output)
3903 ("JSON output supported only for VPE API calls and dump_stats_table");
3908 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3909 "Interface", "sw_if_index",
3910 "sub id", "dot1ad", "tags", "outer id",
3911 "inner id", "exact", "default", "outer any", "inner any");
3913 vec_foreach (sub, vam->sw_if_subif_table)
3916 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3917 sub->interface_name,
3919 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3920 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3921 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3922 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3923 if (sub->vtr_op != L2_VTR_DISABLED)
3926 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3927 "tag1: %d tag2: %d ]\n",
3928 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3929 sub->vtr_tag1, sub->vtr_tag2);
3937 name_sort_cmp (void *a1, void *a2)
3939 name_sort_t *n1 = a1;
3940 name_sort_t *n2 = a2;
3942 return strcmp ((char *) n1->name, (char *) n2->name);
3946 dump_interface_table (vat_main_t * vam)
3949 name_sort_t *nses = 0, *ns;
3951 if (vam->json_output)
3954 ("JSON output supported only for VPE API calls and dump_stats_table");
3959 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3961 vec_add2 (nses, ns, 1);
3962 ns->name = (u8 *)(p->key);
3963 ns->value = (u32) p->value[0];
3967 vec_sort_with_function (nses, name_sort_cmp);
3969 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3970 vec_foreach (ns, nses)
3972 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3979 dump_ip_table (vat_main_t * vam, int is_ipv6)
3981 const ip_details_t *det = NULL;
3982 const ip_address_details_t *address = NULL;
3985 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3987 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3994 fformat (vam->ofp, "%-12d\n", i);
3996 " %-30s%-13s\n", "Address", "Prefix length");
4001 vec_foreach (address, det->addr)
4005 is_ipv6 ? format_ip6_address : format_ip4_address,
4006 address->ip, address->prefix_length);
4014 dump_ipv4_table (vat_main_t * vam)
4016 if (vam->json_output)
4019 ("JSON output supported only for VPE API calls and dump_stats_table");
4023 return dump_ip_table (vam, 0);
4027 dump_ipv6_table (vat_main_t * vam)
4029 if (vam->json_output)
4032 ("JSON output supported only for VPE API calls and dump_stats_table");
4036 return dump_ip_table (vam, 1);
4040 counter_type_to_str (u8 counter_type, u8 is_combined)
4044 switch (counter_type)
4046 case VNET_INTERFACE_COUNTER_DROP:
4048 case VNET_INTERFACE_COUNTER_PUNT:
4050 case VNET_INTERFACE_COUNTER_IP4:
4052 case VNET_INTERFACE_COUNTER_IP6:
4054 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4056 case VNET_INTERFACE_COUNTER_RX_MISS:
4058 case VNET_INTERFACE_COUNTER_RX_ERROR:
4060 case VNET_INTERFACE_COUNTER_TX_ERROR:
4063 return "INVALID-COUNTER-TYPE";
4068 switch (counter_type)
4070 case VNET_INTERFACE_COUNTER_RX:
4072 case VNET_INTERFACE_COUNTER_TX:
4075 return "INVALID-COUNTER-TYPE";
4081 dump_stats_table (vat_main_t * vam)
4083 vat_json_node_t node;
4084 vat_json_node_t *msg_array;
4085 vat_json_node_t *msg;
4086 vat_json_node_t *counter_array;
4087 vat_json_node_t *counter;
4088 interface_counter_t c;
4090 ip4_fib_counter_t *c4;
4091 ip6_fib_counter_t *c6;
4094 if (!vam->json_output)
4096 clib_warning ("dump_stats_table supported only in JSON format");
4100 vat_json_init_object (&node);
4102 /* interface counters */
4103 msg_array = vat_json_object_add (&node, "interface_counters");
4104 vat_json_init_array (msg_array);
4105 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4107 msg = vat_json_array_add (msg_array);
4108 vat_json_init_object (msg);
4109 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4110 (u8 *) counter_type_to_str (i, 0));
4111 vat_json_object_add_int (msg, "is_combined", 0);
4112 counter_array = vat_json_object_add (msg, "data");
4113 vat_json_init_array (counter_array);
4114 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4116 packets = vam->simple_interface_counters[i][j];
4117 vat_json_array_add_uint (counter_array, packets);
4120 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4122 msg = vat_json_array_add (msg_array);
4123 vat_json_init_object (msg);
4124 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4125 (u8 *) counter_type_to_str (i, 1));
4126 vat_json_object_add_int (msg, "is_combined", 1);
4127 counter_array = vat_json_object_add (msg, "data");
4128 vat_json_init_array (counter_array);
4129 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4131 c = vam->combined_interface_counters[i][j];
4132 counter = vat_json_array_add (counter_array);
4133 vat_json_init_object (counter);
4134 vat_json_object_add_uint (counter, "packets", c.packets);
4135 vat_json_object_add_uint (counter, "bytes", c.bytes);
4139 /* ip4 fib counters */
4140 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4141 vat_json_init_array (msg_array);
4142 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4144 msg = vat_json_array_add (msg_array);
4145 vat_json_init_object (msg);
4146 vat_json_object_add_uint (msg, "vrf_id",
4147 vam->ip4_fib_counters_vrf_id_by_index[i]);
4148 counter_array = vat_json_object_add (msg, "c");
4149 vat_json_init_array (counter_array);
4150 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4152 counter = vat_json_array_add (counter_array);
4153 vat_json_init_object (counter);
4154 c4 = &vam->ip4_fib_counters[i][j];
4155 vat_json_object_add_ip4 (counter, "address", c4->address);
4156 vat_json_object_add_uint (counter, "address_length",
4157 c4->address_length);
4158 vat_json_object_add_uint (counter, "packets", c4->packets);
4159 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4163 /* ip6 fib counters */
4164 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4165 vat_json_init_array (msg_array);
4166 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4168 msg = vat_json_array_add (msg_array);
4169 vat_json_init_object (msg);
4170 vat_json_object_add_uint (msg, "vrf_id",
4171 vam->ip6_fib_counters_vrf_id_by_index[i]);
4172 counter_array = vat_json_object_add (msg, "c");
4173 vat_json_init_array (counter_array);
4174 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4176 counter = vat_json_array_add (counter_array);
4177 vat_json_init_object (counter);
4178 c6 = &vam->ip6_fib_counters[i][j];
4179 vat_json_object_add_ip6 (counter, "address", c6->address);
4180 vat_json_object_add_uint (counter, "address_length",
4181 c6->address_length);
4182 vat_json_object_add_uint (counter, "packets", c6->packets);
4183 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4187 vat_json_print (vam->ofp, &node);
4188 vat_json_free (&node);
4194 exec (vat_main_t * vam)
4196 api_main_t *am = &api_main;
4197 vl_api_cli_request_t *mp;
4201 unformat_input_t *i = vam->input;
4203 if (vec_len (i->buffer) == 0)
4206 if (vam->exec_mode == 0 && unformat (i, "mode"))
4211 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4218 M (CLI_REQUEST, cli_request);
4221 * Copy cmd into shared memory.
4222 * In order for the CLI command to work, it
4223 * must be a vector ending in \n, not a C-string ending
4226 pthread_mutex_lock (&am->vlib_rp->mutex);
4227 oldheap = svm_push_data_heap (am->vlib_rp);
4229 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4230 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4232 svm_pop_heap (oldheap);
4233 pthread_mutex_unlock (&am->vlib_rp->mutex);
4235 mp->cmd_in_shmem = (u64) cmd;
4237 timeout = vat_time_now (vam) + 10.0;
4239 while (vat_time_now (vam) < timeout)
4241 if (vam->result_ready == 1)
4244 if (vam->shmem_result != NULL)
4245 fformat (vam->ofp, "%s", vam->shmem_result);
4246 pthread_mutex_lock (&am->vlib_rp->mutex);
4247 oldheap = svm_push_data_heap (am->vlib_rp);
4249 free_me = (u8 *) vam->shmem_result;
4252 svm_pop_heap (oldheap);
4253 pthread_mutex_unlock (&am->vlib_rp->mutex);
4261 * Future replacement of exec() that passes CLI buffers directly in
4262 * the API messages instead of an additional shared memory area.
4265 exec_inband (vat_main_t * vam)
4267 vl_api_cli_inband_t *mp;
4269 unformat_input_t *i = vam->input;
4271 if (vec_len (i->buffer) == 0)
4274 if (vam->exec_mode == 0 && unformat (i, "mode"))
4279 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4286 * In order for the CLI command to work, it
4287 * must be a vector ending in \n, not a C-string ending
4290 u32 len = vec_len (vam->input->buffer);
4291 M2 (CLI_INBAND, cli_inband, len);
4292 clib_memcpy (mp->cmd, vam->input->buffer, len);
4293 mp->length = htonl (len);
4296 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4300 api_create_loopback (vat_main_t * vam)
4302 unformat_input_t *i = vam->input;
4303 vl_api_create_loopback_t *mp;
4308 memset (mac_address, 0, sizeof (mac_address));
4310 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4312 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4318 /* Construct the API message */
4319 M (CREATE_LOOPBACK, create_loopback);
4321 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4328 api_delete_loopback (vat_main_t * vam)
4330 unformat_input_t *i = vam->input;
4331 vl_api_delete_loopback_t *mp;
4333 u32 sw_if_index = ~0;
4335 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4337 if (unformat (i, "sw_if_index %d", &sw_if_index))
4343 if (sw_if_index == ~0)
4345 errmsg ("missing sw_if_index\n");
4349 /* Construct the API message */
4350 M (DELETE_LOOPBACK, delete_loopback);
4351 mp->sw_if_index = ntohl (sw_if_index);
4358 api_want_stats (vat_main_t * vam)
4360 unformat_input_t *i = vam->input;
4361 vl_api_want_stats_t *mp;
4365 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4367 if (unformat (i, "enable"))
4369 else if (unformat (i, "disable"))
4377 errmsg ("missing enable|disable\n");
4381 M (WANT_STATS, want_stats);
4382 mp->enable_disable = enable;
4389 api_want_interface_events (vat_main_t * vam)
4391 unformat_input_t *i = vam->input;
4392 vl_api_want_interface_events_t *mp;
4396 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4398 if (unformat (i, "enable"))
4400 else if (unformat (i, "disable"))
4408 errmsg ("missing enable|disable\n");
4412 M (WANT_INTERFACE_EVENTS, want_interface_events);
4413 mp->enable_disable = enable;
4415 vam->interface_event_display = enable;
4422 /* Note: non-static, called once to set up the initial intfc table */
4424 api_sw_interface_dump (vat_main_t * vam)
4426 vl_api_sw_interface_dump_t *mp;
4429 name_sort_t *nses = 0, *ns;
4430 sw_interface_subif_t *sub = NULL;
4432 /* Toss the old name table */
4434 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4436 vec_add2 (nses, ns, 1);
4437 ns->name = (u8 *)(p->key);
4438 ns->value = (u32) p->value[0];
4442 hash_free (vam->sw_if_index_by_interface_name);
4444 vec_foreach (ns, nses) vec_free (ns->name);
4448 vec_foreach (sub, vam->sw_if_subif_table)
4450 vec_free (sub->interface_name);
4452 vec_free (vam->sw_if_subif_table);
4454 /* recreate the interface name hash table */
4455 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4457 /* Get list of ethernets */
4458 M (SW_INTERFACE_DUMP, sw_interface_dump);
4459 mp->name_filter_valid = 1;
4460 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4463 /* and local / loopback interfaces */
4464 M (SW_INTERFACE_DUMP, sw_interface_dump);
4465 mp->name_filter_valid = 1;
4466 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4469 /* and packet-generator interfaces */
4470 M (SW_INTERFACE_DUMP, sw_interface_dump);
4471 mp->name_filter_valid = 1;
4472 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4475 /* and vxlan-gpe tunnel interfaces */
4476 M (SW_INTERFACE_DUMP, sw_interface_dump);
4477 mp->name_filter_valid = 1;
4478 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4479 sizeof (mp->name_filter) - 1);
4482 /* and vxlan tunnel interfaces */
4483 M (SW_INTERFACE_DUMP, sw_interface_dump);
4484 mp->name_filter_valid = 1;
4485 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4488 /* and host (af_packet) interfaces */
4489 M (SW_INTERFACE_DUMP, sw_interface_dump);
4490 mp->name_filter_valid = 1;
4491 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4494 /* and l2tpv3 tunnel interfaces */
4495 M (SW_INTERFACE_DUMP, sw_interface_dump);
4496 mp->name_filter_valid = 1;
4497 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4498 sizeof (mp->name_filter) - 1);
4501 /* and GRE tunnel interfaces */
4502 M (SW_INTERFACE_DUMP, sw_interface_dump);
4503 mp->name_filter_valid = 1;
4504 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4507 /* and LISP-GPE interfaces */
4508 M (SW_INTERFACE_DUMP, sw_interface_dump);
4509 mp->name_filter_valid = 1;
4510 strncpy ((char *) mp->name_filter, "lisp_gpe",
4511 sizeof (mp->name_filter) - 1);
4514 /* and IPSEC tunnel interfaces */
4515 M (SW_INTERFACE_DUMP, sw_interface_dump);
4516 mp->name_filter_valid = 1;
4517 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4520 /* Use a control ping for synchronization */
4522 vl_api_control_ping_t *mp;
4523 M (CONTROL_PING, control_ping);
4530 api_sw_interface_set_flags (vat_main_t * vam)
4532 unformat_input_t *i = vam->input;
4533 vl_api_sw_interface_set_flags_t *mp;
4536 u8 sw_if_index_set = 0;
4537 u8 admin_up = 0, link_up = 0;
4539 /* Parse args required to build the message */
4540 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4542 if (unformat (i, "admin-up"))
4544 else if (unformat (i, "admin-down"))
4546 else if (unformat (i, "link-up"))
4548 else if (unformat (i, "link-down"))
4550 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4551 sw_if_index_set = 1;
4552 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4553 sw_if_index_set = 1;
4558 if (sw_if_index_set == 0)
4560 errmsg ("missing interface name or sw_if_index\n");
4564 /* Construct the API message */
4565 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4566 mp->sw_if_index = ntohl (sw_if_index);
4567 mp->admin_up_down = admin_up;
4568 mp->link_up_down = link_up;
4573 /* Wait for a reply, return the good/bad news... */
4578 api_sw_interface_clear_stats (vat_main_t * vam)
4580 unformat_input_t *i = vam->input;
4581 vl_api_sw_interface_clear_stats_t *mp;
4584 u8 sw_if_index_set = 0;
4586 /* Parse args required to build the message */
4587 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4589 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4590 sw_if_index_set = 1;
4591 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4592 sw_if_index_set = 1;
4597 /* Construct the API message */
4598 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4600 if (sw_if_index_set == 1)
4601 mp->sw_if_index = ntohl (sw_if_index);
4603 mp->sw_if_index = ~0;
4608 /* Wait for a reply, return the good/bad news... */
4613 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4615 unformat_input_t *i = vam->input;
4616 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4619 u8 sw_if_index_set = 0;
4627 /* Parse args required to build the message */
4628 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4630 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4631 sw_if_index_set = 1;
4632 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4633 sw_if_index_set = 1;
4634 else if (unformat (i, "subport %u", &subport))
4636 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4637 sw_if_index_set = 1;
4638 else if (unformat (i, "pipe %u", &pipe))
4640 else if (unformat (i, "profile %u", &profile))
4646 if (sw_if_index_set == 0)
4648 errmsg ("missing interface name or sw_if_index\n");
4652 if (subport_set == 0)
4654 errmsg ("missing subport \n");
4660 errmsg ("missing pipe\n");
4664 if (profile_set == 0)
4666 errmsg ("missing profile\n");
4670 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
4672 mp->sw_if_index = ntohl (sw_if_index);
4673 mp->subport = ntohl (subport);
4674 mp->pipe = ntohl (pipe);
4675 mp->profile = ntohl (profile);
4685 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
4687 unformat_input_t *i = vam->input;
4688 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
4691 u8 sw_if_index_set = 0;
4694 u32 tb_rate = 1250000000; /* 10GbE */
4695 u32 tb_size = 1000000;
4696 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
4699 /* Parse args required to build the message */
4700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4702 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4703 sw_if_index_set = 1;
4704 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4705 sw_if_index_set = 1;
4706 else if (unformat (i, "subport %u", &subport))
4708 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4709 sw_if_index_set = 1;
4710 else if (unformat (i, "rate %u", &tb_rate))
4714 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
4716 tc_rate[tc_id] = tb_rate;
4718 else if (unformat (i, "bktsize %u", &tb_size))
4720 else if (unformat (i, "tc0 %u", &tc_rate[0]))
4722 else if (unformat (i, "tc1 %u", &tc_rate[1]))
4724 else if (unformat (i, "tc2 %u", &tc_rate[2]))
4726 else if (unformat (i, "tc3 %u", &tc_rate[3]))
4728 else if (unformat (i, "period %u", &tc_period))
4734 if (sw_if_index_set == 0)
4736 errmsg ("missing interface name or sw_if_index\n");
4740 if (subport_set == 0)
4742 errmsg ("missing subport \n");
4746 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
4748 mp->sw_if_index = ntohl (sw_if_index);
4749 mp->subport = ntohl (subport);
4750 mp->tb_rate = ntohl (tb_rate);
4751 mp->tb_size = ntohl (tb_size);
4752 mp->tc_rate[0] = ntohl (tc_rate[0]);
4753 mp->tc_rate[1] = ntohl (tc_rate[1]);
4754 mp->tc_rate[2] = ntohl (tc_rate[2]);
4755 mp->tc_rate[3] = ntohl (tc_rate[3]);
4756 mp->tc_period = ntohl (tc_period);
4765 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
4767 unformat_input_t *i = vam->input;
4768 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
4771 u8 sw_if_index_set = 0;
4775 u32 entry, tc, queue;
4777 /* Parse args required to build the message */
4778 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4780 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4781 sw_if_index_set = 1;
4782 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4783 sw_if_index_set = 1;
4784 else if (unformat (i, "entry %d", &entry))
4786 else if (unformat (i, "tc %d", &tc))
4788 else if (unformat (i, "queue %d", &queue))
4794 if (sw_if_index_set == 0)
4796 errmsg ("missing interface name or sw_if_index\n");
4802 errmsg ("missing entry \n");
4808 errmsg ("missing traffic class \n");
4814 errmsg ("missing queue \n");
4818 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
4820 mp->sw_if_index = ntohl (sw_if_index);
4821 mp->entry = ntohl (entry);
4822 mp->tc = ntohl (tc);
4823 mp->queue = ntohl (queue);
4832 api_sw_interface_add_del_address (vat_main_t * vam)
4834 unformat_input_t *i = vam->input;
4835 vl_api_sw_interface_add_del_address_t *mp;
4838 u8 sw_if_index_set = 0;
4839 u8 is_add = 1, del_all = 0;
4840 u32 address_length = 0;
4841 u8 v4_address_set = 0;
4842 u8 v6_address_set = 0;
4843 ip4_address_t v4address;
4844 ip6_address_t v6address;
4846 /* Parse args required to build the message */
4847 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4849 if (unformat (i, "del-all"))
4851 else if (unformat (i, "del"))
4853 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4854 sw_if_index_set = 1;
4855 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4856 sw_if_index_set = 1;
4857 else if (unformat (i, "%U/%d",
4858 unformat_ip4_address, &v4address, &address_length))
4860 else if (unformat (i, "%U/%d",
4861 unformat_ip6_address, &v6address, &address_length))
4867 if (sw_if_index_set == 0)
4869 errmsg ("missing interface name or sw_if_index\n");
4872 if (v4_address_set && v6_address_set)
4874 errmsg ("both v4 and v6 addresses set\n");
4877 if (!v4_address_set && !v6_address_set && !del_all)
4879 errmsg ("no addresses set\n");
4883 /* Construct the API message */
4884 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4886 mp->sw_if_index = ntohl (sw_if_index);
4887 mp->is_add = is_add;
4888 mp->del_all = del_all;
4892 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4896 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4898 mp->address_length = address_length;
4903 /* Wait for a reply, return good/bad news */
4908 api_sw_interface_set_table (vat_main_t * vam)
4910 unformat_input_t *i = vam->input;
4911 vl_api_sw_interface_set_table_t *mp;
4913 u32 sw_if_index, vrf_id = 0;
4914 u8 sw_if_index_set = 0;
4917 /* Parse args required to build the message */
4918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4920 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4921 sw_if_index_set = 1;
4922 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4923 sw_if_index_set = 1;
4924 else if (unformat (i, "vrf %d", &vrf_id))
4926 else if (unformat (i, "ipv6"))
4932 if (sw_if_index_set == 0)
4934 errmsg ("missing interface name or sw_if_index\n");
4938 /* Construct the API message */
4939 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4941 mp->sw_if_index = ntohl (sw_if_index);
4942 mp->is_ipv6 = is_ipv6;
4943 mp->vrf_id = ntohl (vrf_id);
4948 /* Wait for a reply... */
4953 api_sw_interface_set_vpath (vat_main_t * vam)
4955 unformat_input_t *i = vam->input;
4956 vl_api_sw_interface_set_vpath_t *mp;
4958 u32 sw_if_index = 0;
4959 u8 sw_if_index_set = 0;
4962 /* Parse args required to build the message */
4963 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4965 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4966 sw_if_index_set = 1;
4967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4968 sw_if_index_set = 1;
4969 else if (unformat (i, "enable"))
4971 else if (unformat (i, "disable"))
4977 if (sw_if_index_set == 0)
4979 errmsg ("missing interface name or sw_if_index\n");
4983 /* Construct the API message */
4984 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
4986 mp->sw_if_index = ntohl (sw_if_index);
4987 mp->enable = is_enable;
4992 /* Wait for a reply... */
4997 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
4999 unformat_input_t *i = vam->input;
5000 vl_api_sw_interface_set_l2_xconnect_t *mp;
5003 u8 rx_sw_if_index_set = 0;
5005 u8 tx_sw_if_index_set = 0;
5008 /* Parse args required to build the message */
5009 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5011 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5012 rx_sw_if_index_set = 1;
5013 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5014 tx_sw_if_index_set = 1;
5015 else if (unformat (i, "rx"))
5017 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5019 if (unformat (i, "%U", unformat_sw_if_index, vam,
5021 rx_sw_if_index_set = 1;
5026 else if (unformat (i, "tx"))
5028 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5030 if (unformat (i, "%U", unformat_sw_if_index, vam,
5032 tx_sw_if_index_set = 1;
5037 else if (unformat (i, "enable"))
5039 else if (unformat (i, "disable"))
5045 if (rx_sw_if_index_set == 0)
5047 errmsg ("missing rx interface name or rx_sw_if_index\n");
5051 if (enable && (tx_sw_if_index_set == 0))
5053 errmsg ("missing tx interface name or tx_sw_if_index\n");
5057 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
5059 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5060 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5061 mp->enable = enable;
5070 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5072 unformat_input_t *i = vam->input;
5073 vl_api_sw_interface_set_l2_bridge_t *mp;
5076 u8 rx_sw_if_index_set = 0;
5083 /* Parse args required to build the message */
5084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5086 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5087 rx_sw_if_index_set = 1;
5088 else if (unformat (i, "bd_id %d", &bd_id))
5090 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
5091 rx_sw_if_index_set = 1;
5092 else if (unformat (i, "shg %d", &shg))
5094 else if (unformat (i, "bvi"))
5096 else if (unformat (i, "enable"))
5098 else if (unformat (i, "disable"))
5104 if (rx_sw_if_index_set == 0)
5106 errmsg ("missing rx interface name or sw_if_index\n");
5110 if (enable && (bd_id_set == 0))
5112 errmsg ("missing bridge domain\n");
5116 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5118 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5119 mp->bd_id = ntohl (bd_id);
5122 mp->enable = enable;
5131 api_bridge_domain_dump (vat_main_t * vam)
5133 unformat_input_t *i = vam->input;
5134 vl_api_bridge_domain_dump_t *mp;
5138 /* Parse args required to build the message */
5139 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5141 if (unformat (i, "bd_id %d", &bd_id))
5147 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5148 mp->bd_id = ntohl (bd_id);
5151 /* Use a control ping for synchronization */
5153 vl_api_control_ping_t *mp;
5154 M (CONTROL_PING, control_ping);
5164 api_bridge_domain_add_del (vat_main_t * vam)
5166 unformat_input_t *i = vam->input;
5167 vl_api_bridge_domain_add_del_t *mp;
5171 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5173 /* Parse args required to build the message */
5174 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5176 if (unformat (i, "bd_id %d", &bd_id))
5178 else if (unformat (i, "flood %d", &flood))
5180 else if (unformat (i, "uu-flood %d", &uu_flood))
5182 else if (unformat (i, "forward %d", &forward))
5184 else if (unformat (i, "learn %d", &learn))
5186 else if (unformat (i, "arp-term %d", &arp_term))
5188 else if (unformat (i, "del"))
5191 flood = uu_flood = forward = learn = 0;
5199 errmsg ("missing bridge domain\n");
5203 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5205 mp->bd_id = ntohl (bd_id);
5207 mp->uu_flood = uu_flood;
5208 mp->forward = forward;
5210 mp->arp_term = arp_term;
5211 mp->is_add = is_add;
5220 api_l2fib_add_del (vat_main_t * vam)
5222 unformat_input_t *i = vam->input;
5223 vl_api_l2fib_add_del_t *mp;
5230 u8 sw_if_index_set = 0;
5239 /* Parse args required to build the message */
5240 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5242 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5244 else if (unformat (i, "bd_id %d", &bd_id))
5246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5247 sw_if_index_set = 1;
5248 else if (unformat (i, "sw_if"))
5250 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5252 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5253 sw_if_index_set = 1;
5258 else if (unformat (i, "static"))
5260 else if (unformat (i, "filter"))
5265 else if (unformat (i, "bvi"))
5270 else if (unformat (i, "del"))
5272 else if (unformat (i, "count %d", &count))
5280 errmsg ("missing mac address\n");
5286 errmsg ("missing bridge domain\n");
5290 if (is_add && (sw_if_index_set == 0))
5292 errmsg ("missing interface name or sw_if_index\n");
5298 /* Turn on async mode */
5299 vam->async_mode = 1;
5300 vam->async_errors = 0;
5301 before = vat_time_now (vam);
5304 for (j = 0; j < count; j++)
5306 M (L2FIB_ADD_DEL, l2fib_add_del);
5309 mp->bd_id = ntohl (bd_id);
5310 mp->is_add = is_add;
5314 mp->sw_if_index = ntohl (sw_if_index);
5315 mp->static_mac = static_mac;
5316 mp->filter_mac = filter_mac;
5317 mp->bvi_mac = bvi_mac;
5319 increment_mac_address (&mac);
5326 vl_api_control_ping_t *mp;
5329 /* Shut off async mode */
5330 vam->async_mode = 0;
5332 M (CONTROL_PING, control_ping);
5335 timeout = vat_time_now (vam) + 1.0;
5336 while (vat_time_now (vam) < timeout)
5337 if (vam->result_ready == 1)
5342 if (vam->retval == -99)
5343 errmsg ("timeout\n");
5345 if (vam->async_errors > 0)
5347 errmsg ("%d asynchronous errors\n", vam->async_errors);
5350 vam->async_errors = 0;
5351 after = vat_time_now (vam);
5353 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5354 count, after - before, count / (after - before));
5358 /* Wait for a reply... */
5361 /* Return the good/bad news */
5362 return (vam->retval);
5366 api_l2_flags (vat_main_t * vam)
5368 unformat_input_t *i = vam->input;
5369 vl_api_l2_flags_t *mp;
5372 u32 feature_bitmap = 0;
5373 u8 sw_if_index_set = 0;
5375 /* Parse args required to build the message */
5376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5378 if (unformat (i, "sw_if_index %d", &sw_if_index))
5379 sw_if_index_set = 1;
5380 else if (unformat (i, "sw_if"))
5382 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5384 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5385 sw_if_index_set = 1;
5390 else if (unformat (i, "learn"))
5391 feature_bitmap |= L2INPUT_FEAT_LEARN;
5392 else if (unformat (i, "forward"))
5393 feature_bitmap |= L2INPUT_FEAT_FWD;
5394 else if (unformat (i, "flood"))
5395 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5396 else if (unformat (i, "uu-flood"))
5397 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5402 if (sw_if_index_set == 0)
5404 errmsg ("missing interface name or sw_if_index\n");
5408 M (L2_FLAGS, l2_flags);
5410 mp->sw_if_index = ntohl (sw_if_index);
5411 mp->feature_bitmap = ntohl (feature_bitmap);
5420 api_bridge_flags (vat_main_t * vam)
5422 unformat_input_t *i = vam->input;
5423 vl_api_bridge_flags_t *mp;
5430 /* Parse args required to build the message */
5431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5433 if (unformat (i, "bd_id %d", &bd_id))
5435 else if (unformat (i, "learn"))
5437 else if (unformat (i, "forward"))
5439 else if (unformat (i, "flood"))
5441 else if (unformat (i, "uu-flood"))
5442 flags |= L2_UU_FLOOD;
5443 else if (unformat (i, "arp-term"))
5444 flags |= L2_ARP_TERM;
5445 else if (unformat (i, "off"))
5447 else if (unformat (i, "disable"))
5455 errmsg ("missing bridge domain\n");
5459 M (BRIDGE_FLAGS, bridge_flags);
5461 mp->bd_id = ntohl (bd_id);
5462 mp->feature_bitmap = ntohl (flags);
5463 mp->is_set = is_set;
5472 api_bd_ip_mac_add_del (vat_main_t * vam)
5474 unformat_input_t *i = vam->input;
5475 vl_api_bd_ip_mac_add_del_t *mp;
5483 ip4_address_t v4addr;
5484 ip6_address_t v6addr;
5488 /* Parse args required to build the message */
5489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5491 if (unformat (i, "bd_id %d", &bd_id))
5495 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5499 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5504 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5508 else if (unformat (i, "del"))
5516 errmsg ("missing bridge domain\n");
5519 else if (ip_set == 0)
5521 errmsg ("missing IP address\n");
5524 else if (mac_set == 0)
5526 errmsg ("missing MAC address\n");
5530 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5532 mp->bd_id = ntohl (bd_id);
5533 mp->is_ipv6 = is_ipv6;
5534 mp->is_add = is_add;
5536 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5538 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5539 clib_memcpy (mp->mac_address, macaddr, 6);
5547 api_tap_connect (vat_main_t * vam)
5549 unformat_input_t *i = vam->input;
5550 vl_api_tap_connect_t *mp;
5557 memset (mac_address, 0, sizeof (mac_address));
5559 /* Parse args required to build the message */
5560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5562 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5566 else if (unformat (i, "random-mac"))
5568 else if (unformat (i, "tapname %s", &tap_name))
5576 errmsg ("missing tap name\n");
5579 if (vec_len (tap_name) > 63)
5581 errmsg ("tap name too long\n");
5583 vec_add1 (tap_name, 0);
5585 /* Construct the API message */
5586 M (TAP_CONNECT, tap_connect);
5588 mp->use_random_mac = random_mac;
5589 clib_memcpy (mp->mac_address, mac_address, 6);
5590 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5591 vec_free (tap_name);
5596 /* Wait for a reply... */
5601 api_tap_modify (vat_main_t * vam)
5603 unformat_input_t *i = vam->input;
5604 vl_api_tap_modify_t *mp;
5610 u32 sw_if_index = ~0;
5611 u8 sw_if_index_set = 0;
5613 memset (mac_address, 0, sizeof (mac_address));
5615 /* Parse args required to build the message */
5616 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5618 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5619 sw_if_index_set = 1;
5620 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5621 sw_if_index_set = 1;
5622 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5626 else if (unformat (i, "random-mac"))
5628 else if (unformat (i, "tapname %s", &tap_name))
5634 if (sw_if_index_set == 0)
5636 errmsg ("missing vpp interface name");
5641 errmsg ("missing tap name\n");
5644 if (vec_len (tap_name) > 63)
5646 errmsg ("tap name too long\n");
5648 vec_add1 (tap_name, 0);
5650 /* Construct the API message */
5651 M (TAP_MODIFY, tap_modify);
5653 mp->use_random_mac = random_mac;
5654 mp->sw_if_index = ntohl (sw_if_index);
5655 clib_memcpy (mp->mac_address, mac_address, 6);
5656 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5657 vec_free (tap_name);
5662 /* Wait for a reply... */
5667 api_tap_delete (vat_main_t * vam)
5669 unformat_input_t *i = vam->input;
5670 vl_api_tap_delete_t *mp;
5672 u32 sw_if_index = ~0;
5673 u8 sw_if_index_set = 0;
5675 /* Parse args required to build the message */
5676 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5678 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5679 sw_if_index_set = 1;
5680 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5681 sw_if_index_set = 1;
5686 if (sw_if_index_set == 0)
5688 errmsg ("missing vpp interface name");
5692 /* Construct the API message */
5693 M (TAP_DELETE, tap_delete);
5695 mp->sw_if_index = ntohl (sw_if_index);
5700 /* Wait for a reply... */
5705 api_ip_add_del_route (vat_main_t * vam)
5707 unformat_input_t *i = vam->input;
5708 vl_api_ip_add_del_route_t *mp;
5710 u32 sw_if_index = ~0, vrf_id = 0;
5711 u8 sw_if_index_set = 0;
5713 u8 is_local = 0, is_drop = 0;
5714 u8 create_vrf_if_needed = 0;
5716 u8 next_hop_weight = 1;
5718 u8 is_multipath = 0;
5720 u8 address_length_set = 0;
5721 u32 next_hop_table_id = 0;
5722 u32 resolve_attempts = 0;
5723 u32 dst_address_length = 0;
5724 u8 next_hop_set = 0;
5725 ip4_address_t v4_dst_address, v4_next_hop_address;
5726 ip6_address_t v6_dst_address, v6_next_hop_address;
5730 u32 random_add_del = 0;
5731 u32 *random_vector = 0;
5733 u32 random_seed = 0xdeaddabe;
5734 u32 classify_table_index = ~0;
5736 u8 resolve_host = 0, resolve_attached = 0;
5737 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
5739 /* Parse args required to build the message */
5740 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5742 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5743 sw_if_index_set = 1;
5744 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5745 sw_if_index_set = 1;
5746 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5751 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5756 else if (unformat (i, "/%d", &dst_address_length))
5758 address_length_set = 1;
5761 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5762 &v4_next_hop_address))
5766 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5767 &v6_next_hop_address))
5771 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5773 else if (unformat (i, "weight %d", &next_hop_weight))
5775 else if (unformat (i, "drop"))
5779 else if (unformat (i, "local"))
5783 else if (unformat (i, "classify %d", &classify_table_index))
5787 else if (unformat (i, "del"))
5789 else if (unformat (i, "add"))
5791 else if (unformat (i, "not-last"))
5793 else if (unformat (i, "resolve-via-host"))
5795 else if (unformat (i, "resolve-via-attached"))
5796 resolve_attached = 1;
5797 else if (unformat (i, "multipath"))
5799 else if (unformat (i, "vrf %d", &vrf_id))
5801 else if (unformat (i, "create-vrf"))
5802 create_vrf_if_needed = 1;
5803 else if (unformat (i, "count %d", &count))
5805 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
5807 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
5809 else if (unformat (i, "out-label %d", &next_hop_out_label))
5811 else if (unformat (i, "random"))
5813 else if (unformat (i, "seed %d", &random_seed))
5817 clib_warning ("parse error '%U'", format_unformat_error, i);
5822 if (resolve_attempts > 0 && sw_if_index_set == 0)
5824 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5828 if (!next_hop_set && !is_drop && !is_local && !is_classify)
5830 errmsg ("next hop / local / drop / classify not set\n");
5834 if (address_set == 0)
5836 errmsg ("missing addresses\n");
5840 if (address_length_set == 0)
5842 errmsg ("missing address length\n");
5846 /* Generate a pile of unique, random routes */
5849 u32 this_random_address;
5850 random_hash = hash_create (count, sizeof (uword));
5852 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5853 for (j = 0; j <= count; j++)
5857 this_random_address = random_u32 (&random_seed);
5858 this_random_address =
5859 clib_host_to_net_u32 (this_random_address);
5861 while (hash_get (random_hash, this_random_address));
5862 vec_add1 (random_vector, this_random_address);
5863 hash_set (random_hash, this_random_address, 1);
5865 hash_free (random_hash);
5866 v4_dst_address.as_u32 = random_vector[0];
5871 /* Turn on async mode */
5872 vam->async_mode = 1;
5873 vam->async_errors = 0;
5874 before = vat_time_now (vam);
5877 for (j = 0; j < count; j++)
5879 /* Construct the API message */
5880 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5882 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5883 mp->table_id = ntohl (vrf_id);
5884 if (resolve_attempts > 0)
5886 mp->resolve_attempts = ntohl (resolve_attempts);
5887 mp->resolve_if_needed = 1;
5889 mp->create_vrf_if_needed = create_vrf_if_needed;
5891 mp->is_add = is_add;
5892 mp->is_drop = is_drop;
5893 mp->is_ipv6 = is_ipv6;
5894 mp->is_local = is_local;
5895 mp->is_classify = is_classify;
5896 mp->is_multipath = is_multipath;
5897 mp->is_resolve_host = resolve_host;
5898 mp->is_resolve_attached = resolve_attached;
5899 mp->not_last = not_last;
5900 mp->next_hop_weight = next_hop_weight;
5901 mp->dst_address_length = dst_address_length;
5902 mp->next_hop_table_id = ntohl (next_hop_table_id);
5903 mp->classify_table_index = ntohl (classify_table_index);
5904 mp->next_hop_out_label = ntohl (next_hop_out_label);
5908 clib_memcpy (mp->dst_address, &v6_dst_address,
5909 sizeof (v6_dst_address));
5911 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5912 sizeof (v6_next_hop_address));
5913 increment_v6_address (&v6_dst_address);
5917 clib_memcpy (mp->dst_address, &v4_dst_address,
5918 sizeof (v4_dst_address));
5920 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5921 sizeof (v4_next_hop_address));
5923 v4_dst_address.as_u32 = random_vector[j + 1];
5925 increment_v4_address (&v4_dst_address);
5929 /* If we receive SIGTERM, stop now... */
5934 /* When testing multiple add/del ops, use a control-ping to sync */
5937 vl_api_control_ping_t *mp;
5940 /* Shut off async mode */
5941 vam->async_mode = 0;
5943 M (CONTROL_PING, control_ping);
5946 timeout = vat_time_now (vam) + 1.0;
5947 while (vat_time_now (vam) < timeout)
5948 if (vam->result_ready == 1)
5953 if (vam->retval == -99)
5954 errmsg ("timeout\n");
5956 if (vam->async_errors > 0)
5958 errmsg ("%d asynchronous errors\n", vam->async_errors);
5961 vam->async_errors = 0;
5962 after = vat_time_now (vam);
5964 /* slim chance, but we might have eaten SIGTERM on the first iteration */
5968 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5969 count, after - before, count / (after - before));
5973 /* Wait for a reply... */
5977 /* Return the good/bad news */
5978 return (vam->retval);
5982 api_mpls_route_add_del (vat_main_t * vam)
5984 unformat_input_t *i = vam->input;
5985 vl_api_mpls_route_add_del_t *mp;
5987 u32 sw_if_index = ~0, table_id = 0;
5988 u8 create_table_if_needed = 0;
5990 u8 next_hop_weight = 1;
5991 u8 is_multipath = 0;
5992 u32 next_hop_table_id = 0;
5993 u8 next_hop_set = 0;
5994 ip4_address_t v4_next_hop_address = {
5997 ip6_address_t v6_next_hop_address = { {0} };
6001 u32 classify_table_index = ~0;
6003 u8 resolve_host = 0, resolve_attached = 0;
6004 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6005 mpls_label_t local_label = MPLS_LABEL_INVALID;
6007 u8 next_hop_proto_is_ip4 = 1;
6009 /* Parse args required to build the message */
6010 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6012 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6014 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6016 else if (unformat (i, "%d", &local_label))
6018 else if (unformat (i, "eos"))
6020 else if (unformat (i, "non-eos"))
6022 else if (unformat (i, "via %U", unformat_ip4_address,
6023 &v4_next_hop_address))
6026 next_hop_proto_is_ip4 = 1;
6028 else if (unformat (i, "via %U", unformat_ip6_address,
6029 &v6_next_hop_address))
6032 next_hop_proto_is_ip4 = 0;
6034 else if (unformat (i, "weight %d", &next_hop_weight))
6036 else if (unformat (i, "create-table"))
6037 create_table_if_needed = 1;
6038 else if (unformat (i, "classify %d", &classify_table_index))
6042 else if (unformat (i, "del"))
6044 else if (unformat (i, "add"))
6046 else if (unformat (i, "resolve-via-host"))
6048 else if (unformat (i, "resolve-via-attached"))
6049 resolve_attached = 1;
6050 else if (unformat (i, "multipath"))
6052 else if (unformat (i, "count %d", &count))
6054 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6057 next_hop_proto_is_ip4 = 1;
6059 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6062 next_hop_proto_is_ip4 = 0;
6064 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6066 else if (unformat (i, "out-label %d", &next_hop_out_label))
6070 clib_warning ("parse error '%U'", format_unformat_error, i);
6075 if (!next_hop_set && !is_classify)
6077 errmsg ("next hop / classify not set\n");
6081 if (MPLS_LABEL_INVALID == local_label)
6083 errmsg ("missing label\n");
6089 /* Turn on async mode */
6090 vam->async_mode = 1;
6091 vam->async_errors = 0;
6092 before = vat_time_now (vam);
6095 for (j = 0; j < count; j++)
6097 /* Construct the API message */
6098 M (MPLS_ROUTE_ADD_DEL, mpls_route_add_del);
6100 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6101 mp->mr_table_id = ntohl (table_id);
6102 mp->mr_create_table_if_needed = create_table_if_needed;
6104 mp->mr_is_add = is_add;
6105 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6106 mp->mr_is_classify = is_classify;
6107 mp->mr_is_multipath = is_multipath;
6108 mp->mr_is_resolve_host = resolve_host;
6109 mp->mr_is_resolve_attached = resolve_attached;
6110 mp->mr_next_hop_weight = next_hop_weight;
6111 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6112 mp->mr_classify_table_index = ntohl (classify_table_index);
6113 mp->mr_next_hop_out_label = ntohl (next_hop_out_label);
6114 mp->mr_label = ntohl (local_label);
6115 mp->mr_eos = is_eos;
6119 if (next_hop_proto_is_ip4)
6121 clib_memcpy (mp->mr_next_hop,
6122 &v4_next_hop_address,
6123 sizeof (v4_next_hop_address));
6127 clib_memcpy (mp->mr_next_hop,
6128 &v6_next_hop_address,
6129 sizeof (v6_next_hop_address));
6136 /* If we receive SIGTERM, stop now... */
6141 /* When testing multiple add/del ops, use a control-ping to sync */
6144 vl_api_control_ping_t *mp;
6147 /* Shut off async mode */
6148 vam->async_mode = 0;
6150 M (CONTROL_PING, control_ping);
6153 timeout = vat_time_now (vam) + 1.0;
6154 while (vat_time_now (vam) < timeout)
6155 if (vam->result_ready == 1)
6160 if (vam->retval == -99)
6161 errmsg ("timeout\n");
6163 if (vam->async_errors > 0)
6165 errmsg ("%d asynchronous errors\n", vam->async_errors);
6168 vam->async_errors = 0;
6169 after = vat_time_now (vam);
6171 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6175 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6176 count, after - before, count / (after - before));
6180 /* Wait for a reply... */
6184 /* Return the good/bad news */
6185 return (vam->retval);
6189 api_mpls_ip_bind_unbind (vat_main_t * vam)
6191 unformat_input_t *i = vam->input;
6192 vl_api_mpls_ip_bind_unbind_t *mp;
6194 u32 ip_table_id = 0;
6195 u8 create_table_if_needed = 0;
6198 ip4_address_t v4_address;
6199 ip6_address_t v6_address;
6202 mpls_label_t local_label = MPLS_LABEL_INVALID;
6204 /* Parse args required to build the message */
6205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6207 if (unformat (i, "%U/%d", unformat_ip4_address,
6208 &v4_address, &address_length))
6213 else if (unformat (i, "%U/%d", unformat_ip6_address,
6214 &v6_address, &address_length))
6219 else if (unformat (i, "%d", &local_label))
6221 else if (unformat (i, "create-table"))
6222 create_table_if_needed = 1;
6223 else if (unformat (i, "table-id %d", &ip_table_id))
6225 else if (unformat (i, "unbind"))
6227 else if (unformat (i, "bind"))
6231 clib_warning ("parse error '%U'", format_unformat_error, i);
6238 errmsg ("IP addres not set\n");
6242 if (MPLS_LABEL_INVALID == local_label)
6244 errmsg ("missing label\n");
6248 /* Construct the API message */
6249 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6251 mp->mb_create_table_if_needed = create_table_if_needed;
6252 mp->mb_is_bind = is_bind;
6253 mp->mb_is_ip4 = is_ip4;
6254 mp->mb_ip_table_id = ntohl (ip_table_id);
6255 mp->mb_mpls_table_id = 0;
6256 mp->mb_label = ntohl (local_label);
6257 mp->mb_address_length = address_length;
6260 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6262 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6267 /* Wait for a reply... */
6270 /* Return the good/bad news */
6271 return (vam->retval);
6275 api_proxy_arp_add_del (vat_main_t * vam)
6277 unformat_input_t *i = vam->input;
6278 vl_api_proxy_arp_add_del_t *mp;
6282 ip4_address_t lo, hi;
6285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6287 if (unformat (i, "vrf %d", &vrf_id))
6289 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6290 unformat_ip4_address, &hi))
6292 else if (unformat (i, "del"))
6296 clib_warning ("parse error '%U'", format_unformat_error, i);
6303 errmsg ("address range not set\n");
6307 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
6309 mp->vrf_id = ntohl (vrf_id);
6310 mp->is_add = is_add;
6311 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6312 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6321 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6323 unformat_input_t *i = vam->input;
6324 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6328 u8 sw_if_index_set = 0;
6330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6332 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6333 sw_if_index_set = 1;
6334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6335 sw_if_index_set = 1;
6336 else if (unformat (i, "enable"))
6338 else if (unformat (i, "disable"))
6342 clib_warning ("parse error '%U'", format_unformat_error, i);
6347 if (sw_if_index_set == 0)
6349 errmsg ("missing interface name or sw_if_index\n");
6353 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
6355 mp->sw_if_index = ntohl (sw_if_index);
6356 mp->enable_disable = enable;
6365 api_mpls_add_del_encap (vat_main_t * vam)
6367 unformat_input_t *i = vam->input;
6368 vl_api_mpls_add_del_encap_t *mp;
6373 ip4_address_t dst_address;
6376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6378 if (unformat (i, "vrf %d", &vrf_id))
6380 else if (unformat (i, "label %d", &label))
6381 vec_add1 (labels, ntohl (label));
6382 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
6384 else if (unformat (i, "del"))
6388 clib_warning ("parse error '%U'", format_unformat_error, i);
6393 if (vec_len (labels) == 0)
6395 errmsg ("missing encap label stack\n");
6399 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
6400 sizeof (u32) * vec_len (labels));
6402 mp->vrf_id = ntohl (vrf_id);
6403 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
6404 mp->is_add = is_add;
6405 mp->nlabels = vec_len (labels);
6406 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
6417 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
6419 unformat_input_t *i = vam->input;
6420 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
6422 u32 inner_vrf_id = 0;
6423 ip4_address_t intfc_address;
6424 u8 dst_mac_address[6];
6427 u8 intfc_address_length = 0;
6431 int tx_sw_if_index_set = 0;
6433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6435 if (unformat (i, "vrf %d", &inner_vrf_id))
6437 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6438 &intfc_address, &tmp))
6439 intfc_address_length = tmp;
6440 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
6441 tx_sw_if_index_set = 1;
6442 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6443 tx_sw_if_index_set = 1;
6444 else if (unformat (i, "dst %U", unformat_ethernet_address,
6447 else if (unformat (i, "l2-only"))
6449 else if (unformat (i, "del"))
6453 clib_warning ("parse error '%U'", format_unformat_error, i);
6460 errmsg ("dst (mac address) not set\n");
6463 if (!tx_sw_if_index_set)
6465 errmsg ("tx-intfc not set\n");
6469 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
6471 mp->vrf_id = ntohl (inner_vrf_id);
6472 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
6473 mp->adj_address_length = intfc_address_length;
6474 clib_memcpy (mp->dst_mac_address, dst_mac_address,
6475 sizeof (dst_mac_address));
6476 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6477 mp->l2_only = l2_only;
6478 mp->is_add = is_add;
6487 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
6489 unformat_input_t *i = vam->input;
6490 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
6492 u32 inner_vrf_id = 0;
6493 u32 outer_vrf_id = 0;
6494 ip4_address_t adj_address;
6495 int adj_address_set = 0;
6496 ip4_address_t next_hop_address;
6497 int next_hop_address_set = 0;
6499 u8 adj_address_length = 0;
6502 u32 resolve_attempts = 5;
6503 u8 resolve_if_needed = 1;
6505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6507 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
6509 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
6511 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6512 &adj_address, &tmp))
6514 adj_address_length = tmp;
6515 adj_address_set = 1;
6517 else if (unformat (i, "next-hop %U", unformat_ip4_address,
6519 next_hop_address_set = 1;
6520 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6522 else if (unformat (i, "resolve-if-needed %d", &tmp))
6523 resolve_if_needed = tmp;
6524 else if (unformat (i, "l2-only"))
6526 else if (unformat (i, "del"))
6530 clib_warning ("parse error '%U'", format_unformat_error, i);
6535 if (!adj_address_set)
6537 errmsg ("adjacency address/mask not set\n");
6540 if (!next_hop_address_set)
6542 errmsg ("ip4 next hop address (in outer fib) not set\n");
6546 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
6548 mp->inner_vrf_id = ntohl (inner_vrf_id);
6549 mp->outer_vrf_id = ntohl (outer_vrf_id);
6550 mp->resolve_attempts = ntohl (resolve_attempts);
6551 mp->resolve_if_needed = resolve_if_needed;
6552 mp->is_add = is_add;
6553 mp->l2_only = l2_only;
6554 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
6555 mp->adj_address_length = adj_address_length;
6556 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
6557 sizeof (next_hop_address));
6566 api_sw_interface_set_unnumbered (vat_main_t * vam)
6568 unformat_input_t *i = vam->input;
6569 vl_api_sw_interface_set_unnumbered_t *mp;
6572 u32 unnum_sw_index = ~0;
6574 u8 sw_if_index_set = 0;
6576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6578 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6579 sw_if_index_set = 1;
6580 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6581 sw_if_index_set = 1;
6582 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6584 else if (unformat (i, "del"))
6588 clib_warning ("parse error '%U'", format_unformat_error, i);
6593 if (sw_if_index_set == 0)
6595 errmsg ("missing interface name or sw_if_index\n");
6599 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6601 mp->sw_if_index = ntohl (sw_if_index);
6602 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6603 mp->is_add = is_add;
6612 api_ip_neighbor_add_del (vat_main_t * vam)
6614 unformat_input_t *i = vam->input;
6615 vl_api_ip_neighbor_add_del_t *mp;
6618 u8 sw_if_index_set = 0;
6624 u8 v4_address_set = 0;
6625 u8 v6_address_set = 0;
6626 ip4_address_t v4address;
6627 ip6_address_t v6address;
6629 memset (mac_address, 0, sizeof (mac_address));
6631 /* Parse args required to build the message */
6632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6634 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6638 else if (unformat (i, "del"))
6640 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6641 sw_if_index_set = 1;
6642 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6643 sw_if_index_set = 1;
6644 else if (unformat (i, "is_static"))
6646 else if (unformat (i, "vrf %d", &vrf_id))
6648 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6650 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6654 clib_warning ("parse error '%U'", format_unformat_error, i);
6659 if (sw_if_index_set == 0)
6661 errmsg ("missing interface name or sw_if_index\n");
6664 if (v4_address_set && v6_address_set)
6666 errmsg ("both v4 and v6 addresses set\n");
6669 if (!v4_address_set && !v6_address_set)
6671 errmsg ("no address set\n");
6675 /* Construct the API message */
6676 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6678 mp->sw_if_index = ntohl (sw_if_index);
6679 mp->is_add = is_add;
6680 mp->vrf_id = ntohl (vrf_id);
6681 mp->is_static = is_static;
6683 clib_memcpy (mp->mac_address, mac_address, 6);
6687 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6691 /* mp->is_ipv6 = 0; via memset in M macro above */
6692 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6698 /* Wait for a reply, return good/bad news */
6706 api_reset_vrf (vat_main_t * vam)
6708 unformat_input_t *i = vam->input;
6709 vl_api_reset_vrf_t *mp;
6715 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6717 if (unformat (i, "vrf %d", &vrf_id))
6719 else if (unformat (i, "ipv6"))
6723 clib_warning ("parse error '%U'", format_unformat_error, i);
6728 if (vrf_id_set == 0)
6730 errmsg ("missing vrf id\n");
6734 M (RESET_VRF, reset_vrf);
6736 mp->vrf_id = ntohl (vrf_id);
6737 mp->is_ipv6 = is_ipv6;
6746 api_create_vlan_subif (vat_main_t * vam)
6748 unformat_input_t *i = vam->input;
6749 vl_api_create_vlan_subif_t *mp;
6752 u8 sw_if_index_set = 0;
6756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6758 if (unformat (i, "sw_if_index %d", &sw_if_index))
6759 sw_if_index_set = 1;
6760 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6761 sw_if_index_set = 1;
6762 else if (unformat (i, "vlan %d", &vlan_id))
6766 clib_warning ("parse error '%U'", format_unformat_error, i);
6771 if (sw_if_index_set == 0)
6773 errmsg ("missing interface name or sw_if_index\n");
6777 if (vlan_id_set == 0)
6779 errmsg ("missing vlan_id\n");
6782 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6784 mp->sw_if_index = ntohl (sw_if_index);
6785 mp->vlan_id = ntohl (vlan_id);
6793 #define foreach_create_subif_bit \
6800 _(outer_vlan_id_any) \
6801 _(inner_vlan_id_any)
6804 api_create_subif (vat_main_t * vam)
6806 unformat_input_t *i = vam->input;
6807 vl_api_create_subif_t *mp;
6810 u8 sw_if_index_set = 0;
6817 u32 exact_match = 0;
6818 u32 default_sub = 0;
6819 u32 outer_vlan_id_any = 0;
6820 u32 inner_vlan_id_any = 0;
6822 u16 outer_vlan_id = 0;
6823 u16 inner_vlan_id = 0;
6825 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6827 if (unformat (i, "sw_if_index %d", &sw_if_index))
6828 sw_if_index_set = 1;
6829 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6830 sw_if_index_set = 1;
6831 else if (unformat (i, "sub_id %d", &sub_id))
6833 else if (unformat (i, "outer_vlan_id %d", &tmp))
6834 outer_vlan_id = tmp;
6835 else if (unformat (i, "inner_vlan_id %d", &tmp))
6836 inner_vlan_id = tmp;
6838 #define _(a) else if (unformat (i, #a)) a = 1 ;
6839 foreach_create_subif_bit
6843 clib_warning ("parse error '%U'", format_unformat_error, i);
6848 if (sw_if_index_set == 0)
6850 errmsg ("missing interface name or sw_if_index\n");
6854 if (sub_id_set == 0)
6856 errmsg ("missing sub_id\n");
6859 M (CREATE_SUBIF, create_subif);
6861 mp->sw_if_index = ntohl (sw_if_index);
6862 mp->sub_id = ntohl (sub_id);
6864 #define _(a) mp->a = a;
6865 foreach_create_subif_bit;
6868 mp->outer_vlan_id = ntohs (outer_vlan_id);
6869 mp->inner_vlan_id = ntohs (inner_vlan_id);
6878 api_oam_add_del (vat_main_t * vam)
6880 unformat_input_t *i = vam->input;
6881 vl_api_oam_add_del_t *mp;
6885 ip4_address_t src, dst;
6889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6891 if (unformat (i, "vrf %d", &vrf_id))
6893 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6895 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6897 else if (unformat (i, "del"))
6901 clib_warning ("parse error '%U'", format_unformat_error, i);
6908 errmsg ("missing src addr\n");
6914 errmsg ("missing dst addr\n");
6918 M (OAM_ADD_DEL, oam_add_del);
6920 mp->vrf_id = ntohl (vrf_id);
6921 mp->is_add = is_add;
6922 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6923 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6932 api_reset_fib (vat_main_t * vam)
6934 unformat_input_t *i = vam->input;
6935 vl_api_reset_fib_t *mp;
6941 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6943 if (unformat (i, "vrf %d", &vrf_id))
6945 else if (unformat (i, "ipv6"))
6949 clib_warning ("parse error '%U'", format_unformat_error, i);
6954 if (vrf_id_set == 0)
6956 errmsg ("missing vrf id\n");
6960 M (RESET_FIB, reset_fib);
6962 mp->vrf_id = ntohl (vrf_id);
6963 mp->is_ipv6 = is_ipv6;
6972 api_dhcp_proxy_config (vat_main_t * vam)
6974 unformat_input_t *i = vam->input;
6975 vl_api_dhcp_proxy_config_t *mp;
6980 u8 v4_address_set = 0;
6981 u8 v6_address_set = 0;
6982 ip4_address_t v4address;
6983 ip6_address_t v6address;
6984 u8 v4_src_address_set = 0;
6985 u8 v6_src_address_set = 0;
6986 ip4_address_t v4srcaddress;
6987 ip6_address_t v6srcaddress;
6989 /* Parse args required to build the message */
6990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6992 if (unformat (i, "del"))
6994 else if (unformat (i, "vrf %d", &vrf_id))
6996 else if (unformat (i, "insert-cid %d", &insert_cid))
6998 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7000 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7002 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7003 v4_src_address_set = 1;
7004 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7005 v6_src_address_set = 1;
7010 if (v4_address_set && v6_address_set)
7012 errmsg ("both v4 and v6 server addresses set\n");
7015 if (!v4_address_set && !v6_address_set)
7017 errmsg ("no server addresses set\n");
7021 if (v4_src_address_set && v6_src_address_set)
7023 errmsg ("both v4 and v6 src addresses set\n");
7026 if (!v4_src_address_set && !v6_src_address_set)
7028 errmsg ("no src addresses set\n");
7032 if (!(v4_src_address_set && v4_address_set) &&
7033 !(v6_src_address_set && v6_address_set))
7035 errmsg ("no matching server and src addresses set\n");
7039 /* Construct the API message */
7040 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7042 mp->insert_circuit_id = insert_cid;
7043 mp->is_add = is_add;
7044 mp->vrf_id = ntohl (vrf_id);
7048 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7049 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7053 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7054 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7060 /* Wait for a reply, return good/bad news */
7067 api_dhcp_proxy_config_2 (vat_main_t * vam)
7069 unformat_input_t *i = vam->input;
7070 vl_api_dhcp_proxy_config_2_t *mp;
7073 u32 server_vrf_id = 0;
7076 u8 v4_address_set = 0;
7077 u8 v6_address_set = 0;
7078 ip4_address_t v4address;
7079 ip6_address_t v6address;
7080 u8 v4_src_address_set = 0;
7081 u8 v6_src_address_set = 0;
7082 ip4_address_t v4srcaddress;
7083 ip6_address_t v6srcaddress;
7085 /* Parse args required to build the message */
7086 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7088 if (unformat (i, "del"))
7090 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7092 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7094 else if (unformat (i, "insert-cid %d", &insert_cid))
7096 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7098 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7100 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7101 v4_src_address_set = 1;
7102 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7103 v6_src_address_set = 1;
7108 if (v4_address_set && v6_address_set)
7110 errmsg ("both v4 and v6 server addresses set\n");
7113 if (!v4_address_set && !v6_address_set)
7115 errmsg ("no server addresses set\n");
7119 if (v4_src_address_set && v6_src_address_set)
7121 errmsg ("both v4 and v6 src addresses set\n");
7124 if (!v4_src_address_set && !v6_src_address_set)
7126 errmsg ("no src addresses set\n");
7130 if (!(v4_src_address_set && v4_address_set) &&
7131 !(v6_src_address_set && v6_address_set))
7133 errmsg ("no matching server and src addresses set\n");
7137 /* Construct the API message */
7138 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7140 mp->insert_circuit_id = insert_cid;
7141 mp->is_add = is_add;
7142 mp->rx_vrf_id = ntohl (rx_vrf_id);
7143 mp->server_vrf_id = ntohl (server_vrf_id);
7147 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7148 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7152 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7153 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7159 /* Wait for a reply, return good/bad news */
7166 api_dhcp_proxy_set_vss (vat_main_t * vam)
7168 unformat_input_t *i = vam->input;
7169 vl_api_dhcp_proxy_set_vss_t *mp;
7180 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7182 if (unformat (i, "tbl_id %d", &tbl_id))
7184 if (unformat (i, "fib_id %d", &fib_id))
7186 if (unformat (i, "oui %d", &oui))
7188 else if (unformat (i, "ipv6"))
7190 else if (unformat (i, "del"))
7194 clib_warning ("parse error '%U'", format_unformat_error, i);
7199 if (tbl_id_set == 0)
7201 errmsg ("missing tbl id\n");
7205 if (fib_id_set == 0)
7207 errmsg ("missing fib id\n");
7212 errmsg ("missing oui\n");
7216 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7217 mp->tbl_id = ntohl (tbl_id);
7218 mp->fib_id = ntohl (fib_id);
7219 mp->oui = ntohl (oui);
7220 mp->is_ipv6 = is_ipv6;
7221 mp->is_add = is_add;
7230 api_dhcp_client_config (vat_main_t * vam)
7232 unformat_input_t *i = vam->input;
7233 vl_api_dhcp_client_config_t *mp;
7236 u8 sw_if_index_set = 0;
7239 u8 disable_event = 0;
7241 /* Parse args required to build the message */
7242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7244 if (unformat (i, "del"))
7246 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7247 sw_if_index_set = 1;
7248 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7249 sw_if_index_set = 1;
7250 else if (unformat (i, "hostname %s", &hostname))
7252 else if (unformat (i, "disable_event"))
7258 if (sw_if_index_set == 0)
7260 errmsg ("missing interface name or sw_if_index\n");
7264 if (vec_len (hostname) > 63)
7266 errmsg ("hostname too long\n");
7268 vec_add1 (hostname, 0);
7270 /* Construct the API message */
7271 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7273 mp->sw_if_index = ntohl (sw_if_index);
7274 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7275 vec_free (hostname);
7276 mp->is_add = is_add;
7277 mp->want_dhcp_event = disable_event ? 0 : 1;
7278 mp->pid = getpid ();
7283 /* Wait for a reply, return good/bad news */
7290 api_set_ip_flow_hash (vat_main_t * vam)
7292 unformat_input_t *i = vam->input;
7293 vl_api_set_ip_flow_hash_t *mp;
7305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7307 if (unformat (i, "vrf %d", &vrf_id))
7309 else if (unformat (i, "ipv6"))
7311 else if (unformat (i, "src"))
7313 else if (unformat (i, "dst"))
7315 else if (unformat (i, "sport"))
7317 else if (unformat (i, "dport"))
7319 else if (unformat (i, "proto"))
7321 else if (unformat (i, "reverse"))
7326 clib_warning ("parse error '%U'", format_unformat_error, i);
7331 if (vrf_id_set == 0)
7333 errmsg ("missing vrf id\n");
7337 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7343 mp->reverse = reverse;
7344 mp->vrf_id = ntohl (vrf_id);
7345 mp->is_ipv6 = is_ipv6;
7354 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7356 unformat_input_t *i = vam->input;
7357 vl_api_sw_interface_ip6_enable_disable_t *mp;
7360 u8 sw_if_index_set = 0;
7363 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7365 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7366 sw_if_index_set = 1;
7367 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7368 sw_if_index_set = 1;
7369 else if (unformat (i, "enable"))
7371 else if (unformat (i, "disable"))
7375 clib_warning ("parse error '%U'", format_unformat_error, i);
7380 if (sw_if_index_set == 0)
7382 errmsg ("missing interface name or sw_if_index\n");
7386 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
7388 mp->sw_if_index = ntohl (sw_if_index);
7389 mp->enable = enable;
7398 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7400 unformat_input_t *i = vam->input;
7401 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7404 u8 sw_if_index_set = 0;
7405 u32 address_length = 0;
7406 u8 v6_address_set = 0;
7407 ip6_address_t v6address;
7409 /* Parse args required to build the message */
7410 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7412 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7413 sw_if_index_set = 1;
7414 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7415 sw_if_index_set = 1;
7416 else if (unformat (i, "%U/%d",
7417 unformat_ip6_address, &v6address, &address_length))
7423 if (sw_if_index_set == 0)
7425 errmsg ("missing interface name or sw_if_index\n");
7428 if (!v6_address_set)
7430 errmsg ("no address set\n");
7434 /* Construct the API message */
7435 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
7436 sw_interface_ip6_set_link_local_address);
7438 mp->sw_if_index = ntohl (sw_if_index);
7439 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7440 mp->address_length = address_length;
7445 /* Wait for a reply, return good/bad news */
7454 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7456 unformat_input_t *i = vam->input;
7457 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7460 u8 sw_if_index_set = 0;
7461 u32 address_length = 0;
7462 u8 v6_address_set = 0;
7463 ip6_address_t v6address;
7465 u8 no_advertise = 0;
7467 u8 no_autoconfig = 0;
7470 u32 val_lifetime = 0;
7471 u32 pref_lifetime = 0;
7473 /* Parse args required to build the message */
7474 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7476 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7477 sw_if_index_set = 1;
7478 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7479 sw_if_index_set = 1;
7480 else if (unformat (i, "%U/%d",
7481 unformat_ip6_address, &v6address, &address_length))
7483 else if (unformat (i, "val_life %d", &val_lifetime))
7485 else if (unformat (i, "pref_life %d", &pref_lifetime))
7487 else if (unformat (i, "def"))
7489 else if (unformat (i, "noadv"))
7491 else if (unformat (i, "offl"))
7493 else if (unformat (i, "noauto"))
7495 else if (unformat (i, "nolink"))
7497 else if (unformat (i, "isno"))
7501 clib_warning ("parse error '%U'", format_unformat_error, i);
7506 if (sw_if_index_set == 0)
7508 errmsg ("missing interface name or sw_if_index\n");
7511 if (!v6_address_set)
7513 errmsg ("no address set\n");
7517 /* Construct the API message */
7518 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
7520 mp->sw_if_index = ntohl (sw_if_index);
7521 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7522 mp->address_length = address_length;
7523 mp->use_default = use_default;
7524 mp->no_advertise = no_advertise;
7525 mp->off_link = off_link;
7526 mp->no_autoconfig = no_autoconfig;
7527 mp->no_onlink = no_onlink;
7529 mp->val_lifetime = ntohl (val_lifetime);
7530 mp->pref_lifetime = ntohl (pref_lifetime);
7535 /* Wait for a reply, return good/bad news */
7543 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7545 unformat_input_t *i = vam->input;
7546 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7549 u8 sw_if_index_set = 0;
7554 u8 send_unicast = 0;
7557 u8 default_router = 0;
7558 u32 max_interval = 0;
7559 u32 min_interval = 0;
7561 u32 initial_count = 0;
7562 u32 initial_interval = 0;
7565 /* Parse args required to build the message */
7566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7568 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7569 sw_if_index_set = 1;
7570 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7571 sw_if_index_set = 1;
7572 else if (unformat (i, "maxint %d", &max_interval))
7574 else if (unformat (i, "minint %d", &min_interval))
7576 else if (unformat (i, "life %d", &lifetime))
7578 else if (unformat (i, "count %d", &initial_count))
7580 else if (unformat (i, "interval %d", &initial_interval))
7582 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7584 else if (unformat (i, "managed"))
7586 else if (unformat (i, "other"))
7588 else if (unformat (i, "ll"))
7590 else if (unformat (i, "send"))
7592 else if (unformat (i, "cease"))
7594 else if (unformat (i, "isno"))
7596 else if (unformat (i, "def"))
7600 clib_warning ("parse error '%U'", format_unformat_error, i);
7605 if (sw_if_index_set == 0)
7607 errmsg ("missing interface name or sw_if_index\n");
7611 /* Construct the API message */
7612 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7614 mp->sw_if_index = ntohl (sw_if_index);
7615 mp->max_interval = ntohl (max_interval);
7616 mp->min_interval = ntohl (min_interval);
7617 mp->lifetime = ntohl (lifetime);
7618 mp->initial_count = ntohl (initial_count);
7619 mp->initial_interval = ntohl (initial_interval);
7620 mp->suppress = suppress;
7621 mp->managed = managed;
7623 mp->ll_option = ll_option;
7624 mp->send_unicast = send_unicast;
7627 mp->default_router = default_router;
7632 /* Wait for a reply, return good/bad news */
7640 api_set_arp_neighbor_limit (vat_main_t * vam)
7642 unformat_input_t *i = vam->input;
7643 vl_api_set_arp_neighbor_limit_t *mp;
7649 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7651 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7653 else if (unformat (i, "ipv6"))
7657 clib_warning ("parse error '%U'", format_unformat_error, i);
7664 errmsg ("missing limit value\n");
7668 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7670 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7671 mp->is_ipv6 = is_ipv6;
7680 api_l2_patch_add_del (vat_main_t * vam)
7682 unformat_input_t *i = vam->input;
7683 vl_api_l2_patch_add_del_t *mp;
7686 u8 rx_sw_if_index_set = 0;
7688 u8 tx_sw_if_index_set = 0;
7691 /* Parse args required to build the message */
7692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7694 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7695 rx_sw_if_index_set = 1;
7696 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7697 tx_sw_if_index_set = 1;
7698 else if (unformat (i, "rx"))
7700 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7702 if (unformat (i, "%U", unformat_sw_if_index, vam,
7704 rx_sw_if_index_set = 1;
7709 else if (unformat (i, "tx"))
7711 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7713 if (unformat (i, "%U", unformat_sw_if_index, vam,
7715 tx_sw_if_index_set = 1;
7720 else if (unformat (i, "del"))
7726 if (rx_sw_if_index_set == 0)
7728 errmsg ("missing rx interface name or rx_sw_if_index\n");
7732 if (tx_sw_if_index_set == 0)
7734 errmsg ("missing tx interface name or tx_sw_if_index\n");
7738 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7740 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7741 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7742 mp->is_add = is_add;
7751 api_ioam_enable (vat_main_t * vam)
7753 unformat_input_t *input = vam->input;
7754 vl_api_ioam_enable_t *mp;
7757 int has_trace_option = 0;
7758 int has_pow_option = 0;
7759 int has_ppc_option = 0;
7761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7763 if (unformat (input, "trace"))
7764 has_trace_option = 1;
7765 else if (unformat (input, "pow"))
7767 else if (unformat (input, "ppc encap"))
7768 has_ppc_option = PPC_ENCAP;
7769 else if (unformat (input, "ppc decap"))
7770 has_ppc_option = PPC_DECAP;
7771 else if (unformat (input, "ppc none"))
7772 has_ppc_option = PPC_NONE;
7776 M (IOAM_ENABLE, ioam_enable);
7777 mp->id = htons (id);
7778 mp->trace_ppc = has_ppc_option;
7779 mp->pow_enable = has_pow_option;
7780 mp->trace_enable = has_trace_option;
7791 api_ioam_disable (vat_main_t * vam)
7793 vl_api_ioam_disable_t *mp;
7796 M (IOAM_DISABLE, ioam_disable);
7803 api_sr_tunnel_add_del (vat_main_t * vam)
7805 unformat_input_t *i = vam->input;
7806 vl_api_sr_tunnel_add_del_t *mp;
7810 ip6_address_t src_address;
7811 int src_address_set = 0;
7812 ip6_address_t dst_address;
7814 int dst_address_set = 0;
7816 u32 rx_table_id = 0;
7817 u32 tx_table_id = 0;
7818 ip6_address_t *segments = 0;
7819 ip6_address_t *this_seg;
7820 ip6_address_t *tags = 0;
7821 ip6_address_t *this_tag;
7822 ip6_address_t next_address, tag;
7824 u8 *policy_name = 0;
7826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7828 if (unformat (i, "del"))
7830 else if (unformat (i, "name %s", &name))
7832 else if (unformat (i, "policy %s", &policy_name))
7834 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7836 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7838 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7839 src_address_set = 1;
7840 else if (unformat (i, "dst %U/%d",
7841 unformat_ip6_address, &dst_address, &dst_mask_width))
7842 dst_address_set = 1;
7843 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7845 vec_add2 (segments, this_seg, 1);
7846 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7847 sizeof (*this_seg));
7849 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7851 vec_add2 (tags, this_tag, 1);
7852 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7854 else if (unformat (i, "clean"))
7855 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7856 else if (unformat (i, "protected"))
7857 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7858 else if (unformat (i, "InPE %d", &pl_index))
7860 if (pl_index <= 0 || pl_index > 4)
7862 pl_index_range_error:
7863 errmsg ("pl index %d out of range\n", pl_index);
7867 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7869 else if (unformat (i, "EgPE %d", &pl_index))
7871 if (pl_index <= 0 || pl_index > 4)
7872 goto pl_index_range_error;
7874 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7876 else if (unformat (i, "OrgSrc %d", &pl_index))
7878 if (pl_index <= 0 || pl_index > 4)
7879 goto pl_index_range_error;
7881 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7887 if (!src_address_set)
7889 errmsg ("src address required\n");
7893 if (!dst_address_set)
7895 errmsg ("dst address required\n");
7901 errmsg ("at least one sr segment required\n");
7905 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7906 vec_len (segments) * sizeof (ip6_address_t)
7907 + vec_len (tags) * sizeof (ip6_address_t));
7909 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7910 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7911 mp->dst_mask_width = dst_mask_width;
7912 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7913 mp->n_segments = vec_len (segments);
7914 mp->n_tags = vec_len (tags);
7915 mp->is_add = is_del == 0;
7916 clib_memcpy (mp->segs_and_tags, segments,
7917 vec_len (segments) * sizeof (ip6_address_t));
7918 clib_memcpy (mp->segs_and_tags +
7919 vec_len (segments) * sizeof (ip6_address_t), tags,
7920 vec_len (tags) * sizeof (ip6_address_t));
7922 mp->outer_vrf_id = ntohl (rx_table_id);
7923 mp->inner_vrf_id = ntohl (tx_table_id);
7924 memcpy (mp->name, name, vec_len (name));
7925 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7927 vec_free (segments);
7936 api_sr_policy_add_del (vat_main_t * vam)
7938 unformat_input_t *input = vam->input;
7939 vl_api_sr_policy_add_del_t *mp;
7943 u8 *tunnel_name = 0;
7944 u8 **tunnel_names = 0;
7949 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
7950 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
7952 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7954 if (unformat (input, "del"))
7956 else if (unformat (input, "name %s", &name))
7958 else if (unformat (input, "tunnel %s", &tunnel_name))
7962 vec_add1 (tunnel_names, tunnel_name);
7964 - length = #bytes to store in serial vector
7965 - +1 = byte to store that length
7967 tunnel_names_length += (vec_len (tunnel_name) + 1);
7978 errmsg ("policy name required\n");
7982 if ((!tunnel_set) && (!is_del))
7984 errmsg ("tunnel name required\n");
7988 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
7992 mp->is_add = !is_del;
7994 memcpy (mp->name, name, vec_len (name));
7995 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
7996 u8 *serial_orig = 0;
7997 vec_validate (serial_orig, tunnel_names_length);
7998 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
7999 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8001 for (j = 0; j < vec_len (tunnel_names); j++)
8003 tun_name_len = vec_len (tunnel_names[j]);
8004 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8005 serial_orig += 1; // Move along one byte to store the actual tunnel name
8006 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8007 serial_orig += tun_name_len; // Advance past the copy
8009 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8011 vec_free (tunnel_names);
8012 vec_free (tunnel_name);
8020 api_sr_multicast_map_add_del (vat_main_t * vam)
8022 unformat_input_t *input = vam->input;
8023 vl_api_sr_multicast_map_add_del_t *mp;
8026 ip6_address_t multicast_address;
8027 u8 *policy_name = 0;
8028 int multicast_address_set = 0;
8030 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8032 if (unformat (input, "del"))
8036 (input, "address %U", unformat_ip6_address, &multicast_address))
8037 multicast_address_set = 1;
8038 else if (unformat (input, "sr-policy %s", &policy_name))
8044 if (!is_del && !policy_name)
8046 errmsg ("sr-policy name required\n");
8051 if (!multicast_address_set)
8053 errmsg ("address required\n");
8057 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8059 mp->is_add = !is_del;
8060 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8061 clib_memcpy (mp->multicast_address, &multicast_address,
8062 sizeof (mp->multicast_address));
8065 vec_free (policy_name);
8073 #define foreach_tcp_proto_field \
8077 #define foreach_udp_proto_field \
8081 #define foreach_ip4_proto_field \
8092 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8094 u8 **maskp = va_arg (*args, u8 **);
8096 u8 found_something = 0;
8099 #define _(a) u8 a=0;
8100 foreach_tcp_proto_field;
8103 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8106 #define _(a) else if (unformat (input, #a)) a=1;
8107 foreach_tcp_proto_field
8113 #define _(a) found_something += a;
8114 foreach_tcp_proto_field;
8117 if (found_something == 0)
8120 vec_validate (mask, sizeof (*tcp) - 1);
8122 tcp = (tcp_header_t *) mask;
8124 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8125 foreach_tcp_proto_field;
8133 unformat_udp_mask (unformat_input_t * input, va_list * args)
8135 u8 **maskp = va_arg (*args, u8 **);
8137 u8 found_something = 0;
8140 #define _(a) u8 a=0;
8141 foreach_udp_proto_field;
8144 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8147 #define _(a) else if (unformat (input, #a)) a=1;
8148 foreach_udp_proto_field
8154 #define _(a) found_something += a;
8155 foreach_udp_proto_field;
8158 if (found_something == 0)
8161 vec_validate (mask, sizeof (*udp) - 1);
8163 udp = (udp_header_t *) mask;
8165 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8166 foreach_udp_proto_field;
8175 u16 src_port, dst_port;
8179 unformat_l4_mask (unformat_input_t * input, va_list * args)
8181 u8 **maskp = va_arg (*args, u8 **);
8182 u16 src_port = 0, dst_port = 0;
8183 tcpudp_header_t *tcpudp;
8185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8187 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8189 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8191 else if (unformat (input, "src_port"))
8193 else if (unformat (input, "dst_port"))
8199 if (!src_port && !dst_port)
8203 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8205 tcpudp = (tcpudp_header_t *) mask;
8206 tcpudp->src_port = src_port;
8207 tcpudp->dst_port = dst_port;
8215 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8217 u8 **maskp = va_arg (*args, u8 **);
8219 u8 found_something = 0;
8222 #define _(a) u8 a=0;
8223 foreach_ip4_proto_field;
8229 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8231 if (unformat (input, "version"))
8233 else if (unformat (input, "hdr_length"))
8235 else if (unformat (input, "src"))
8237 else if (unformat (input, "dst"))
8239 else if (unformat (input, "proto"))
8242 #define _(a) else if (unformat (input, #a)) a=1;
8243 foreach_ip4_proto_field
8249 #define _(a) found_something += a;
8250 foreach_ip4_proto_field;
8253 if (found_something == 0)
8256 vec_validate (mask, sizeof (*ip) - 1);
8258 ip = (ip4_header_t *) mask;
8260 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8261 foreach_ip4_proto_field;
8264 ip->ip_version_and_header_length = 0;
8267 ip->ip_version_and_header_length |= 0xF0;
8270 ip->ip_version_and_header_length |= 0x0F;
8276 #define foreach_ip6_proto_field \
8284 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8286 u8 **maskp = va_arg (*args, u8 **);
8288 u8 found_something = 0;
8290 u32 ip_version_traffic_class_and_flow_label;
8292 #define _(a) u8 a=0;
8293 foreach_ip6_proto_field;
8296 u8 traffic_class = 0;
8299 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8301 if (unformat (input, "version"))
8303 else if (unformat (input, "traffic-class"))
8305 else if (unformat (input, "flow-label"))
8307 else if (unformat (input, "src"))
8309 else if (unformat (input, "dst"))
8311 else if (unformat (input, "proto"))
8314 #define _(a) else if (unformat (input, #a)) a=1;
8315 foreach_ip6_proto_field
8321 #define _(a) found_something += a;
8322 foreach_ip6_proto_field;
8325 if (found_something == 0)
8328 vec_validate (mask, sizeof (*ip) - 1);
8330 ip = (ip6_header_t *) mask;
8332 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8333 foreach_ip6_proto_field;
8336 ip_version_traffic_class_and_flow_label = 0;
8339 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8342 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8345 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8347 ip->ip_version_traffic_class_and_flow_label =
8348 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8355 unformat_l3_mask (unformat_input_t * input, va_list * args)
8357 u8 **maskp = va_arg (*args, u8 **);
8359 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8361 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8363 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8372 unformat_l2_mask (unformat_input_t * input, va_list * args)
8374 u8 **maskp = va_arg (*args, u8 **);
8389 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8391 if (unformat (input, "src"))
8393 else if (unformat (input, "dst"))
8395 else if (unformat (input, "proto"))
8397 else if (unformat (input, "tag1"))
8399 else if (unformat (input, "tag2"))
8401 else if (unformat (input, "ignore-tag1"))
8403 else if (unformat (input, "ignore-tag2"))
8405 else if (unformat (input, "cos1"))
8407 else if (unformat (input, "cos2"))
8409 else if (unformat (input, "dot1q"))
8411 else if (unformat (input, "dot1ad"))
8416 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8417 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8420 if (tag1 || ignore_tag1 || cos1 || dot1q)
8422 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8425 vec_validate (mask, len - 1);
8428 memset (mask, 0xff, 6);
8431 memset (mask + 6, 0xff, 6);
8435 /* inner vlan tag */
8444 mask[21] = mask[20] = 0xff;
8465 mask[16] = mask[17] = 0xff;
8475 mask[12] = mask[13] = 0xff;
8482 unformat_classify_mask (unformat_input_t * input, va_list * args)
8484 u8 **maskp = va_arg (*args, u8 **);
8485 u32 *skipp = va_arg (*args, u32 *);
8486 u32 *matchp = va_arg (*args, u32 *);
8494 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8496 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8498 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8500 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8502 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8516 if (mask || l2 || l3 || l4)
8520 /* "With a free Ethernet header in every package" */
8522 vec_validate (l2, 13);
8526 vec_append (mask, l3);
8531 vec_append (mask, l4);
8536 /* Scan forward looking for the first significant mask octet */
8537 for (i = 0; i < vec_len (mask); i++)
8541 /* compute (skip, match) params */
8542 *skipp = i / sizeof (u32x4);
8543 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8545 /* Pad mask to an even multiple of the vector size */
8546 while (vec_len (mask) % sizeof (u32x4))
8549 match = vec_len (mask) / sizeof (u32x4);
8551 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8553 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8554 if (*tmp || *(tmp + 1))
8559 clib_warning ("BUG: match 0");
8561 _vec_len (mask) = match * sizeof (u32x4);
8572 #define foreach_l2_next \
8574 _(ethernet, ETHERNET_INPUT) \
8579 unformat_l2_next_index (unformat_input_t * input, va_list * args)
8581 u32 *miss_next_indexp = va_arg (*args, u32 *);
8586 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8590 if (unformat (input, "%d", &tmp))
8599 *miss_next_indexp = next_index;
8603 #define foreach_ip_next \
8609 unformat_ip_next_index (unformat_input_t * input, va_list * args)
8611 u32 *miss_next_indexp = va_arg (*args, u32 *);
8616 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8620 if (unformat (input, "%d", &tmp))
8629 *miss_next_indexp = next_index;
8633 #define foreach_acl_next \
8637 unformat_acl_next_index (unformat_input_t * input, va_list * args)
8639 u32 *miss_next_indexp = va_arg (*args, u32 *);
8644 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8648 if (unformat (input, "permit"))
8653 else if (unformat (input, "%d", &tmp))
8662 *miss_next_indexp = next_index;
8667 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8669 u32 *r = va_arg (*args, u32 *);
8671 if (unformat (input, "conform-color"))
8672 *r = POLICE_CONFORM;
8673 else if (unformat (input, "exceed-color"))
8682 api_classify_add_del_table (vat_main_t * vam)
8684 unformat_input_t *i = vam->input;
8685 vl_api_classify_add_del_table_t *mp;
8691 u32 table_index = ~0;
8692 u32 next_table_index = ~0;
8693 u32 miss_next_index = ~0;
8694 u32 memory_size = 32 << 20;
8698 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8700 if (unformat (i, "del"))
8702 else if (unformat (i, "buckets %d", &nbuckets))
8704 else if (unformat (i, "memory_size %d", &memory_size))
8706 else if (unformat (i, "skip %d", &skip))
8708 else if (unformat (i, "match %d", &match))
8710 else if (unformat (i, "table %d", &table_index))
8712 else if (unformat (i, "mask %U", unformat_classify_mask,
8713 &mask, &skip, &match))
8715 else if (unformat (i, "next-table %d", &next_table_index))
8717 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8720 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8723 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8730 if (is_add && mask == 0)
8732 errmsg ("Mask required\n");
8736 if (is_add && skip == ~0)
8738 errmsg ("skip count required\n");
8742 if (is_add && match == ~0)
8744 errmsg ("match count required\n");
8748 if (!is_add && table_index == ~0)
8750 errmsg ("table index required for delete\n");
8754 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8756 mp->is_add = is_add;
8757 mp->table_index = ntohl (table_index);
8758 mp->nbuckets = ntohl (nbuckets);
8759 mp->memory_size = ntohl (memory_size);
8760 mp->skip_n_vectors = ntohl (skip);
8761 mp->match_n_vectors = ntohl (match);
8762 mp->next_table_index = ntohl (next_table_index);
8763 mp->miss_next_index = ntohl (miss_next_index);
8764 clib_memcpy (mp->mask, mask, vec_len (mask));
8774 unformat_l4_match (unformat_input_t * input, va_list * args)
8776 u8 **matchp = va_arg (*args, u8 **);
8778 u8 *proto_header = 0;
8784 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8786 if (unformat (input, "src_port %d", &src_port))
8788 else if (unformat (input, "dst_port %d", &dst_port))
8794 h.src_port = clib_host_to_net_u16 (src_port);
8795 h.dst_port = clib_host_to_net_u16 (dst_port);
8796 vec_validate (proto_header, sizeof (h) - 1);
8797 memcpy (proto_header, &h, sizeof (h));
8799 *matchp = proto_header;
8805 unformat_ip4_match (unformat_input_t * input, va_list * args)
8807 u8 **matchp = va_arg (*args, u8 **);
8814 int src = 0, dst = 0;
8815 ip4_address_t src_val, dst_val;
8822 int fragment_id = 0;
8823 u32 fragment_id_val;
8829 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8831 if (unformat (input, "version %d", &version_val))
8833 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8835 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8837 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8839 else if (unformat (input, "proto %d", &proto_val))
8841 else if (unformat (input, "tos %d", &tos_val))
8843 else if (unformat (input, "length %d", &length_val))
8845 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8847 else if (unformat (input, "ttl %d", &ttl_val))
8849 else if (unformat (input, "checksum %d", &checksum_val))
8855 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8856 + ttl + checksum == 0)
8860 * Aligned because we use the real comparison functions
8862 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8864 ip = (ip4_header_t *) match;
8866 /* These are realistically matched in practice */
8868 ip->src_address.as_u32 = src_val.as_u32;
8871 ip->dst_address.as_u32 = dst_val.as_u32;
8874 ip->protocol = proto_val;
8877 /* These are not, but they're included for completeness */
8879 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8882 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8888 ip->length = clib_host_to_net_u16 (length_val);
8894 ip->checksum = clib_host_to_net_u16 (checksum_val);
8901 unformat_ip6_match (unformat_input_t * input, va_list * args)
8903 u8 **matchp = va_arg (*args, u8 **);
8908 u8 traffic_class = 0;
8909 u32 traffic_class_val = 0;
8912 int src = 0, dst = 0;
8913 ip6_address_t src_val, dst_val;
8916 int payload_length = 0;
8917 u32 payload_length_val;
8920 u32 ip_version_traffic_class_and_flow_label;
8922 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8924 if (unformat (input, "version %d", &version_val))
8926 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8928 else if (unformat (input, "flow_label %d", &flow_label_val))
8930 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8932 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8934 else if (unformat (input, "proto %d", &proto_val))
8936 else if (unformat (input, "payload_length %d", &payload_length_val))
8938 else if (unformat (input, "hop_limit %d", &hop_limit_val))
8944 if (version + traffic_class + flow_label + src + dst + proto +
8945 payload_length + hop_limit == 0)
8949 * Aligned because we use the real comparison functions
8951 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8953 ip = (ip6_header_t *) match;
8956 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
8959 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
8962 ip->protocol = proto_val;
8964 ip_version_traffic_class_and_flow_label = 0;
8967 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
8970 ip_version_traffic_class_and_flow_label |=
8971 (traffic_class_val & 0xFF) << 20;
8974 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
8976 ip->ip_version_traffic_class_and_flow_label =
8977 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8980 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
8983 ip->hop_limit = hop_limit_val;
8990 unformat_l3_match (unformat_input_t * input, va_list * args)
8992 u8 **matchp = va_arg (*args, u8 **);
8994 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8996 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
8998 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9007 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9009 u8 *tagp = va_arg (*args, u8 *);
9012 if (unformat (input, "%d", &tag))
9014 tagp[0] = (tag >> 8) & 0x0F;
9015 tagp[1] = tag & 0xFF;
9023 unformat_l2_match (unformat_input_t * input, va_list * args)
9025 u8 **matchp = va_arg (*args, u8 **);
9045 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9047 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9050 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9052 else if (unformat (input, "proto %U",
9053 unformat_ethernet_type_host_byte_order, &proto_val))
9055 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9057 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9059 else if (unformat (input, "ignore-tag1"))
9061 else if (unformat (input, "ignore-tag2"))
9063 else if (unformat (input, "cos1 %d", &cos1_val))
9065 else if (unformat (input, "cos2 %d", &cos2_val))
9070 if ((src + dst + proto + tag1 + tag2 +
9071 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9074 if (tag1 || ignore_tag1 || cos1)
9076 if (tag2 || ignore_tag2 || cos2)
9079 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9082 clib_memcpy (match, dst_val, 6);
9085 clib_memcpy (match + 6, src_val, 6);
9089 /* inner vlan tag */
9090 match[19] = tag2_val[1];
9091 match[18] = tag2_val[0];
9093 match[18] |= (cos2_val & 0x7) << 5;
9096 match[21] = proto_val & 0xff;
9097 match[20] = proto_val >> 8;
9101 match[15] = tag1_val[1];
9102 match[14] = tag1_val[0];
9105 match[14] |= (cos1_val & 0x7) << 5;
9111 match[15] = tag1_val[1];
9112 match[14] = tag1_val[0];
9115 match[17] = proto_val & 0xff;
9116 match[16] = proto_val >> 8;
9119 match[14] |= (cos1_val & 0x7) << 5;
9125 match[18] |= (cos2_val & 0x7) << 5;
9127 match[14] |= (cos1_val & 0x7) << 5;
9130 match[13] = proto_val & 0xff;
9131 match[12] = proto_val >> 8;
9140 unformat_classify_match (unformat_input_t * input, va_list * args)
9142 u8 **matchp = va_arg (*args, u8 **);
9143 u32 skip_n_vectors = va_arg (*args, u32);
9144 u32 match_n_vectors = va_arg (*args, u32);
9151 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9153 if (unformat (input, "hex %U", unformat_hex_string, &match))
9155 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9157 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9159 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9173 if (match || l2 || l3 || l4)
9177 /* "Win a free Ethernet header in every packet" */
9179 vec_validate_aligned (l2, 13, sizeof (u32x4));
9183 vec_append_aligned (match, l3, sizeof (u32x4));
9188 vec_append_aligned (match, l4, sizeof (u32x4));
9193 /* Make sure the vector is big enough even if key is all 0's */
9194 vec_validate_aligned
9195 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9198 /* Set size, include skipped vectors */
9199 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9210 api_classify_add_del_session (vat_main_t * vam)
9212 unformat_input_t *i = vam->input;
9213 vl_api_classify_add_del_session_t *mp;
9215 u32 table_index = ~0;
9216 u32 hit_next_index = ~0;
9217 u32 opaque_index = ~0;
9221 u32 skip_n_vectors = 0;
9222 u32 match_n_vectors = 0;
9225 * Warning: you have to supply skip_n and match_n
9226 * because the API client cant simply look at the classify
9230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9232 if (unformat (i, "del"))
9234 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9237 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9240 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9243 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9245 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9247 else if (unformat (i, "opaque-index %d", &opaque_index))
9249 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9251 else if (unformat (i, "match_n %d", &match_n_vectors))
9253 else if (unformat (i, "match %U", unformat_classify_match,
9254 &match, skip_n_vectors, match_n_vectors))
9256 else if (unformat (i, "advance %d", &advance))
9258 else if (unformat (i, "table-index %d", &table_index))
9264 if (table_index == ~0)
9266 errmsg ("Table index required\n");
9270 if (is_add && match == 0)
9272 errmsg ("Match value required\n");
9276 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9278 mp->is_add = is_add;
9279 mp->table_index = ntohl (table_index);
9280 mp->hit_next_index = ntohl (hit_next_index);
9281 mp->opaque_index = ntohl (opaque_index);
9282 mp->advance = ntohl (advance);
9283 clib_memcpy (mp->match, match, vec_len (match));
9292 api_classify_set_interface_ip_table (vat_main_t * vam)
9294 unformat_input_t *i = vam->input;
9295 vl_api_classify_set_interface_ip_table_t *mp;
9298 int sw_if_index_set;
9299 u32 table_index = ~0;
9302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9304 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9305 sw_if_index_set = 1;
9306 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9307 sw_if_index_set = 1;
9308 else if (unformat (i, "table %d", &table_index))
9312 clib_warning ("parse error '%U'", format_unformat_error, i);
9317 if (sw_if_index_set == 0)
9319 errmsg ("missing interface name or sw_if_index\n");
9324 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9326 mp->sw_if_index = ntohl (sw_if_index);
9327 mp->table_index = ntohl (table_index);
9328 mp->is_ipv6 = is_ipv6;
9337 api_classify_set_interface_l2_tables (vat_main_t * vam)
9339 unformat_input_t *i = vam->input;
9340 vl_api_classify_set_interface_l2_tables_t *mp;
9343 int sw_if_index_set;
9344 u32 ip4_table_index = ~0;
9345 u32 ip6_table_index = ~0;
9346 u32 other_table_index = ~0;
9349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9351 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9352 sw_if_index_set = 1;
9353 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9354 sw_if_index_set = 1;
9355 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9357 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9359 else if (unformat (i, "other-table %d", &other_table_index))
9361 else if (unformat (i, "is-input %d", &is_input))
9365 clib_warning ("parse error '%U'", format_unformat_error, i);
9370 if (sw_if_index_set == 0)
9372 errmsg ("missing interface name or sw_if_index\n");
9377 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
9379 mp->sw_if_index = ntohl (sw_if_index);
9380 mp->ip4_table_index = ntohl (ip4_table_index);
9381 mp->ip6_table_index = ntohl (ip6_table_index);
9382 mp->other_table_index = ntohl (other_table_index);
9383 mp->is_input = (u8) is_input;
9392 api_set_ipfix_exporter (vat_main_t * vam)
9394 unformat_input_t *i = vam->input;
9395 vl_api_set_ipfix_exporter_t *mp;
9396 ip4_address_t collector_address;
9397 u8 collector_address_set = 0;
9398 u32 collector_port = ~0;
9399 ip4_address_t src_address;
9400 u8 src_address_set = 0;
9403 u32 template_interval = ~0;
9404 u8 udp_checksum = 0;
9407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9409 if (unformat (i, "collector_address %U", unformat_ip4_address,
9410 &collector_address))
9411 collector_address_set = 1;
9412 else if (unformat (i, "collector_port %d", &collector_port))
9414 else if (unformat (i, "src_address %U", unformat_ip4_address,
9416 src_address_set = 1;
9417 else if (unformat (i, "vrf_id %d", &vrf_id))
9419 else if (unformat (i, "path_mtu %d", &path_mtu))
9421 else if (unformat (i, "template_interval %d", &template_interval))
9423 else if (unformat (i, "udp_checksum"))
9429 if (collector_address_set == 0)
9431 errmsg ("collector_address required\n");
9435 if (src_address_set == 0)
9437 errmsg ("src_address required\n");
9441 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
9443 memcpy (mp->collector_address, collector_address.data,
9444 sizeof (collector_address.data));
9445 mp->collector_port = htons ((u16) collector_port);
9446 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9447 mp->vrf_id = htonl (vrf_id);
9448 mp->path_mtu = htonl (path_mtu);
9449 mp->template_interval = htonl (template_interval);
9450 mp->udp_checksum = udp_checksum;
9458 api_set_ipfix_classify_stream (vat_main_t * vam)
9460 unformat_input_t *i = vam->input;
9461 vl_api_set_ipfix_classify_stream_t *mp;
9463 u32 src_port = UDP_DST_PORT_ipfix;
9466 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9468 if (unformat (i, "domain %d", &domain_id))
9470 else if (unformat (i, "src_port %d", &src_port))
9474 errmsg ("unknown input `%U'", format_unformat_error, i);
9479 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
9481 mp->domain_id = htonl (domain_id);
9482 mp->src_port = htons ((u16) src_port);
9490 api_ipfix_classify_table_add_del (vat_main_t * vam)
9492 unformat_input_t *i = vam->input;
9493 vl_api_ipfix_classify_table_add_del_t *mp;
9495 u32 classify_table_index = ~0;
9497 u8 transport_protocol = 255;
9500 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9502 if (unformat (i, "add"))
9504 else if (unformat (i, "del"))
9506 else if (unformat (i, "table %d", &classify_table_index))
9508 else if (unformat (i, "ip4"))
9510 else if (unformat (i, "ip6"))
9512 else if (unformat (i, "tcp"))
9513 transport_protocol = 6;
9514 else if (unformat (i, "udp"))
9515 transport_protocol = 17;
9518 errmsg ("unknown input `%U'", format_unformat_error, i);
9525 errmsg ("expecting: add|del");
9528 if (classify_table_index == ~0)
9530 errmsg ("classifier table not specified");
9533 if (ip_version == 0)
9535 errmsg ("IP version not specified");
9539 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
9541 mp->is_add = is_add;
9542 mp->table_id = htonl (classify_table_index);
9543 mp->ip_version = ip_version;
9544 mp->transport_protocol = transport_protocol;
9552 api_get_node_index (vat_main_t * vam)
9554 unformat_input_t *i = vam->input;
9555 vl_api_get_node_index_t *mp;
9559 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9561 if (unformat (i, "node %s", &name))
9568 errmsg ("node name required\n");
9571 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9573 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9577 M (GET_NODE_INDEX, get_node_index);
9578 clib_memcpy (mp->node_name, name, vec_len (name));
9588 api_get_next_index (vat_main_t * vam)
9590 unformat_input_t *i = vam->input;
9591 vl_api_get_next_index_t *mp;
9593 u8 *node_name = 0, *next_node_name = 0;
9595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9597 if (unformat (i, "node-name %s", &node_name))
9599 else if (unformat (i, "next-node-name %s", &next_node_name))
9605 errmsg ("node name required\n");
9608 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9610 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9614 if (next_node_name == 0)
9616 errmsg ("next node name required\n");
9619 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9621 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
9625 M (GET_NEXT_INDEX, get_next_index);
9626 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9627 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9628 vec_free (node_name);
9629 vec_free (next_node_name);
9638 api_add_node_next (vat_main_t * vam)
9640 unformat_input_t *i = vam->input;
9641 vl_api_add_node_next_t *mp;
9646 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9648 if (unformat (i, "node %s", &name))
9650 else if (unformat (i, "next %s", &next))
9657 errmsg ("node name required\n");
9660 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9662 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9667 errmsg ("next node required\n");
9670 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9672 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
9676 M (ADD_NODE_NEXT, add_node_next);
9677 clib_memcpy (mp->node_name, name, vec_len (name));
9678 clib_memcpy (mp->next_name, next, vec_len (next));
9689 api_l2tpv3_create_tunnel (vat_main_t * vam)
9691 unformat_input_t *i = vam->input;
9692 ip6_address_t client_address, our_address;
9693 int client_address_set = 0;
9694 int our_address_set = 0;
9695 u32 local_session_id = 0;
9696 u32 remote_session_id = 0;
9697 u64 local_cookie = 0;
9698 u64 remote_cookie = 0;
9699 u8 l2_sublayer_present = 0;
9700 vl_api_l2tpv3_create_tunnel_t *mp;
9703 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9705 if (unformat (i, "client_address %U", unformat_ip6_address,
9707 client_address_set = 1;
9708 else if (unformat (i, "our_address %U", unformat_ip6_address,
9710 our_address_set = 1;
9711 else if (unformat (i, "local_session_id %d", &local_session_id))
9713 else if (unformat (i, "remote_session_id %d", &remote_session_id))
9715 else if (unformat (i, "local_cookie %lld", &local_cookie))
9717 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
9719 else if (unformat (i, "l2-sublayer-present"))
9720 l2_sublayer_present = 1;
9725 if (client_address_set == 0)
9727 errmsg ("client_address required\n");
9731 if (our_address_set == 0)
9733 errmsg ("our_address required\n");
9737 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9739 clib_memcpy (mp->client_address, client_address.as_u8,
9740 sizeof (mp->client_address));
9742 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9744 mp->local_session_id = ntohl (local_session_id);
9745 mp->remote_session_id = ntohl (remote_session_id);
9746 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9747 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9748 mp->l2_sublayer_present = l2_sublayer_present;
9758 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9760 unformat_input_t *i = vam->input;
9762 u8 sw_if_index_set = 0;
9763 u64 new_local_cookie = 0;
9764 u64 new_remote_cookie = 0;
9765 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9768 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9770 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9771 sw_if_index_set = 1;
9772 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9773 sw_if_index_set = 1;
9774 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9776 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9782 if (sw_if_index_set == 0)
9784 errmsg ("missing interface name or sw_if_index\n");
9788 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9790 mp->sw_if_index = ntohl (sw_if_index);
9791 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9792 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9801 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9803 unformat_input_t *i = vam->input;
9804 vl_api_l2tpv3_interface_enable_disable_t *mp;
9807 u8 sw_if_index_set = 0;
9808 u8 enable_disable = 1;
9810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9812 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9813 sw_if_index_set = 1;
9814 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9815 sw_if_index_set = 1;
9816 else if (unformat (i, "enable"))
9818 else if (unformat (i, "disable"))
9824 if (sw_if_index_set == 0)
9826 errmsg ("missing interface name or sw_if_index\n");
9830 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9832 mp->sw_if_index = ntohl (sw_if_index);
9833 mp->enable_disable = enable_disable;
9842 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9844 unformat_input_t *i = vam->input;
9845 vl_api_l2tpv3_set_lookup_key_t *mp;
9849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9851 if (unformat (i, "lookup_v6_src"))
9852 key = L2T_LOOKUP_SRC_ADDRESS;
9853 else if (unformat (i, "lookup_v6_dst"))
9854 key = L2T_LOOKUP_DST_ADDRESS;
9855 else if (unformat (i, "lookup_session_id"))
9856 key = L2T_LOOKUP_SESSION_ID;
9861 if (key == (u8) ~ 0)
9863 errmsg ("l2tp session lookup key unset\n");
9867 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9877 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9878 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9880 vat_main_t *vam = &vat_main;
9882 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9883 format_ip6_address, mp->our_address,
9884 format_ip6_address, mp->client_address,
9885 clib_net_to_host_u32 (mp->sw_if_index));
9888 " local cookies %016llx %016llx remote cookie %016llx\n",
9889 clib_net_to_host_u64 (mp->local_cookie[0]),
9890 clib_net_to_host_u64 (mp->local_cookie[1]),
9891 clib_net_to_host_u64 (mp->remote_cookie));
9893 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9894 clib_net_to_host_u32 (mp->local_session_id),
9895 clib_net_to_host_u32 (mp->remote_session_id));
9897 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9898 mp->l2_sublayer_present ? "preset" : "absent");
9902 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9903 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9905 vat_main_t *vam = &vat_main;
9906 vat_json_node_t *node = NULL;
9907 struct in6_addr addr;
9909 if (VAT_JSON_ARRAY != vam->json_tree.type)
9911 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9912 vat_json_init_array (&vam->json_tree);
9914 node = vat_json_array_add (&vam->json_tree);
9916 vat_json_init_object (node);
9918 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9919 vat_json_object_add_ip6 (node, "our_address", addr);
9920 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9921 vat_json_object_add_ip6 (node, "client_address", addr);
9923 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9924 vat_json_init_array (lc);
9925 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9926 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9927 vat_json_object_add_uint (node, "remote_cookie",
9928 clib_net_to_host_u64 (mp->remote_cookie));
9930 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9931 vat_json_object_add_uint (node, "local_session_id",
9932 clib_net_to_host_u32 (mp->local_session_id));
9933 vat_json_object_add_uint (node, "remote_session_id",
9934 clib_net_to_host_u32 (mp->remote_session_id));
9935 vat_json_object_add_string_copy (node, "l2_sublayer",
9936 mp->l2_sublayer_present ? (u8 *) "present"
9941 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
9943 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
9946 /* Get list of l2tpv3-tunnel interfaces */
9947 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
9950 /* Use a control ping for synchronization */
9952 vl_api_control_ping_t *mp;
9953 M (CONTROL_PING, control_ping);
9960 static void vl_api_sw_interface_tap_details_t_handler
9961 (vl_api_sw_interface_tap_details_t * mp)
9963 vat_main_t *vam = &vat_main;
9965 fformat (vam->ofp, "%-16s %d\n",
9966 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
9969 static void vl_api_sw_interface_tap_details_t_handler_json
9970 (vl_api_sw_interface_tap_details_t * mp)
9972 vat_main_t *vam = &vat_main;
9973 vat_json_node_t *node = NULL;
9975 if (VAT_JSON_ARRAY != vam->json_tree.type)
9977 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9978 vat_json_init_array (&vam->json_tree);
9980 node = vat_json_array_add (&vam->json_tree);
9982 vat_json_init_object (node);
9983 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
9984 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
9988 api_sw_interface_tap_dump (vat_main_t * vam)
9990 vl_api_sw_interface_tap_dump_t *mp;
9993 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
9994 /* Get list of tap interfaces */
9995 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
9998 /* Use a control ping for synchronization */
10000 vl_api_control_ping_t *mp;
10001 M (CONTROL_PING, control_ping);
10007 static uword unformat_vxlan_decap_next
10008 (unformat_input_t * input, va_list * args)
10010 u32 *result = va_arg (*args, u32 *);
10013 if (unformat (input, "drop"))
10014 *result = VXLAN_INPUT_NEXT_DROP;
10015 else if (unformat (input, "ip4"))
10016 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
10017 else if (unformat (input, "ip6"))
10018 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
10019 else if (unformat (input, "l2"))
10020 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10021 else if (unformat (input, "%d", &tmp))
10029 api_vxlan_add_del_tunnel (vat_main_t * vam)
10031 unformat_input_t *line_input = vam->input;
10032 vl_api_vxlan_add_del_tunnel_t *mp;
10034 ip4_address_t src4, dst4;
10035 ip6_address_t src6, dst6;
10037 u8 ipv4_set = 0, ipv6_set = 0;
10040 u32 encap_vrf_id = 0;
10041 u32 decap_next_index = ~0;
10044 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10046 if (unformat (line_input, "del"))
10048 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10053 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10058 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
10063 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
10068 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10070 else if (unformat (line_input, "decap-next %U",
10071 unformat_vxlan_decap_next, &decap_next_index))
10073 else if (unformat (line_input, "vni %d", &vni))
10077 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10084 errmsg ("tunnel src address not specified\n");
10089 errmsg ("tunnel dst address not specified\n");
10093 if (ipv4_set && ipv6_set)
10095 errmsg ("both IPv4 and IPv6 addresses specified");
10099 if ((vni == 0) || (vni >> 24))
10101 errmsg ("vni not specified or out of range\n");
10105 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10109 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
10110 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
10114 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10115 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10117 mp->encap_vrf_id = ntohl (encap_vrf_id);
10118 mp->decap_next_index = ntohl (decap_next_index);
10119 mp->vni = ntohl (vni);
10120 mp->is_add = is_add;
10121 mp->is_ipv6 = ipv6_set;
10129 static void vl_api_vxlan_tunnel_details_t_handler
10130 (vl_api_vxlan_tunnel_details_t * mp)
10132 vat_main_t *vam = &vat_main;
10134 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
10135 ntohl (mp->sw_if_index),
10136 format_ip46_address, &(mp->src_address[0]),
10138 format_ip46_address, &(mp->dst_address[0]),
10140 ntohl (mp->encap_vrf_id),
10141 ntohl (mp->decap_next_index), ntohl (mp->vni));
10144 static void vl_api_vxlan_tunnel_details_t_handler_json
10145 (vl_api_vxlan_tunnel_details_t * mp)
10147 vat_main_t *vam = &vat_main;
10148 vat_json_node_t *node = NULL;
10149 struct in_addr ip4;
10150 struct in6_addr ip6;
10152 if (VAT_JSON_ARRAY != vam->json_tree.type)
10154 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10155 vat_json_init_array (&vam->json_tree);
10157 node = vat_json_array_add (&vam->json_tree);
10159 vat_json_init_object (node);
10160 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10163 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
10164 vat_json_object_add_ip6 (node, "src_address", ip6);
10165 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
10166 vat_json_object_add_ip6 (node, "dst_address", ip6);
10170 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
10171 vat_json_object_add_ip4 (node, "src_address", ip4);
10172 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
10173 vat_json_object_add_ip4 (node, "dst_address", ip4);
10175 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10176 vat_json_object_add_uint (node, "decap_next_index",
10177 ntohl (mp->decap_next_index));
10178 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10179 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10183 api_vxlan_tunnel_dump (vat_main_t * vam)
10185 unformat_input_t *i = vam->input;
10186 vl_api_vxlan_tunnel_dump_t *mp;
10189 u8 sw_if_index_set = 0;
10191 /* Parse args required to build the message */
10192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10194 if (unformat (i, "sw_if_index %d", &sw_if_index))
10195 sw_if_index_set = 1;
10200 if (sw_if_index_set == 0)
10205 if (!vam->json_output)
10207 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
10208 "sw_if_index", "src_address", "dst_address",
10209 "encap_vrf_id", "decap_next_index", "vni");
10212 /* Get list of vxlan-tunnel interfaces */
10213 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10215 mp->sw_if_index = htonl (sw_if_index);
10219 /* Use a control ping for synchronization */
10221 vl_api_control_ping_t *mp;
10222 M (CONTROL_PING, control_ping);
10229 api_gre_add_del_tunnel (vat_main_t * vam)
10231 unformat_input_t *line_input = vam->input;
10232 vl_api_gre_add_del_tunnel_t *mp;
10234 ip4_address_t src4, dst4;
10239 u32 outer_fib_id = 0;
10241 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10243 if (unformat (line_input, "del"))
10245 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10247 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10249 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10251 else if (unformat (line_input, "teb"))
10255 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10262 errmsg ("tunnel src address not specified\n");
10267 errmsg ("tunnel dst address not specified\n");
10272 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10274 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10275 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10276 mp->outer_fib_id = ntohl (outer_fib_id);
10277 mp->is_add = is_add;
10286 static void vl_api_gre_tunnel_details_t_handler
10287 (vl_api_gre_tunnel_details_t * mp)
10289 vat_main_t *vam = &vat_main;
10291 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
10292 ntohl (mp->sw_if_index),
10293 format_ip4_address, &mp->src_address,
10294 format_ip4_address, &mp->dst_address,
10295 mp->teb, ntohl (mp->outer_fib_id));
10298 static void vl_api_gre_tunnel_details_t_handler_json
10299 (vl_api_gre_tunnel_details_t * mp)
10301 vat_main_t *vam = &vat_main;
10302 vat_json_node_t *node = NULL;
10303 struct in_addr ip4;
10305 if (VAT_JSON_ARRAY != vam->json_tree.type)
10307 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10308 vat_json_init_array (&vam->json_tree);
10310 node = vat_json_array_add (&vam->json_tree);
10312 vat_json_init_object (node);
10313 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10314 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10315 vat_json_object_add_ip4 (node, "src_address", ip4);
10316 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10317 vat_json_object_add_ip4 (node, "dst_address", ip4);
10318 vat_json_object_add_uint (node, "teb", mp->teb);
10319 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10323 api_gre_tunnel_dump (vat_main_t * vam)
10325 unformat_input_t *i = vam->input;
10326 vl_api_gre_tunnel_dump_t *mp;
10329 u8 sw_if_index_set = 0;
10331 /* Parse args required to build the message */
10332 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10334 if (unformat (i, "sw_if_index %d", &sw_if_index))
10335 sw_if_index_set = 1;
10340 if (sw_if_index_set == 0)
10345 if (!vam->json_output)
10347 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
10348 "sw_if_index", "src_address", "dst_address", "teb",
10352 /* Get list of gre-tunnel interfaces */
10353 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
10355 mp->sw_if_index = htonl (sw_if_index);
10359 /* Use a control ping for synchronization */
10361 vl_api_control_ping_t *mp;
10362 M (CONTROL_PING, control_ping);
10369 api_l2_fib_clear_table (vat_main_t * vam)
10371 // unformat_input_t * i = vam->input;
10372 vl_api_l2_fib_clear_table_t *mp;
10375 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
10384 api_l2_interface_efp_filter (vat_main_t * vam)
10386 unformat_input_t *i = vam->input;
10387 vl_api_l2_interface_efp_filter_t *mp;
10391 u8 sw_if_index_set = 0;
10393 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10395 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10396 sw_if_index_set = 1;
10397 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10398 sw_if_index_set = 1;
10399 else if (unformat (i, "enable"))
10401 else if (unformat (i, "disable"))
10405 clib_warning ("parse error '%U'", format_unformat_error, i);
10410 if (sw_if_index_set == 0)
10412 errmsg ("missing sw_if_index\n");
10416 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
10418 mp->sw_if_index = ntohl (sw_if_index);
10419 mp->enable_disable = enable;
10427 #define foreach_vtr_op \
10428 _("disable", L2_VTR_DISABLED) \
10429 _("push-1", L2_VTR_PUSH_1) \
10430 _("push-2", L2_VTR_PUSH_2) \
10431 _("pop-1", L2_VTR_POP_1) \
10432 _("pop-2", L2_VTR_POP_2) \
10433 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10434 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10435 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10436 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10439 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10441 unformat_input_t *i = vam->input;
10442 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10445 u8 sw_if_index_set = 0;
10448 u32 push_dot1q = 1;
10452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10454 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10455 sw_if_index_set = 1;
10456 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10457 sw_if_index_set = 1;
10458 else if (unformat (i, "vtr_op %d", &vtr_op))
10460 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10463 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10465 else if (unformat (i, "tag1 %d", &tag1))
10467 else if (unformat (i, "tag2 %d", &tag2))
10471 clib_warning ("parse error '%U'", format_unformat_error, i);
10476 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10478 errmsg ("missing vtr operation or sw_if_index\n");
10482 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
10483 mp->sw_if_index = ntohl (sw_if_index);
10484 mp->vtr_op = ntohl (vtr_op);
10485 mp->push_dot1q = ntohl (push_dot1q);
10486 mp->tag1 = ntohl (tag1);
10487 mp->tag2 = ntohl (tag2);
10496 api_create_vhost_user_if (vat_main_t * vam)
10498 unformat_input_t *i = vam->input;
10499 vl_api_create_vhost_user_if_t *mp;
10503 u8 file_name_set = 0;
10504 u32 custom_dev_instance = ~0;
10506 u8 use_custom_mac = 0;
10508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10510 if (unformat (i, "socket %s", &file_name))
10514 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10516 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10517 use_custom_mac = 1;
10518 else if (unformat (i, "server"))
10524 if (file_name_set == 0)
10526 errmsg ("missing socket file name\n");
10530 if (vec_len (file_name) > 255)
10532 errmsg ("socket file name too long\n");
10535 vec_add1 (file_name, 0);
10537 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
10539 mp->is_server = is_server;
10540 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10541 vec_free (file_name);
10542 if (custom_dev_instance != ~0)
10545 mp->custom_dev_instance = ntohl (custom_dev_instance);
10547 mp->use_custom_mac = use_custom_mac;
10548 clib_memcpy (mp->mac_address, hwaddr, 6);
10557 api_modify_vhost_user_if (vat_main_t * vam)
10559 unformat_input_t *i = vam->input;
10560 vl_api_modify_vhost_user_if_t *mp;
10564 u8 file_name_set = 0;
10565 u32 custom_dev_instance = ~0;
10566 u8 sw_if_index_set = 0;
10567 u32 sw_if_index = (u32) ~ 0;
10569 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10571 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10572 sw_if_index_set = 1;
10573 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10574 sw_if_index_set = 1;
10575 else if (unformat (i, "socket %s", &file_name))
10579 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10581 else if (unformat (i, "server"))
10587 if (sw_if_index_set == 0)
10589 errmsg ("missing sw_if_index or interface name\n");
10593 if (file_name_set == 0)
10595 errmsg ("missing socket file name\n");
10599 if (vec_len (file_name) > 255)
10601 errmsg ("socket file name too long\n");
10604 vec_add1 (file_name, 0);
10606 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
10608 mp->sw_if_index = ntohl (sw_if_index);
10609 mp->is_server = is_server;
10610 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10611 vec_free (file_name);
10612 if (custom_dev_instance != ~0)
10615 mp->custom_dev_instance = ntohl (custom_dev_instance);
10625 api_delete_vhost_user_if (vat_main_t * vam)
10627 unformat_input_t *i = vam->input;
10628 vl_api_delete_vhost_user_if_t *mp;
10630 u32 sw_if_index = ~0;
10631 u8 sw_if_index_set = 0;
10633 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10635 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10636 sw_if_index_set = 1;
10637 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10638 sw_if_index_set = 1;
10643 if (sw_if_index_set == 0)
10645 errmsg ("missing sw_if_index or interface name\n");
10650 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
10652 mp->sw_if_index = ntohl (sw_if_index);
10660 static void vl_api_sw_interface_vhost_user_details_t_handler
10661 (vl_api_sw_interface_vhost_user_details_t * mp)
10663 vat_main_t *vam = &vat_main;
10665 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
10666 (char *) mp->interface_name,
10667 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10668 clib_net_to_host_u64 (mp->features), mp->is_server,
10669 ntohl (mp->num_regions), (char *) mp->sock_filename);
10670 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
10673 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10674 (vl_api_sw_interface_vhost_user_details_t * mp)
10676 vat_main_t *vam = &vat_main;
10677 vat_json_node_t *node = NULL;
10679 if (VAT_JSON_ARRAY != vam->json_tree.type)
10681 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10682 vat_json_init_array (&vam->json_tree);
10684 node = vat_json_array_add (&vam->json_tree);
10686 vat_json_init_object (node);
10687 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10688 vat_json_object_add_string_copy (node, "interface_name",
10689 mp->interface_name);
10690 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10691 ntohl (mp->virtio_net_hdr_sz));
10692 vat_json_object_add_uint (node, "features",
10693 clib_net_to_host_u64 (mp->features));
10694 vat_json_object_add_uint (node, "is_server", mp->is_server);
10695 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10696 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10697 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10701 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10703 vl_api_sw_interface_vhost_user_dump_t *mp;
10706 "Interface name idx hdr_sz features server regions filename\n");
10708 /* Get list of vhost-user interfaces */
10709 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
10712 /* Use a control ping for synchronization */
10714 vl_api_control_ping_t *mp;
10715 M (CONTROL_PING, control_ping);
10722 api_show_version (vat_main_t * vam)
10724 vl_api_show_version_t *mp;
10727 M (SHOW_VERSION, show_version);
10737 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10739 unformat_input_t *line_input = vam->input;
10740 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10742 ip4_address_t local4, remote4;
10743 ip6_address_t local6, remote6;
10745 u8 ipv4_set = 0, ipv6_set = 0;
10748 u32 encap_vrf_id = 0;
10749 u32 decap_vrf_id = 0;
10754 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10756 if (unformat (line_input, "del"))
10758 else if (unformat (line_input, "local %U",
10759 unformat_ip4_address, &local4))
10764 else if (unformat (line_input, "remote %U",
10765 unformat_ip4_address, &remote4))
10770 else if (unformat (line_input, "local %U",
10771 unformat_ip6_address, &local6))
10776 else if (unformat (line_input, "remote %U",
10777 unformat_ip6_address, &remote6))
10782 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10784 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10786 else if (unformat (line_input, "vni %d", &vni))
10788 else if (unformat (line_input, "next-ip4"))
10790 else if (unformat (line_input, "next-ip6"))
10792 else if (unformat (line_input, "next-ethernet"))
10794 else if (unformat (line_input, "next-nsh"))
10798 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10803 if (local_set == 0)
10805 errmsg ("tunnel local address not specified\n");
10808 if (remote_set == 0)
10810 errmsg ("tunnel remote address not specified\n");
10813 if (ipv4_set && ipv6_set)
10815 errmsg ("both IPv4 and IPv6 addresses specified");
10821 errmsg ("vni not specified\n");
10825 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10830 clib_memcpy (&mp->local, &local6, sizeof (local6));
10831 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10835 clib_memcpy (&mp->local, &local4, sizeof (local4));
10836 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10839 mp->encap_vrf_id = ntohl (encap_vrf_id);
10840 mp->decap_vrf_id = ntohl (decap_vrf_id);
10841 mp->protocol = ntohl (protocol);
10842 mp->vni = ntohl (vni);
10843 mp->is_add = is_add;
10844 mp->is_ipv6 = ipv6_set;
10852 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10853 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10855 vat_main_t *vam = &vat_main;
10857 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10858 ntohl (mp->sw_if_index),
10859 format_ip46_address, &(mp->local[0]),
10860 format_ip46_address, &(mp->remote[0]),
10862 ntohl (mp->protocol),
10863 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10866 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10867 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10869 vat_main_t *vam = &vat_main;
10870 vat_json_node_t *node = NULL;
10871 struct in_addr ip4;
10872 struct in6_addr ip6;
10874 if (VAT_JSON_ARRAY != vam->json_tree.type)
10876 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10877 vat_json_init_array (&vam->json_tree);
10879 node = vat_json_array_add (&vam->json_tree);
10881 vat_json_init_object (node);
10882 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10885 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10886 vat_json_object_add_ip6 (node, "local", ip6);
10887 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10888 vat_json_object_add_ip6 (node, "remote", ip6);
10892 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10893 vat_json_object_add_ip4 (node, "local", ip4);
10894 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10895 vat_json_object_add_ip4 (node, "remote", ip4);
10897 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10898 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10899 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10900 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10901 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10905 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10907 unformat_input_t *i = vam->input;
10908 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10911 u8 sw_if_index_set = 0;
10913 /* Parse args required to build the message */
10914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10916 if (unformat (i, "sw_if_index %d", &sw_if_index))
10917 sw_if_index_set = 1;
10922 if (sw_if_index_set == 0)
10927 if (!vam->json_output)
10929 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10930 "sw_if_index", "local", "remote", "vni",
10931 "protocol", "encap_vrf_id", "decap_vrf_id");
10934 /* Get list of vxlan-tunnel interfaces */
10935 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10937 mp->sw_if_index = htonl (sw_if_index);
10941 /* Use a control ping for synchronization */
10943 vl_api_control_ping_t *mp;
10944 M (CONTROL_PING, control_ping);
10951 format_l2_fib_mac_address (u8 * s, va_list * args)
10953 u8 *a = va_arg (*args, u8 *);
10955 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
10956 a[2], a[3], a[4], a[5], a[6], a[7]);
10959 static void vl_api_l2_fib_table_entry_t_handler
10960 (vl_api_l2_fib_table_entry_t * mp)
10962 vat_main_t *vam = &vat_main;
10964 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
10966 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
10967 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
10971 static void vl_api_l2_fib_table_entry_t_handler_json
10972 (vl_api_l2_fib_table_entry_t * mp)
10974 vat_main_t *vam = &vat_main;
10975 vat_json_node_t *node = NULL;
10977 if (VAT_JSON_ARRAY != vam->json_tree.type)
10979 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10980 vat_json_init_array (&vam->json_tree);
10982 node = vat_json_array_add (&vam->json_tree);
10984 vat_json_init_object (node);
10985 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
10986 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
10987 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10988 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
10989 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
10990 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
10994 api_l2_fib_table_dump (vat_main_t * vam)
10996 unformat_input_t *i = vam->input;
10997 vl_api_l2_fib_table_dump_t *mp;
11002 /* Parse args required to build the message */
11003 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11005 if (unformat (i, "bd_id %d", &bd_id))
11011 if (bd_id_set == 0)
11013 errmsg ("missing bridge domain\n");
11018 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
11020 /* Get list of l2 fib entries */
11021 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11023 mp->bd_id = ntohl (bd_id);
11026 /* Use a control ping for synchronization */
11028 vl_api_control_ping_t *mp;
11029 M (CONTROL_PING, control_ping);
11037 api_interface_name_renumber (vat_main_t * vam)
11039 unformat_input_t *line_input = vam->input;
11040 vl_api_interface_name_renumber_t *mp;
11041 u32 sw_if_index = ~0;
11043 u32 new_show_dev_instance = ~0;
11045 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11047 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
11050 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11052 else if (unformat (line_input, "new_show_dev_instance %d",
11053 &new_show_dev_instance))
11059 if (sw_if_index == ~0)
11061 errmsg ("missing interface name or sw_if_index\n");
11065 if (new_show_dev_instance == ~0)
11067 errmsg ("missing new_show_dev_instance\n");
11071 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11073 mp->sw_if_index = ntohl (sw_if_index);
11074 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11081 api_want_ip4_arp_events (vat_main_t * vam)
11083 unformat_input_t *line_input = vam->input;
11084 vl_api_want_ip4_arp_events_t *mp;
11086 ip4_address_t address;
11087 int address_set = 0;
11088 u32 enable_disable = 1;
11090 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11092 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11094 else if (unformat (line_input, "del"))
11095 enable_disable = 0;
11100 if (address_set == 0)
11102 errmsg ("missing addresses\n");
11106 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11107 mp->enable_disable = enable_disable;
11108 mp->pid = getpid ();
11109 mp->address = address.as_u32;
11116 api_want_ip6_nd_events (vat_main_t * vam)
11118 unformat_input_t *line_input = vam->input;
11119 vl_api_want_ip6_nd_events_t *mp;
11121 ip6_address_t address;
11122 int address_set = 0;
11123 u32 enable_disable = 1;
11125 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11127 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11129 else if (unformat (line_input, "del"))
11130 enable_disable = 0;
11135 if (address_set == 0)
11137 errmsg ("missing addresses\n");
11141 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11142 mp->enable_disable = enable_disable;
11143 mp->pid = getpid ();
11144 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11151 api_input_acl_set_interface (vat_main_t * vam)
11153 unformat_input_t *i = vam->input;
11154 vl_api_input_acl_set_interface_t *mp;
11157 int sw_if_index_set;
11158 u32 ip4_table_index = ~0;
11159 u32 ip6_table_index = ~0;
11160 u32 l2_table_index = ~0;
11163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11165 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11166 sw_if_index_set = 1;
11167 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11168 sw_if_index_set = 1;
11169 else if (unformat (i, "del"))
11171 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11173 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11175 else if (unformat (i, "l2-table %d", &l2_table_index))
11179 clib_warning ("parse error '%U'", format_unformat_error, i);
11184 if (sw_if_index_set == 0)
11186 errmsg ("missing interface name or sw_if_index\n");
11190 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11192 mp->sw_if_index = ntohl (sw_if_index);
11193 mp->ip4_table_index = ntohl (ip4_table_index);
11194 mp->ip6_table_index = ntohl (ip6_table_index);
11195 mp->l2_table_index = ntohl (l2_table_index);
11196 mp->is_add = is_add;
11205 api_ip_address_dump (vat_main_t * vam)
11207 unformat_input_t *i = vam->input;
11208 vl_api_ip_address_dump_t *mp;
11209 u32 sw_if_index = ~0;
11210 u8 sw_if_index_set = 0;
11215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11217 if (unformat (i, "sw_if_index %d", &sw_if_index))
11218 sw_if_index_set = 1;
11219 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11220 sw_if_index_set = 1;
11221 else if (unformat (i, "ipv4"))
11223 else if (unformat (i, "ipv6"))
11229 if (ipv4_set && ipv6_set)
11231 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11235 if ((!ipv4_set) && (!ipv6_set))
11237 errmsg ("no ipv4 nor ipv6 flag set\n");
11241 if (sw_if_index_set == 0)
11243 errmsg ("missing interface name or sw_if_index\n");
11247 vam->current_sw_if_index = sw_if_index;
11248 vam->is_ipv6 = ipv6_set;
11250 M (IP_ADDRESS_DUMP, ip_address_dump);
11251 mp->sw_if_index = ntohl (sw_if_index);
11252 mp->is_ipv6 = ipv6_set;
11255 /* Use a control ping for synchronization */
11257 vl_api_control_ping_t *mp;
11258 M (CONTROL_PING, control_ping);
11265 api_ip_dump (vat_main_t * vam)
11267 vl_api_ip_dump_t *mp;
11268 unformat_input_t *in = vam->input;
11275 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11277 if (unformat (in, "ipv4"))
11279 else if (unformat (in, "ipv6"))
11285 if (ipv4_set && ipv6_set)
11287 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11291 if ((!ipv4_set) && (!ipv6_set))
11293 errmsg ("no ipv4 nor ipv6 flag set\n");
11297 is_ipv6 = ipv6_set;
11298 vam->is_ipv6 = is_ipv6;
11300 /* free old data */
11301 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11303 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11305 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11307 M (IP_DUMP, ip_dump);
11308 mp->is_ipv6 = ipv6_set;
11311 /* Use a control ping for synchronization */
11313 vl_api_control_ping_t *mp;
11314 M (CONTROL_PING, control_ping);
11321 api_ipsec_spd_add_del (vat_main_t * vam)
11324 unformat_input_t *i = vam->input;
11325 vl_api_ipsec_spd_add_del_t *mp;
11330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11332 if (unformat (i, "spd_id %d", &spd_id))
11334 else if (unformat (i, "del"))
11338 clib_warning ("parse error '%U'", format_unformat_error, i);
11344 errmsg ("spd_id must be set\n");
11348 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
11350 mp->spd_id = ntohl (spd_id);
11351 mp->is_add = is_add;
11358 clib_warning ("unsupported (no dpdk)");
11364 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11367 unformat_input_t *i = vam->input;
11368 vl_api_ipsec_interface_add_del_spd_t *mp;
11371 u8 sw_if_index_set = 0;
11372 u32 spd_id = (u32) ~ 0;
11375 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11377 if (unformat (i, "del"))
11379 else if (unformat (i, "spd_id %d", &spd_id))
11381 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11382 sw_if_index_set = 1;
11383 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11384 sw_if_index_set = 1;
11387 clib_warning ("parse error '%U'", format_unformat_error, i);
11393 if (spd_id == (u32) ~ 0)
11395 errmsg ("spd_id must be set\n");
11399 if (sw_if_index_set == 0)
11401 errmsg ("missing interface name or sw_if_index\n");
11405 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
11407 mp->spd_id = ntohl (spd_id);
11408 mp->sw_if_index = ntohl (sw_if_index);
11409 mp->is_add = is_add;
11416 clib_warning ("unsupported (no dpdk)");
11422 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11425 unformat_input_t *i = vam->input;
11426 vl_api_ipsec_spd_add_del_entry_t *mp;
11428 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11429 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11431 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11432 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11433 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11434 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11436 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11437 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11438 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11439 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11440 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11441 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11445 if (unformat (i, "del"))
11447 if (unformat (i, "outbound"))
11449 if (unformat (i, "inbound"))
11451 else if (unformat (i, "spd_id %d", &spd_id))
11453 else if (unformat (i, "sa_id %d", &sa_id))
11455 else if (unformat (i, "priority %d", &priority))
11457 else if (unformat (i, "protocol %d", &protocol))
11459 else if (unformat (i, "lport_start %d", &lport_start))
11461 else if (unformat (i, "lport_stop %d", &lport_stop))
11463 else if (unformat (i, "rport_start %d", &rport_start))
11465 else if (unformat (i, "rport_stop %d", &rport_stop))
11469 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11475 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11482 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11488 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11495 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11501 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
11508 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
11514 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
11520 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11522 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11524 clib_warning ("unsupported action: 'resolve'");
11530 clib_warning ("parse error '%U'", format_unformat_error, i);
11536 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
11538 mp->spd_id = ntohl (spd_id);
11539 mp->priority = ntohl (priority);
11540 mp->is_outbound = is_outbound;
11542 mp->is_ipv6 = is_ipv6;
11543 if (is_ipv6 || is_ip_any)
11545 clib_memcpy (mp->remote_address_start, &raddr6_start,
11546 sizeof (ip6_address_t));
11547 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
11548 sizeof (ip6_address_t));
11549 clib_memcpy (mp->local_address_start, &laddr6_start,
11550 sizeof (ip6_address_t));
11551 clib_memcpy (mp->local_address_stop, &laddr6_stop,
11552 sizeof (ip6_address_t));
11556 clib_memcpy (mp->remote_address_start, &raddr4_start,
11557 sizeof (ip4_address_t));
11558 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
11559 sizeof (ip4_address_t));
11560 clib_memcpy (mp->local_address_start, &laddr4_start,
11561 sizeof (ip4_address_t));
11562 clib_memcpy (mp->local_address_stop, &laddr4_stop,
11563 sizeof (ip4_address_t));
11565 mp->protocol = (u8) protocol;
11566 mp->local_port_start = ntohs ((u16) lport_start);
11567 mp->local_port_stop = ntohs ((u16) lport_stop);
11568 mp->remote_port_start = ntohs ((u16) rport_start);
11569 mp->remote_port_stop = ntohs ((u16) rport_stop);
11570 mp->policy = (u8) policy;
11571 mp->sa_id = ntohl (sa_id);
11572 mp->is_add = is_add;
11573 mp->is_ip_any = is_ip_any;
11579 clib_warning ("unsupported (no dpdk)");
11585 api_ipsec_sad_add_del_entry (vat_main_t * vam)
11588 unformat_input_t *i = vam->input;
11589 vl_api_ipsec_sad_add_del_entry_t *mp;
11591 u32 sad_id = 0, spi = 0;
11592 u8 *ck = 0, *ik = 0;
11595 u8 protocol = IPSEC_PROTOCOL_AH;
11596 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
11597 u32 crypto_alg = 0, integ_alg = 0;
11598 ip4_address_t tun_src4;
11599 ip4_address_t tun_dst4;
11600 ip6_address_t tun_src6;
11601 ip6_address_t tun_dst6;
11603 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11605 if (unformat (i, "del"))
11607 else if (unformat (i, "sad_id %d", &sad_id))
11609 else if (unformat (i, "spi %d", &spi))
11611 else if (unformat (i, "esp"))
11612 protocol = IPSEC_PROTOCOL_ESP;
11613 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
11616 is_tunnel_ipv6 = 0;
11618 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
11621 is_tunnel_ipv6 = 0;
11623 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
11626 is_tunnel_ipv6 = 1;
11628 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
11631 is_tunnel_ipv6 = 1;
11635 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
11637 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
11638 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
11640 clib_warning ("unsupported crypto-alg: '%U'",
11641 format_ipsec_crypto_alg, crypto_alg);
11645 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11649 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
11651 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
11652 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
11654 clib_warning ("unsupported integ-alg: '%U'",
11655 format_ipsec_integ_alg, integ_alg);
11659 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11663 clib_warning ("parse error '%U'", format_unformat_error, i);
11669 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
11671 mp->sad_id = ntohl (sad_id);
11672 mp->is_add = is_add;
11673 mp->protocol = protocol;
11674 mp->spi = ntohl (spi);
11675 mp->is_tunnel = is_tunnel;
11676 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
11677 mp->crypto_algorithm = crypto_alg;
11678 mp->integrity_algorithm = integ_alg;
11679 mp->crypto_key_length = vec_len (ck);
11680 mp->integrity_key_length = vec_len (ik);
11682 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11683 mp->crypto_key_length = sizeof (mp->crypto_key);
11685 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11686 mp->integrity_key_length = sizeof (mp->integrity_key);
11689 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11691 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11695 if (is_tunnel_ipv6)
11697 clib_memcpy (mp->tunnel_src_address, &tun_src6,
11698 sizeof (ip6_address_t));
11699 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
11700 sizeof (ip6_address_t));
11704 clib_memcpy (mp->tunnel_src_address, &tun_src4,
11705 sizeof (ip4_address_t));
11706 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
11707 sizeof (ip4_address_t));
11716 clib_warning ("unsupported (no dpdk)");
11722 api_ipsec_sa_set_key (vat_main_t * vam)
11725 unformat_input_t *i = vam->input;
11726 vl_api_ipsec_sa_set_key_t *mp;
11729 u8 *ck = 0, *ik = 0;
11731 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11733 if (unformat (i, "sa_id %d", &sa_id))
11735 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11737 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11741 clib_warning ("parse error '%U'", format_unformat_error, i);
11746 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
11748 mp->sa_id = ntohl (sa_id);
11749 mp->crypto_key_length = vec_len (ck);
11750 mp->integrity_key_length = vec_len (ik);
11752 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11753 mp->crypto_key_length = sizeof (mp->crypto_key);
11755 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11756 mp->integrity_key_length = sizeof (mp->integrity_key);
11759 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11761 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11768 clib_warning ("unsupported (no dpdk)");
11774 api_ikev2_profile_add_del (vat_main_t * vam)
11777 unformat_input_t *i = vam->input;
11778 vl_api_ikev2_profile_add_del_t *mp;
11783 const char *valid_chars = "a-zA-Z0-9_";
11785 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11787 if (unformat (i, "del"))
11789 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11790 vec_add1 (name, 0);
11793 errmsg ("parse error '%U'", format_unformat_error, i);
11798 if (!vec_len (name))
11800 errmsg ("profile name must be specified");
11804 if (vec_len (name) > 64)
11806 errmsg ("profile name too long");
11810 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11812 clib_memcpy (mp->name, name, vec_len (name));
11813 mp->is_add = is_add;
11821 clib_warning ("unsupported (no dpdk)");
11827 api_ikev2_profile_set_auth (vat_main_t * vam)
11830 unformat_input_t *i = vam->input;
11831 vl_api_ikev2_profile_set_auth_t *mp;
11835 u32 auth_method = 0;
11838 const char *valid_chars = "a-zA-Z0-9_";
11840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11842 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11843 vec_add1 (name, 0);
11844 else if (unformat (i, "auth_method %U",
11845 unformat_ikev2_auth_method, &auth_method))
11847 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11849 else if (unformat (i, "auth_data %v", &data))
11853 errmsg ("parse error '%U'", format_unformat_error, i);
11858 if (!vec_len (name))
11860 errmsg ("profile name must be specified");
11864 if (vec_len (name) > 64)
11866 errmsg ("profile name too long");
11870 if (!vec_len (data))
11872 errmsg ("auth_data must be specified");
11878 errmsg ("auth_method must be specified");
11882 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11884 mp->is_hex = is_hex;
11885 mp->auth_method = (u8) auth_method;
11886 mp->data_len = vec_len (data);
11887 clib_memcpy (mp->name, name, vec_len (name));
11888 clib_memcpy (mp->data, data, vec_len (data));
11897 clib_warning ("unsupported (no dpdk)");
11903 api_ikev2_profile_set_id (vat_main_t * vam)
11906 unformat_input_t *i = vam->input;
11907 vl_api_ikev2_profile_set_id_t *mp;
11915 const char *valid_chars = "a-zA-Z0-9_";
11917 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11919 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11920 vec_add1 (name, 0);
11921 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11923 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11925 data = vec_new (u8, 4);
11926 clib_memcpy (data, ip4.as_u8, 4);
11928 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11930 else if (unformat (i, "id_data %v", &data))
11932 else if (unformat (i, "local"))
11934 else if (unformat (i, "remote"))
11938 errmsg ("parse error '%U'", format_unformat_error, i);
11943 if (!vec_len (name))
11945 errmsg ("profile name must be specified");
11949 if (vec_len (name) > 64)
11951 errmsg ("profile name too long");
11955 if (!vec_len (data))
11957 errmsg ("id_data must be specified");
11963 errmsg ("id_type must be specified");
11967 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
11969 mp->is_local = is_local;
11970 mp->id_type = (u8) id_type;
11971 mp->data_len = vec_len (data);
11972 clib_memcpy (mp->name, name, vec_len (name));
11973 clib_memcpy (mp->data, data, vec_len (data));
11982 clib_warning ("unsupported (no dpdk)");
11988 api_ikev2_profile_set_ts (vat_main_t * vam)
11991 unformat_input_t *i = vam->input;
11992 vl_api_ikev2_profile_set_ts_t *mp;
11996 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
11997 ip4_address_t start_addr, end_addr;
11999 const char *valid_chars = "a-zA-Z0-9_";
12001 start_addr.as_u32 = 0;
12002 end_addr.as_u32 = (u32) ~ 0;
12004 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12006 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12007 vec_add1 (name, 0);
12008 else if (unformat (i, "protocol %d", &proto))
12010 else if (unformat (i, "start_port %d", &start_port))
12012 else if (unformat (i, "end_port %d", &end_port))
12015 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12017 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12019 else if (unformat (i, "local"))
12021 else if (unformat (i, "remote"))
12025 errmsg ("parse error '%U'", format_unformat_error, i);
12030 if (!vec_len (name))
12032 errmsg ("profile name must be specified");
12036 if (vec_len (name) > 64)
12038 errmsg ("profile name too long");
12042 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12044 mp->is_local = is_local;
12045 mp->proto = (u8) proto;
12046 mp->start_port = (u16) start_port;
12047 mp->end_port = (u16) end_port;
12048 mp->start_addr = start_addr.as_u32;
12049 mp->end_addr = end_addr.as_u32;
12050 clib_memcpy (mp->name, name, vec_len (name));
12058 clib_warning ("unsupported (no dpdk)");
12064 api_ikev2_set_local_key (vat_main_t * vam)
12067 unformat_input_t *i = vam->input;
12068 vl_api_ikev2_set_local_key_t *mp;
12072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12074 if (unformat (i, "file %v", &file))
12075 vec_add1 (file, 0);
12078 errmsg ("parse error '%U'", format_unformat_error, i);
12083 if (!vec_len (file))
12085 errmsg ("RSA key file must be specified");
12089 if (vec_len (file) > 256)
12091 errmsg ("file name too long");
12095 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12097 clib_memcpy (mp->key_file, file, vec_len (file));
12105 clib_warning ("unsupported (no dpdk)");
12114 api_map_add_domain (vat_main_t * vam)
12116 unformat_input_t *i = vam->input;
12117 vl_api_map_add_domain_t *mp;
12120 ip4_address_t ip4_prefix;
12121 ip6_address_t ip6_prefix;
12122 ip6_address_t ip6_src;
12123 u32 num_m_args = 0;
12124 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12125 0, psid_length = 0;
12126 u8 is_translation = 0;
12128 u32 ip6_src_len = 128;
12130 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12132 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12133 &ip4_prefix, &ip4_prefix_len))
12135 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12136 &ip6_prefix, &ip6_prefix_len))
12140 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12143 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12145 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12147 else if (unformat (i, "psid-offset %d", &psid_offset))
12149 else if (unformat (i, "psid-len %d", &psid_length))
12151 else if (unformat (i, "mtu %d", &mtu))
12153 else if (unformat (i, "map-t"))
12154 is_translation = 1;
12157 clib_warning ("parse error '%U'", format_unformat_error, i);
12162 if (num_m_args < 3)
12164 errmsg ("mandatory argument(s) missing\n");
12168 /* Construct the API message */
12169 M (MAP_ADD_DOMAIN, map_add_domain);
12171 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12172 mp->ip4_prefix_len = ip4_prefix_len;
12174 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12175 mp->ip6_prefix_len = ip6_prefix_len;
12177 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12178 mp->ip6_src_prefix_len = ip6_src_len;
12180 mp->ea_bits_len = ea_bits_len;
12181 mp->psid_offset = psid_offset;
12182 mp->psid_length = psid_length;
12183 mp->is_translation = is_translation;
12184 mp->mtu = htons (mtu);
12189 /* Wait for a reply, return good/bad news */
12194 api_map_del_domain (vat_main_t * vam)
12196 unformat_input_t *i = vam->input;
12197 vl_api_map_del_domain_t *mp;
12200 u32 num_m_args = 0;
12203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12205 if (unformat (i, "index %d", &index))
12209 clib_warning ("parse error '%U'", format_unformat_error, i);
12214 if (num_m_args != 1)
12216 errmsg ("mandatory argument(s) missing\n");
12220 /* Construct the API message */
12221 M (MAP_DEL_DOMAIN, map_del_domain);
12223 mp->index = ntohl (index);
12228 /* Wait for a reply, return good/bad news */
12233 api_map_add_del_rule (vat_main_t * vam)
12235 unformat_input_t *i = vam->input;
12236 vl_api_map_add_del_rule_t *mp;
12239 ip6_address_t ip6_dst;
12240 u32 num_m_args = 0, index, psid = 0;
12242 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12244 if (unformat (i, "index %d", &index))
12246 else if (unformat (i, "psid %d", &psid))
12248 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12250 else if (unformat (i, "del"))
12256 clib_warning ("parse error '%U'", format_unformat_error, i);
12261 /* Construct the API message */
12262 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12264 mp->index = ntohl (index);
12265 mp->is_add = is_add;
12266 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12267 mp->psid = ntohs (psid);
12272 /* Wait for a reply, return good/bad news */
12277 api_map_domain_dump (vat_main_t * vam)
12279 vl_api_map_domain_dump_t *mp;
12282 /* Construct the API message */
12283 M (MAP_DOMAIN_DUMP, map_domain_dump);
12288 /* Use a control ping for synchronization */
12290 vl_api_control_ping_t *mp;
12291 M (CONTROL_PING, control_ping);
12298 api_map_rule_dump (vat_main_t * vam)
12300 unformat_input_t *i = vam->input;
12301 vl_api_map_rule_dump_t *mp;
12303 u32 domain_index = ~0;
12305 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12307 if (unformat (i, "index %u", &domain_index))
12313 if (domain_index == ~0)
12315 clib_warning ("parse error: domain index expected");
12319 /* Construct the API message */
12320 M (MAP_RULE_DUMP, map_rule_dump);
12322 mp->domain_index = htonl (domain_index);
12327 /* Use a control ping for synchronization */
12329 vl_api_control_ping_t *mp;
12330 M (CONTROL_PING, control_ping);
12336 static void vl_api_map_add_domain_reply_t_handler
12337 (vl_api_map_add_domain_reply_t * mp)
12339 vat_main_t *vam = &vat_main;
12340 i32 retval = ntohl (mp->retval);
12342 if (vam->async_mode)
12344 vam->async_errors += (retval < 0);
12348 vam->retval = retval;
12349 vam->result_ready = 1;
12353 static void vl_api_map_add_domain_reply_t_handler_json
12354 (vl_api_map_add_domain_reply_t * mp)
12356 vat_main_t *vam = &vat_main;
12357 vat_json_node_t node;
12359 vat_json_init_object (&node);
12360 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12361 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12363 vat_json_print (vam->ofp, &node);
12364 vat_json_free (&node);
12366 vam->retval = ntohl (mp->retval);
12367 vam->result_ready = 1;
12371 api_get_first_msg_id (vat_main_t * vam)
12373 vl_api_get_first_msg_id_t *mp;
12375 unformat_input_t *i = vam->input;
12379 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12381 if (unformat (i, "client %s", &name))
12389 errmsg ("missing client name\n");
12392 vec_add1 (name, 0);
12394 if (vec_len (name) > 63)
12396 errmsg ("client name too long\n");
12400 M (GET_FIRST_MSG_ID, get_first_msg_id);
12401 clib_memcpy (mp->name, name, vec_len (name));
12409 api_cop_interface_enable_disable (vat_main_t * vam)
12411 unformat_input_t *line_input = vam->input;
12412 vl_api_cop_interface_enable_disable_t *mp;
12414 u32 sw_if_index = ~0;
12415 u8 enable_disable = 1;
12417 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12419 if (unformat (line_input, "disable"))
12420 enable_disable = 0;
12421 if (unformat (line_input, "enable"))
12422 enable_disable = 1;
12423 else if (unformat (line_input, "%U", unformat_sw_if_index,
12424 vam, &sw_if_index))
12426 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12432 if (sw_if_index == ~0)
12434 errmsg ("missing interface name or sw_if_index\n");
12438 /* Construct the API message */
12439 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
12440 mp->sw_if_index = ntohl (sw_if_index);
12441 mp->enable_disable = enable_disable;
12445 /* Wait for the reply */
12450 api_cop_whitelist_enable_disable (vat_main_t * vam)
12452 unformat_input_t *line_input = vam->input;
12453 vl_api_cop_whitelist_enable_disable_t *mp;
12455 u32 sw_if_index = ~0;
12456 u8 ip4 = 0, ip6 = 0, default_cop = 0;
12459 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12461 if (unformat (line_input, "ip4"))
12463 else if (unformat (line_input, "ip6"))
12465 else if (unformat (line_input, "default"))
12467 else if (unformat (line_input, "%U", unformat_sw_if_index,
12468 vam, &sw_if_index))
12470 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12472 else if (unformat (line_input, "fib-id %d", &fib_id))
12478 if (sw_if_index == ~0)
12480 errmsg ("missing interface name or sw_if_index\n");
12484 /* Construct the API message */
12485 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
12486 mp->sw_if_index = ntohl (sw_if_index);
12487 mp->fib_id = ntohl (fib_id);
12490 mp->default_cop = default_cop;
12494 /* Wait for the reply */
12499 api_get_node_graph (vat_main_t * vam)
12501 vl_api_get_node_graph_t *mp;
12504 M (GET_NODE_GRAPH, get_node_graph);
12508 /* Wait for the reply */
12513 /** Used for parsing LISP eids */
12514 typedef CLIB_PACKED(struct{
12515 u8 addr[16]; /**< eid address */
12516 u32 len; /**< prefix length if IP */
12517 u8 type; /**< type of eid */
12522 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
12524 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
12526 memset (a, 0, sizeof (a[0]));
12528 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
12530 a->type = 0; /* ipv4 type */
12532 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
12534 a->type = 1; /* ipv6 type */
12536 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
12538 a->type = 2; /* mac type */
12545 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
12554 lisp_eid_size_vat (u8 type)
12569 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
12571 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
12575 /** Used for transferring locators via VPP API */
12576 typedef CLIB_PACKED(struct
12578 u32 sw_if_index; /**< locator sw_if_index */
12579 u8 priority; /**< locator priority */
12580 u8 weight; /**< locator weight */
12585 api_lisp_add_del_locator_set (vat_main_t * vam)
12587 unformat_input_t *input = vam->input;
12588 vl_api_lisp_add_del_locator_set_t *mp;
12591 u8 *locator_set_name = NULL;
12592 u8 locator_set_name_set = 0;
12593 ls_locator_t locator, *locators = 0;
12594 u32 sw_if_index, priority, weight;
12597 /* Parse args required to build the message */
12598 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12600 if (unformat (input, "del"))
12604 else if (unformat (input, "locator-set %s", &locator_set_name))
12606 locator_set_name_set = 1;
12608 else if (unformat (input, "sw_if_index %u p %u w %u",
12609 &sw_if_index, &priority, &weight))
12611 locator.sw_if_index = htonl (sw_if_index);
12612 locator.priority = priority;
12613 locator.weight = weight;
12614 vec_add1 (locators, locator);
12616 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
12617 vam, &sw_if_index, &priority, &weight))
12619 locator.sw_if_index = htonl (sw_if_index);
12620 locator.priority = priority;
12621 locator.weight = weight;
12622 vec_add1 (locators, locator);
12628 if (locator_set_name_set == 0)
12630 errmsg ("missing locator-set name");
12631 vec_free (locators);
12635 if (vec_len (locator_set_name) > 64)
12637 errmsg ("locator-set name too long\n");
12638 vec_free (locator_set_name);
12639 vec_free (locators);
12642 vec_add1 (locator_set_name, 0);
12644 data_len = sizeof (ls_locator_t) * vec_len (locators);
12646 /* Construct the API message */
12647 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
12649 mp->is_add = is_add;
12650 clib_memcpy (mp->locator_set_name, locator_set_name,
12651 vec_len (locator_set_name));
12652 vec_free (locator_set_name);
12654 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
12656 clib_memcpy (mp->locators, locators, data_len);
12657 vec_free (locators);
12662 /* Wait for a reply... */
12670 api_lisp_add_del_locator (vat_main_t * vam)
12672 unformat_input_t *input = vam->input;
12673 vl_api_lisp_add_del_locator_t *mp;
12675 u32 tmp_if_index = ~0;
12676 u32 sw_if_index = ~0;
12677 u8 sw_if_index_set = 0;
12678 u8 sw_if_index_if_name_set = 0;
12680 u8 priority_set = 0;
12684 u8 *locator_set_name = NULL;
12685 u8 locator_set_name_set = 0;
12687 /* Parse args required to build the message */
12688 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12690 if (unformat (input, "del"))
12694 else if (unformat (input, "locator-set %s", &locator_set_name))
12696 locator_set_name_set = 1;
12698 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
12701 sw_if_index_if_name_set = 1;
12702 sw_if_index = tmp_if_index;
12704 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
12706 sw_if_index_set = 1;
12707 sw_if_index = tmp_if_index;
12709 else if (unformat (input, "p %d", &priority))
12713 else if (unformat (input, "w %d", &weight))
12721 if (locator_set_name_set == 0)
12723 errmsg ("missing locator-set name");
12727 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12729 errmsg ("missing sw_if_index");
12730 vec_free (locator_set_name);
12734 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
12736 errmsg ("cannot use both params interface name and sw_if_index");
12737 vec_free (locator_set_name);
12741 if (priority_set == 0)
12743 errmsg ("missing locator-set priority\n");
12744 vec_free (locator_set_name);
12748 if (weight_set == 0)
12750 errmsg ("missing locator-set weight\n");
12751 vec_free (locator_set_name);
12755 if (vec_len (locator_set_name) > 64)
12757 errmsg ("locator-set name too long\n");
12758 vec_free (locator_set_name);
12761 vec_add1 (locator_set_name, 0);
12763 /* Construct the API message */
12764 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
12766 mp->is_add = is_add;
12767 mp->sw_if_index = ntohl (sw_if_index);
12768 mp->priority = priority;
12769 mp->weight = weight;
12770 clib_memcpy (mp->locator_set_name, locator_set_name,
12771 vec_len (locator_set_name));
12772 vec_free (locator_set_name);
12777 /* Wait for a reply... */
12785 api_lisp_add_del_local_eid (vat_main_t * vam)
12787 unformat_input_t *input = vam->input;
12788 vl_api_lisp_add_del_local_eid_t *mp;
12792 lisp_eid_vat_t _eid, *eid = &_eid;
12793 u8 *locator_set_name = 0;
12794 u8 locator_set_name_set = 0;
12797 /* Parse args required to build the message */
12798 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12800 if (unformat (input, "del"))
12804 else if (unformat (input, "vni %d", &vni))
12808 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12812 else if (unformat (input, "locator-set %s", &locator_set_name))
12814 locator_set_name_set = 1;
12820 if (locator_set_name_set == 0)
12822 errmsg ("missing locator-set name\n");
12828 errmsg ("EID address not set!");
12829 vec_free (locator_set_name);
12833 if (vec_len (locator_set_name) > 64)
12835 errmsg ("locator-set name too long\n");
12836 vec_free (locator_set_name);
12839 vec_add1 (locator_set_name, 0);
12841 /* Construct the API message */
12842 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12844 mp->is_add = is_add;
12845 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12846 mp->eid_type = eid->type;
12847 mp->prefix_len = eid->len;
12848 mp->vni = clib_host_to_net_u32 (vni);
12849 clib_memcpy (mp->locator_set_name, locator_set_name,
12850 vec_len (locator_set_name));
12852 vec_free (locator_set_name);
12857 /* Wait for a reply... */
12865 /** Used for transferring locators via VPP API */
12866 typedef CLIB_PACKED(struct
12868 u8 is_ip4; /**< is locator an IPv4 address? */
12869 u8 priority; /**< locator priority */
12870 u8 weight; /**< locator weight */
12871 u8 addr[16]; /**< IPv4/IPv6 address */
12876 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12878 unformat_input_t *input = vam->input;
12879 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12882 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12883 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12884 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12885 u32 action = ~0, p, w;
12886 ip4_address_t rmt_rloc4, lcl_rloc4;
12887 ip6_address_t rmt_rloc6, lcl_rloc6;
12888 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12890 memset (&rloc, 0, sizeof (rloc));
12892 /* Parse args required to build the message */
12893 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12895 if (unformat (input, "del"))
12899 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12903 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12907 else if (unformat (input, "p %d w %d", &p, &w))
12911 errmsg ("No RLOC configured for setting priority/weight!");
12914 curr_rloc->priority = p;
12915 curr_rloc->weight = w;
12917 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12918 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12922 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12923 rloc.priority = rloc.weight = 0;
12924 vec_add1 (lcl_locs, rloc);
12926 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12927 vec_add1 (rmt_locs, rloc);
12928 /* priority and weight saved in rmt loc */
12929 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12931 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12932 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12935 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12936 rloc.priority = rloc.weight = 0;
12937 vec_add1 (lcl_locs, rloc);
12939 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12940 vec_add1 (rmt_locs, rloc);
12941 /* priority and weight saved in rmt loc */
12942 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12944 else if (unformat (input, "action %d", &action))
12950 clib_warning ("parse error '%U'", format_unformat_error, input);
12957 errmsg ("remote eid addresses not set\n");
12961 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
12963 errmsg ("eid types don't match\n");
12967 if (0 == rmt_locs && (u32) ~ 0 == action)
12969 errmsg ("action not set for negative mapping\n");
12973 /* Construct the API message */
12974 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
12976 mp->is_add = is_add;
12977 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
12978 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
12979 mp->eid_type = rmt_eid->type;
12980 mp->rmt_len = rmt_eid->len;
12981 mp->lcl_len = lcl_eid->len;
12982 mp->action = action;
12984 if (0 != rmt_locs && 0 != lcl_locs)
12986 mp->loc_num = vec_len (rmt_locs);
12987 clib_memcpy (mp->lcl_locs, lcl_locs,
12988 (sizeof (rloc_t) * vec_len (lcl_locs)));
12989 clib_memcpy (mp->rmt_locs, rmt_locs,
12990 (sizeof (rloc_t) * vec_len (rmt_locs)));
12992 vec_free (lcl_locs);
12993 vec_free (rmt_locs);
12998 /* Wait for a reply... */
13006 api_lisp_add_del_map_resolver (vat_main_t * vam)
13008 unformat_input_t *input = vam->input;
13009 vl_api_lisp_add_del_map_resolver_t *mp;
13014 ip4_address_t ipv4;
13015 ip6_address_t ipv6;
13017 /* Parse args required to build the message */
13018 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13020 if (unformat (input, "del"))
13024 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13028 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13036 if (ipv4_set && ipv6_set)
13038 errmsg ("both eid v4 and v6 addresses set\n");
13042 if (!ipv4_set && !ipv6_set)
13044 errmsg ("eid addresses not set\n");
13048 /* Construct the API message */
13049 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13051 mp->is_add = is_add;
13055 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13060 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13066 /* Wait for a reply... */
13074 api_lisp_gpe_enable_disable (vat_main_t * vam)
13076 unformat_input_t *input = vam->input;
13077 vl_api_lisp_gpe_enable_disable_t *mp;
13082 /* Parse args required to build the message */
13083 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13085 if (unformat (input, "enable"))
13090 else if (unformat (input, "disable"))
13101 errmsg ("Value not set\n");
13105 /* Construct the API message */
13106 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13113 /* Wait for a reply... */
13121 api_lisp_enable_disable (vat_main_t * vam)
13123 unformat_input_t *input = vam->input;
13124 vl_api_lisp_enable_disable_t *mp;
13129 /* Parse args required to build the message */
13130 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13132 if (unformat (input, "enable"))
13137 else if (unformat (input, "disable"))
13147 errmsg ("Value not set\n");
13151 /* Construct the API message */
13152 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
13159 /* Wait for a reply... */
13167 api_show_lisp_map_request_mode (vat_main_t * vam)
13170 vl_api_show_lisp_map_request_mode_t *mp;
13172 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
13177 /* wait for reply */
13184 api_lisp_map_request_mode (vat_main_t * vam)
13187 unformat_input_t *input = vam->input;
13188 vl_api_lisp_map_request_mode_t *mp;
13191 /* Parse args required to build the message */
13192 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13194 if (unformat (input, "dst-only"))
13196 else if (unformat (input, "src-dst"))
13200 errmsg ("parse error '%U'", format_unformat_error, input);
13205 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
13212 /* wait for reply */
13220 * Enable/disable LISP proxy ITR.
13222 * @param vam vpp API test context
13223 * @return return code
13226 api_lisp_pitr_set_locator_set (vat_main_t * vam)
13229 u8 ls_name_set = 0;
13230 unformat_input_t *input = vam->input;
13231 vl_api_lisp_pitr_set_locator_set_t *mp;
13235 /* Parse args required to build the message */
13236 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13238 if (unformat (input, "del"))
13240 else if (unformat (input, "locator-set %s", &ls_name))
13244 errmsg ("parse error '%U'", format_unformat_error, input);
13251 errmsg ("locator-set name not set!");
13255 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
13257 mp->is_add = is_add;
13258 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
13259 vec_free (ls_name);
13264 /* wait for reply */
13272 api_show_lisp_pitr (vat_main_t * vam)
13274 vl_api_show_lisp_pitr_t *mp;
13277 if (!vam->json_output)
13279 fformat (vam->ofp, "%=20s\n", "lisp status:");
13282 M (SHOW_LISP_PITR, show_lisp_pitr);
13286 /* Wait for a reply... */
13294 * Add/delete mapping between vni and vrf
13297 api_lisp_eid_table_add_del_map (vat_main_t * vam)
13300 unformat_input_t *input = vam->input;
13301 vl_api_lisp_eid_table_add_del_map_t *mp;
13302 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
13303 u32 vni, vrf, bd_index;
13305 /* Parse args required to build the message */
13306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13308 if (unformat (input, "del"))
13310 else if (unformat (input, "vrf %d", &vrf))
13312 else if (unformat (input, "bd_index %d", &bd_index))
13314 else if (unformat (input, "vni %d", &vni))
13320 if (!vni_set || (!vrf_set && !bd_index_set))
13322 errmsg ("missing arguments!");
13326 if (vrf_set && bd_index_set)
13328 errmsg ("error: both vrf and bd entered!");
13332 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
13334 mp->is_add = is_add;
13335 mp->vni = htonl (vni);
13336 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
13337 mp->is_l2 = bd_index_set;
13342 /* wait for reply */
13350 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
13352 u32 *action = va_arg (*args, u32 *);
13355 if (unformat (input, "%s", &s))
13357 if (!strcmp ((char *) s, "no-action"))
13359 else if (!strcmp ((char *) s, "natively-forward"))
13361 else if (!strcmp ((char *) s, "send-map-request"))
13363 else if (!strcmp ((char *) s, "drop"))
13367 clib_warning ("invalid action: '%s'", s);
13379 * Add/del remote mapping to/from LISP control plane
13381 * @param vam vpp API test context
13382 * @return return code
13385 api_lisp_add_del_remote_mapping (vat_main_t * vam)
13387 unformat_input_t *input = vam->input;
13388 vl_api_lisp_add_del_remote_mapping_t *mp;
13391 lisp_eid_vat_t _eid, *eid = &_eid;
13392 lisp_eid_vat_t _seid, *seid = &_seid;
13393 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
13394 u32 action = ~0, p, w, data_len;
13395 ip4_address_t rloc4;
13396 ip6_address_t rloc6;
13397 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
13399 memset (&rloc, 0, sizeof (rloc));
13401 /* Parse args required to build the message */
13402 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13404 if (unformat (input, "del-all"))
13408 else if (unformat (input, "del"))
13412 else if (unformat (input, "add"))
13416 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13420 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
13424 else if (unformat (input, "vni %d", &vni))
13428 else if (unformat (input, "p %d w %d", &p, &w))
13432 errmsg ("No RLOC configured for setting priority/weight!");
13435 curr_rloc->priority = p;
13436 curr_rloc->weight = w;
13438 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
13441 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
13442 vec_add1 (rlocs, rloc);
13443 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13445 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
13448 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
13449 vec_add1 (rlocs, rloc);
13450 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13452 else if (unformat (input, "action %U",
13453 unformat_negative_mapping_action, &action))
13459 clib_warning ("parse error '%U'", format_unformat_error, input);
13466 errmsg ("missing params!");
13470 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
13472 errmsg ("no action set for negative map-reply!");
13476 data_len = vec_len (rlocs) * sizeof (rloc_t);
13478 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
13479 mp->is_add = is_add;
13480 mp->vni = htonl (vni);
13481 mp->action = (u8) action;
13482 mp->is_src_dst = seid_set;
13483 mp->eid_len = eid->len;
13484 mp->seid_len = seid->len;
13485 mp->del_all = del_all;
13486 mp->eid_type = eid->type;
13487 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13488 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
13490 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
13491 clib_memcpy (mp->rlocs, rlocs, data_len);
13497 /* Wait for a reply... */
13505 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
13506 * forwarding entries in data-plane accordingly.
13508 * @param vam vpp API test context
13509 * @return return code
13512 api_lisp_add_del_adjacency (vat_main_t * vam)
13514 unformat_input_t *input = vam->input;
13515 vl_api_lisp_add_del_adjacency_t *mp;
13518 ip4_address_t leid4, reid4;
13519 ip6_address_t leid6, reid6;
13520 u8 reid_mac[6] = { 0 };
13521 u8 leid_mac[6] = { 0 };
13522 u8 reid_type, leid_type;
13523 u32 leid_len = 0, reid_len = 0, len;
13526 leid_type = reid_type = (u8) ~ 0;
13528 /* Parse args required to build the message */
13529 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13531 if (unformat (input, "del"))
13535 else if (unformat (input, "add"))
13539 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
13542 reid_type = 0; /* ipv4 */
13545 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
13548 reid_type = 1; /* ipv6 */
13551 else if (unformat (input, "reid %U", unformat_ethernet_address,
13554 reid_type = 2; /* mac */
13556 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
13559 leid_type = 0; /* ipv4 */
13562 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
13565 leid_type = 1; /* ipv6 */
13568 else if (unformat (input, "leid %U", unformat_ethernet_address,
13571 leid_type = 2; /* mac */
13573 else if (unformat (input, "vni %d", &vni))
13579 errmsg ("parse error '%U'", format_unformat_error, input);
13584 if ((u8) ~ 0 == reid_type)
13586 errmsg ("missing params!");
13590 if (leid_type != reid_type)
13592 errmsg ("remote and local EIDs are of different types!");
13596 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
13597 mp->is_add = is_add;
13598 mp->vni = htonl (vni);
13599 mp->leid_len = leid_len;
13600 mp->reid_len = reid_len;
13601 mp->eid_type = reid_type;
13603 switch (mp->eid_type)
13606 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
13607 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
13610 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
13611 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
13614 clib_memcpy (mp->leid, leid_mac, 6);
13615 clib_memcpy (mp->reid, reid_mac, 6);
13618 errmsg ("unknown EID type %d!", mp->eid_type);
13625 /* Wait for a reply... */
13633 api_lisp_gpe_add_del_iface (vat_main_t * vam)
13635 unformat_input_t *input = vam->input;
13636 vl_api_lisp_gpe_add_del_iface_t *mp;
13638 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
13639 u32 dp_table = 0, vni = 0;
13641 /* Parse args required to build the message */
13642 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13644 if (unformat (input, "up"))
13649 else if (unformat (input, "down"))
13654 else if (unformat (input, "table_id %d", &dp_table))
13658 else if (unformat (input, "bd_id %d", &dp_table))
13663 else if (unformat (input, "vni %d", &vni))
13671 if (action_set == 0)
13673 errmsg ("Action not set\n");
13676 if (dp_table_set == 0 || vni_set == 0)
13678 errmsg ("vni and dp_table must be set\n");
13682 /* Construct the API message */
13683 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
13685 mp->is_add = is_add;
13686 mp->dp_table = dp_table;
13693 /* Wait for a reply... */
13701 * Add/del map request itr rlocs from LISP control plane and updates
13703 * @param vam vpp API test context
13704 * @return return code
13707 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
13709 unformat_input_t *input = vam->input;
13710 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
13712 u8 *locator_set_name = 0;
13713 u8 locator_set_name_set = 0;
13716 /* Parse args required to build the message */
13717 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13719 if (unformat (input, "del"))
13723 else if (unformat (input, "%_%v%_", &locator_set_name))
13725 locator_set_name_set = 1;
13729 clib_warning ("parse error '%U'", format_unformat_error, input);
13734 if (is_add && !locator_set_name_set)
13736 errmsg ("itr-rloc is not set!");
13740 if (is_add && vec_len (locator_set_name) > 64)
13742 errmsg ("itr-rloc locator-set name too long\n");
13743 vec_free (locator_set_name);
13747 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
13748 mp->is_add = is_add;
13751 clib_memcpy (mp->locator_set_name, locator_set_name,
13752 vec_len (locator_set_name));
13756 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
13758 vec_free (locator_set_name);
13763 /* Wait for a reply... */
13771 api_lisp_locator_dump (vat_main_t * vam)
13773 unformat_input_t *input = vam->input;
13774 vl_api_lisp_locator_dump_t *mp;
13776 u8 is_index_set = 0, is_name_set = 0;
13780 /* Parse args required to build the message */
13781 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13783 if (unformat (input, "ls_name %_%v%_", &ls_name))
13787 else if (unformat (input, "ls_index %d", &ls_index))
13793 errmsg ("parse error '%U'", format_unformat_error, input);
13798 if (!is_index_set && !is_name_set)
13800 errmsg ("error: expected one of index or name!\n");
13804 if (is_index_set && is_name_set)
13806 errmsg ("error: only one param expected!\n");
13810 if (vec_len (ls_name) > 62)
13812 errmsg ("error: locator set name too long!");
13816 if (!vam->json_output)
13818 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
13822 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
13823 mp->is_index_set = is_index_set;
13826 mp->ls_index = clib_host_to_net_u32 (ls_index);
13829 vec_add1 (ls_name, 0);
13830 strncpy ((char *) mp->ls_name, (char *) ls_name,
13831 sizeof (mp->ls_name) - 1);
13837 /* Use a control ping for synchronization */
13839 vl_api_control_ping_t *mp;
13840 M (CONTROL_PING, control_ping);
13843 /* Wait for a reply... */
13851 api_lisp_locator_set_dump (vat_main_t * vam)
13853 vl_api_lisp_locator_set_dump_t *mp;
13854 unformat_input_t *input = vam->input;
13858 /* Parse args required to build the message */
13859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13861 if (unformat (input, "local"))
13865 else if (unformat (input, "remote"))
13871 errmsg ("parse error '%U'", format_unformat_error, input);
13876 if (!vam->json_output)
13878 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13881 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13883 mp->filter = filter;
13888 /* Use a control ping for synchronization */
13890 vl_api_control_ping_t *mp;
13891 M (CONTROL_PING, control_ping);
13894 /* Wait for a reply... */
13902 api_lisp_eid_table_map_dump (vat_main_t * vam)
13906 unformat_input_t *input = vam->input;
13907 vl_api_lisp_eid_table_map_dump_t *mp;
13910 /* Parse args required to build the message */
13911 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13913 if (unformat (input, "l2"))
13918 else if (unformat (input, "l3"))
13925 errmsg ("parse error '%U'", format_unformat_error, input);
13932 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13936 if (!vam->json_output)
13938 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13941 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13947 /* Use a control ping for synchronization */
13949 vl_api_control_ping_t *mp;
13950 M (CONTROL_PING, control_ping);
13953 /* Wait for a reply... */
13961 api_lisp_eid_table_vni_dump (vat_main_t * vam)
13963 vl_api_lisp_eid_table_vni_dump_t *mp;
13966 if (!vam->json_output)
13968 fformat (vam->ofp, "VNI\n");
13971 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
13976 /* Use a control ping for synchronization */
13978 vl_api_control_ping_t *mp;
13979 M (CONTROL_PING, control_ping);
13982 /* Wait for a reply... */
13990 api_lisp_eid_table_dump (vat_main_t * vam)
13992 unformat_input_t *i = vam->input;
13993 vl_api_lisp_eid_table_dump_t *mp;
13995 struct in_addr ip4;
13996 struct in6_addr ip6;
13998 u8 eid_type = ~0, eid_set = 0;
13999 u32 prefix_length = ~0, t, vni = 0;
14002 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14004 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14010 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14016 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14021 else if (unformat (i, "vni %d", &t))
14025 else if (unformat (i, "local"))
14029 else if (unformat (i, "remote"))
14035 errmsg ("parse error '%U'", format_unformat_error, i);
14040 if (!vam->json_output)
14042 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
14043 "ls_index", "ttl", "authoritative");
14046 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14048 mp->filter = filter;
14052 mp->vni = htonl (vni);
14053 mp->eid_type = eid_type;
14057 mp->prefix_length = prefix_length;
14058 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14061 mp->prefix_length = prefix_length;
14062 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14065 clib_memcpy (mp->eid, mac, sizeof (mac));
14068 errmsg ("unknown EID type %d!", eid_type);
14076 /* Use a control ping for synchronization */
14078 vl_api_control_ping_t *mp;
14079 M (CONTROL_PING, control_ping);
14083 /* Wait for a reply... */
14091 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
14093 vl_api_lisp_gpe_tunnel_dump_t *mp;
14096 if (!vam->json_output)
14098 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
14099 "%=16s%=16s%=16s%=16s%=16s\n",
14100 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
14101 "Decap next", "Lisp version", "Flags", "Next protocol",
14102 "ver_res", "res", "iid");
14105 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
14109 /* Use a control ping for synchronization */
14111 vl_api_control_ping_t *mp;
14112 M (CONTROL_PING, control_ping);
14115 /* Wait for a reply... */
14123 api_lisp_adjacencies_get (vat_main_t * vam)
14125 unformat_input_t *i = vam->input;
14126 vl_api_lisp_adjacencies_get_t *mp;
14131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14133 if (unformat (i, "vni %d", &vni))
14139 errmsg ("parse error '%U'\n", format_unformat_error, i);
14146 errmsg ("vni not set!\n");
14150 if (!vam->json_output)
14152 fformat (vam->ofp, "%s %40s\n", "leid", "reid");
14155 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
14156 mp->vni = clib_host_to_net_u32 (vni);
14161 /* Wait for a reply... */
14169 api_lisp_map_resolver_dump (vat_main_t * vam)
14171 vl_api_lisp_map_resolver_dump_t *mp;
14174 if (!vam->json_output)
14176 fformat (vam->ofp, "%=20s\n", "Map resolver");
14179 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
14183 /* Use a control ping for synchronization */
14185 vl_api_control_ping_t *mp;
14186 M (CONTROL_PING, control_ping);
14189 /* Wait for a reply... */
14197 api_show_lisp_status (vat_main_t * vam)
14199 vl_api_show_lisp_status_t *mp;
14202 if (!vam->json_output)
14204 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
14207 M (SHOW_LISP_STATUS, show_lisp_status);
14210 /* Wait for a reply... */
14218 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
14220 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
14223 if (!vam->json_output)
14225 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
14228 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
14231 /* Wait for a reply... */
14239 api_af_packet_create (vat_main_t * vam)
14241 unformat_input_t *i = vam->input;
14242 vl_api_af_packet_create_t *mp;
14244 u8 *host_if_name = 0;
14246 u8 random_hw_addr = 1;
14248 memset (hw_addr, 0, sizeof (hw_addr));
14250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14252 if (unformat (i, "name %s", &host_if_name))
14253 vec_add1 (host_if_name, 0);
14254 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14255 random_hw_addr = 0;
14260 if (!vec_len (host_if_name))
14262 errmsg ("host-interface name must be specified");
14266 if (vec_len (host_if_name) > 64)
14268 errmsg ("host-interface name too long");
14272 M (AF_PACKET_CREATE, af_packet_create);
14274 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14275 clib_memcpy (mp->hw_addr, hw_addr, 6);
14276 mp->use_random_hw_addr = random_hw_addr;
14277 vec_free (host_if_name);
14280 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
14286 api_af_packet_delete (vat_main_t * vam)
14288 unformat_input_t *i = vam->input;
14289 vl_api_af_packet_delete_t *mp;
14291 u8 *host_if_name = 0;
14293 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14295 if (unformat (i, "name %s", &host_if_name))
14296 vec_add1 (host_if_name, 0);
14301 if (!vec_len (host_if_name))
14303 errmsg ("host-interface name must be specified");
14307 if (vec_len (host_if_name) > 64)
14309 errmsg ("host-interface name too long");
14313 M (AF_PACKET_DELETE, af_packet_delete);
14315 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14316 vec_free (host_if_name);
14325 api_policer_add_del (vat_main_t * vam)
14327 unformat_input_t *i = vam->input;
14328 vl_api_policer_add_del_t *mp;
14339 u8 color_aware = 0;
14340 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
14342 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
14343 conform_action.dscp = 0;
14344 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
14345 exceed_action.dscp = 0;
14346 violate_action.action_type = SSE2_QOS_ACTION_DROP;
14347 violate_action.dscp = 0;
14349 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14351 if (unformat (i, "del"))
14353 else if (unformat (i, "name %s", &name))
14354 vec_add1 (name, 0);
14355 else if (unformat (i, "cir %u", &cir))
14357 else if (unformat (i, "eir %u", &eir))
14359 else if (unformat (i, "cb %u", &cb))
14361 else if (unformat (i, "eb %u", &eb))
14363 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
14366 else if (unformat (i, "round_type %U", unformat_policer_round_type,
14369 else if (unformat (i, "type %U", unformat_policer_type, &type))
14371 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
14374 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
14377 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
14380 else if (unformat (i, "color-aware"))
14386 if (!vec_len (name))
14388 errmsg ("policer name must be specified");
14392 if (vec_len (name) > 64)
14394 errmsg ("policer name too long");
14398 M (POLICER_ADD_DEL, policer_add_del);
14400 clib_memcpy (mp->name, name, vec_len (name));
14402 mp->is_add = is_add;
14407 mp->rate_type = rate_type;
14408 mp->round_type = round_type;
14410 mp->conform_action_type = conform_action.action_type;
14411 mp->conform_dscp = conform_action.dscp;
14412 mp->exceed_action_type = exceed_action.action_type;
14413 mp->exceed_dscp = exceed_action.dscp;
14414 mp->violate_action_type = violate_action.action_type;
14415 mp->violate_dscp = violate_action.dscp;
14416 mp->color_aware = color_aware;
14425 api_policer_dump (vat_main_t * vam)
14427 unformat_input_t *i = vam->input;
14428 vl_api_policer_dump_t *mp;
14430 u8 *match_name = 0;
14431 u8 match_name_valid = 0;
14433 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14435 if (unformat (i, "name %s", &match_name))
14437 vec_add1 (match_name, 0);
14438 match_name_valid = 1;
14444 M (POLICER_DUMP, policer_dump);
14445 mp->match_name_valid = match_name_valid;
14446 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
14447 vec_free (match_name);
14451 /* Use a control ping for synchronization */
14453 vl_api_control_ping_t *mp;
14454 M (CONTROL_PING, control_ping);
14457 /* Wait for a reply... */
14465 api_policer_classify_set_interface (vat_main_t * vam)
14467 unformat_input_t *i = vam->input;
14468 vl_api_policer_classify_set_interface_t *mp;
14471 int sw_if_index_set;
14472 u32 ip4_table_index = ~0;
14473 u32 ip6_table_index = ~0;
14474 u32 l2_table_index = ~0;
14477 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14479 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
14480 sw_if_index_set = 1;
14481 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14482 sw_if_index_set = 1;
14483 else if (unformat (i, "del"))
14485 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14487 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14489 else if (unformat (i, "l2-table %d", &l2_table_index))
14493 clib_warning ("parse error '%U'", format_unformat_error, i);
14498 if (sw_if_index_set == 0)
14500 errmsg ("missing interface name or sw_if_index\n");
14504 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
14506 mp->sw_if_index = ntohl (sw_if_index);
14507 mp->ip4_table_index = ntohl (ip4_table_index);
14508 mp->ip6_table_index = ntohl (ip6_table_index);
14509 mp->l2_table_index = ntohl (l2_table_index);
14510 mp->is_add = is_add;
14519 api_policer_classify_dump (vat_main_t * vam)
14521 unformat_input_t *i = vam->input;
14522 vl_api_policer_classify_dump_t *mp;
14524 u8 type = POLICER_CLASSIFY_N_TABLES;
14526 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
14530 errmsg ("classify table type must be specified\n");
14534 if (!vam->json_output)
14536 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14539 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14544 /* Use a control ping for synchronization */
14546 vl_api_control_ping_t *mp;
14547 M (CONTROL_PING, control_ping);
14550 /* Wait for a reply... */
14558 api_netmap_create (vat_main_t * vam)
14560 unformat_input_t *i = vam->input;
14561 vl_api_netmap_create_t *mp;
14565 u8 random_hw_addr = 1;
14569 memset (hw_addr, 0, sizeof (hw_addr));
14571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14573 if (unformat (i, "name %s", &if_name))
14574 vec_add1 (if_name, 0);
14575 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14576 random_hw_addr = 0;
14577 else if (unformat (i, "pipe"))
14579 else if (unformat (i, "master"))
14581 else if (unformat (i, "slave"))
14587 if (!vec_len (if_name))
14589 errmsg ("interface name must be specified");
14593 if (vec_len (if_name) > 64)
14595 errmsg ("interface name too long");
14599 M (NETMAP_CREATE, netmap_create);
14601 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14602 clib_memcpy (mp->hw_addr, hw_addr, 6);
14603 mp->use_random_hw_addr = random_hw_addr;
14604 mp->is_pipe = is_pipe;
14605 mp->is_master = is_master;
14606 vec_free (if_name);
14615 api_netmap_delete (vat_main_t * vam)
14617 unformat_input_t *i = vam->input;
14618 vl_api_netmap_delete_t *mp;
14622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14624 if (unformat (i, "name %s", &if_name))
14625 vec_add1 (if_name, 0);
14630 if (!vec_len (if_name))
14632 errmsg ("interface name must be specified");
14636 if (vec_len (if_name) > 64)
14638 errmsg ("interface name too long");
14642 M (NETMAP_DELETE, netmap_delete);
14644 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14645 vec_free (if_name);
14653 static void vl_api_mpls_eth_tunnel_details_t_handler
14654 (vl_api_mpls_eth_tunnel_details_t * mp)
14656 vat_main_t *vam = &vat_main;
14658 i32 len = ntohl (mp->nlabels);
14660 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14661 ntohl (mp->tunnel_index),
14662 format_ethernet_address, &mp->tunnel_dst_mac,
14663 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14664 for (i = 0; i < len; i++)
14666 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14668 fformat (vam->ofp, "\n");
14669 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14670 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14673 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14674 (vl_api_mpls_eth_tunnel_details_t * mp)
14676 vat_main_t *vam = &vat_main;
14677 vat_json_node_t *node = NULL;
14678 struct in_addr ip4;
14680 i32 len = ntohl (mp->nlabels);
14682 if (VAT_JSON_ARRAY != vam->json_tree.type)
14684 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14685 vat_json_init_array (&vam->json_tree);
14687 node = vat_json_array_add (&vam->json_tree);
14689 vat_json_init_object (node);
14690 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14691 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14692 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14693 vat_json_object_add_uint (node, "inner_fib_index",
14694 ntohl (mp->inner_fib_index));
14695 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14696 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14697 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14698 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14699 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14700 format (0, "%U", format_ethernet_address,
14701 &mp->tunnel_dst_mac));
14702 vat_json_object_add_uint (node, "tx_sw_if_index",
14703 ntohl (mp->tx_sw_if_index));
14704 vat_json_object_add_uint (node, "label_count", len);
14705 for (i = 0; i < len; i++)
14707 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14712 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14714 vl_api_mpls_eth_tunnel_dump_t *mp;
14718 /* Parse args required to build the message */
14719 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14721 if (!unformat (vam->input, "tunnel_index %d", &index))
14728 fformat (vam->ofp, " tunnel_index %d\n", index);
14730 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14731 mp->tunnel_index = htonl (index);
14734 /* Use a control ping for synchronization */
14736 vl_api_control_ping_t *mp;
14737 M (CONTROL_PING, control_ping);
14743 static void vl_api_mpls_fib_encap_details_t_handler
14744 (vl_api_mpls_fib_encap_details_t * mp)
14746 vat_main_t *vam = &vat_main;
14748 i32 len = ntohl (mp->nlabels);
14750 fformat (vam->ofp, "table %d, dest %U, label ",
14751 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14752 for (i = 0; i < len; i++)
14754 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14756 fformat (vam->ofp, "\n");
14759 static void vl_api_mpls_fib_encap_details_t_handler_json
14760 (vl_api_mpls_fib_encap_details_t * mp)
14762 vat_main_t *vam = &vat_main;
14763 vat_json_node_t *node = NULL;
14765 i32 len = ntohl (mp->nlabels);
14766 struct in_addr ip4;
14768 if (VAT_JSON_ARRAY != vam->json_tree.type)
14770 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14771 vat_json_init_array (&vam->json_tree);
14773 node = vat_json_array_add (&vam->json_tree);
14775 vat_json_init_object (node);
14776 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14777 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14778 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14779 vat_json_object_add_ip4 (node, "dest", ip4);
14780 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14781 vat_json_object_add_uint (node, "label_count", len);
14782 for (i = 0; i < len; i++)
14784 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14789 api_mpls_fib_encap_dump (vat_main_t * vam)
14791 vl_api_mpls_fib_encap_dump_t *mp;
14794 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14797 /* Use a control ping for synchronization */
14799 vl_api_control_ping_t *mp;
14800 M (CONTROL_PING, control_ping);
14807 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
14809 vat_main_t *vam = &vat_main;
14812 "table-id %d, label %u, ess_bit %u\n",
14813 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
14816 static void vl_api_mpls_fib_details_t_handler_json
14817 (vl_api_mpls_fib_details_t * mp)
14819 vat_main_t *vam = &vat_main;
14820 vat_json_node_t *node = NULL;
14822 if (VAT_JSON_ARRAY != vam->json_tree.type)
14824 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14825 vat_json_init_array (&vam->json_tree);
14827 node = vat_json_array_add (&vam->json_tree);
14829 vat_json_init_object (node);
14830 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
14831 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
14832 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14836 api_mpls_fib_dump (vat_main_t * vam)
14838 vl_api_mpls_fib_dump_t *mp;
14841 M (MPLS_FIB_DUMP, mpls_fib_dump);
14844 /* Use a control ping for synchronization */
14846 vl_api_control_ping_t *mp;
14847 M (CONTROL_PING, control_ping);
14854 api_classify_table_ids (vat_main_t * vam)
14856 vl_api_classify_table_ids_t *mp;
14859 /* Construct the API message */
14860 M (CLASSIFY_TABLE_IDS, classify_table_ids);
14870 api_classify_table_by_interface (vat_main_t * vam)
14872 unformat_input_t *input = vam->input;
14873 vl_api_classify_table_by_interface_t *mp;
14876 u32 sw_if_index = ~0;
14877 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14879 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
14881 else if (unformat (input, "sw_if_index %d", &sw_if_index))
14886 if (sw_if_index == ~0)
14888 errmsg ("missing interface name or sw_if_index\n");
14892 /* Construct the API message */
14893 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
14895 mp->sw_if_index = ntohl (sw_if_index);
14904 api_classify_table_info (vat_main_t * vam)
14906 unformat_input_t *input = vam->input;
14907 vl_api_classify_table_info_t *mp;
14911 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14913 if (unformat (input, "table_id %d", &table_id))
14918 if (table_id == ~0)
14920 errmsg ("missing table id\n");
14924 /* Construct the API message */
14925 M (CLASSIFY_TABLE_INFO, classify_table_info);
14927 mp->table_id = ntohl (table_id);
14936 api_classify_session_dump (vat_main_t * vam)
14938 unformat_input_t *input = vam->input;
14939 vl_api_classify_session_dump_t *mp;
14943 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14945 if (unformat (input, "table_id %d", &table_id))
14950 if (table_id == ~0)
14952 errmsg ("missing table id\n");
14956 /* Construct the API message */
14957 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
14959 mp->table_id = ntohl (table_id);
14962 /* Use a control ping for synchronization */
14964 vl_api_control_ping_t *mp;
14965 M (CONTROL_PING, control_ping);
14974 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
14976 vat_main_t *vam = &vat_main;
14978 fformat (vam->ofp, "collector_address %U, collector_port %d, "
14979 "src_address %U, vrf_id %d, path_mtu %u, "
14980 "template_interval %u, udp_checksum %d\n",
14981 format_ip4_address, mp->collector_address,
14982 ntohs (mp->collector_port),
14983 format_ip4_address, mp->src_address,
14984 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
14985 ntohl (mp->template_interval), mp->udp_checksum);
14988 vam->result_ready = 1;
14992 vl_api_ipfix_exporter_details_t_handler_json
14993 (vl_api_ipfix_exporter_details_t * mp)
14995 vat_main_t *vam = &vat_main;
14996 vat_json_node_t node;
14997 struct in_addr collector_address;
14998 struct in_addr src_address;
15000 vat_json_init_object (&node);
15001 clib_memcpy (&collector_address, &mp->collector_address,
15002 sizeof (collector_address));
15003 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
15004 vat_json_object_add_uint (&node, "collector_port",
15005 ntohs (mp->collector_port));
15006 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
15007 vat_json_object_add_ip4 (&node, "src_address", src_address);
15008 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
15009 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
15010 vat_json_object_add_uint (&node, "template_interval",
15011 ntohl (mp->template_interval));
15012 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
15014 vat_json_print (vam->ofp, &node);
15015 vat_json_free (&node);
15017 vam->result_ready = 1;
15021 api_ipfix_exporter_dump (vat_main_t * vam)
15023 vl_api_ipfix_exporter_dump_t *mp;
15026 /* Construct the API message */
15027 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
15037 api_ipfix_classify_stream_dump (vat_main_t * vam)
15039 vl_api_ipfix_classify_stream_dump_t *mp;
15042 /* Construct the API message */
15043 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
15053 vl_api_ipfix_classify_stream_details_t_handler
15054 (vl_api_ipfix_classify_stream_details_t * mp)
15056 vat_main_t *vam = &vat_main;
15057 fformat (vam->ofp, "domain_id %d, src_port %d\n",
15058 ntohl (mp->domain_id), ntohs (mp->src_port));
15060 vam->result_ready = 1;
15064 vl_api_ipfix_classify_stream_details_t_handler_json
15065 (vl_api_ipfix_classify_stream_details_t * mp)
15067 vat_main_t *vam = &vat_main;
15068 vat_json_node_t node;
15070 vat_json_init_object (&node);
15071 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
15072 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
15074 vat_json_print (vam->ofp, &node);
15075 vat_json_free (&node);
15077 vam->result_ready = 1;
15081 api_ipfix_classify_table_dump (vat_main_t * vam)
15083 vl_api_ipfix_classify_table_dump_t *mp;
15086 if (!vam->json_output)
15088 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
15089 "transport_protocol");
15092 /* Construct the API message */
15093 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
15098 /* Use a control ping for synchronization */
15100 vl_api_control_ping_t *mp;
15101 M (CONTROL_PING, control_ping);
15108 vl_api_ipfix_classify_table_details_t_handler
15109 (vl_api_ipfix_classify_table_details_t * mp)
15111 vat_main_t *vam = &vat_main;
15112 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
15113 mp->transport_protocol);
15117 vl_api_ipfix_classify_table_details_t_handler_json
15118 (vl_api_ipfix_classify_table_details_t * mp)
15120 vat_json_node_t *node = NULL;
15121 vat_main_t *vam = &vat_main;
15123 if (VAT_JSON_ARRAY != vam->json_tree.type)
15125 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15126 vat_json_init_array (&vam->json_tree);
15129 node = vat_json_array_add (&vam->json_tree);
15130 vat_json_init_object (node);
15132 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
15133 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
15134 vat_json_object_add_uint (node, "transport_protocol",
15135 mp->transport_protocol);
15139 api_pg_create_interface (vat_main_t * vam)
15141 unformat_input_t *input = vam->input;
15142 vl_api_pg_create_interface_t *mp;
15146 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15148 if (unformat (input, "if_id %d", &if_id))
15155 errmsg ("missing pg interface index\n");
15159 /* Construct the API message */
15160 M (PG_CREATE_INTERFACE, pg_create_interface);
15162 mp->interface_id = ntohl (if_id);
15171 api_pg_capture (vat_main_t * vam)
15173 unformat_input_t *input = vam->input;
15174 vl_api_pg_capture_t *mp;
15180 u8 pcap_file_set = 0;
15182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15184 if (unformat (input, "if_id %d", &if_id))
15186 else if (unformat (input, "pcap %s", &pcap_file))
15188 else if (unformat (input, "count %d", &count))
15190 else if (unformat (input, "disable"))
15197 errmsg ("missing pg interface index\n");
15200 if (pcap_file_set > 0)
15202 if (vec_len (pcap_file) > 255)
15204 errmsg ("pcap file name is too long\n");
15209 u32 name_len = vec_len (pcap_file);
15210 /* Construct the API message */
15211 M (PG_CAPTURE, pg_capture);
15213 mp->interface_id = ntohl (if_id);
15214 mp->is_enabled = enable;
15215 mp->count = ntohl (count);
15216 mp->pcap_name_length = ntohl (name_len);
15217 if (pcap_file_set != 0)
15219 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
15221 vec_free (pcap_file);
15230 api_pg_enable_disable (vat_main_t * vam)
15232 unformat_input_t *input = vam->input;
15233 vl_api_pg_enable_disable_t *mp;
15237 u8 stream_name_set = 0;
15238 u8 *stream_name = 0;
15239 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15241 if (unformat (input, "stream %s", &stream_name))
15242 stream_name_set = 1;
15243 else if (unformat (input, "disable"))
15249 if (stream_name_set > 0)
15251 if (vec_len (stream_name) > 255)
15253 errmsg ("stream name too long\n");
15258 u32 name_len = vec_len (stream_name);
15259 /* Construct the API message */
15260 M (PG_ENABLE_DISABLE, pg_enable_disable);
15262 mp->is_enabled = enable;
15263 if (stream_name_set != 0)
15265 mp->stream_name_length = ntohl (name_len);
15266 clib_memcpy (mp->stream_name, stream_name, name_len);
15268 vec_free (stream_name);
15277 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
15279 unformat_input_t *input = vam->input;
15280 vl_api_ip_source_and_port_range_check_add_del_t *mp;
15283 u16 *low_ports = 0;
15284 u16 *high_ports = 0;
15287 ip4_address_t ip4_addr;
15288 ip6_address_t ip6_addr;
15296 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15298 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
15304 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
15309 else if (unformat (input, "vrf %d", &vrf_id))
15311 else if (unformat (input, "del"))
15313 else if (unformat (input, "port %d", &tmp))
15315 if (tmp == 0 || tmp > 65535)
15317 errmsg ("port %d out of range", tmp);
15321 this_hi = this_low + 1;
15322 vec_add1 (low_ports, this_low);
15323 vec_add1 (high_ports, this_hi);
15325 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
15327 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
15329 errmsg ("incorrect range parameters\n");
15333 /* Note: in debug CLI +1 is added to high before
15334 passing to real fn that does "the work"
15335 (ip_source_and_port_range_check_add_del).
15336 This fn is a wrapper around the binary API fn a
15337 control plane will call, which expects this increment
15338 to have occurred. Hence letting the binary API control
15339 plane fn do the increment for consistency between VAT
15340 and other control planes.
15343 vec_add1 (low_ports, this_low);
15344 vec_add1 (high_ports, this_hi);
15350 if (prefix_set == 0)
15352 errmsg ("<address>/<mask> not specified\n");
15358 errmsg ("VRF ID required, not specified\n");
15365 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15369 if (vec_len (low_ports) == 0)
15371 errmsg ("At least one port or port range required\n");
15375 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
15376 ip_source_and_port_range_check_add_del);
15378 mp->is_add = is_add;
15383 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
15388 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
15391 mp->mask_length = length;
15392 mp->number_of_ranges = vec_len (low_ports);
15394 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
15395 vec_free (low_ports);
15397 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
15398 vec_free (high_ports);
15400 mp->vrf_id = ntohl (vrf_id);
15409 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
15411 unformat_input_t *input = vam->input;
15412 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
15414 u32 sw_if_index = ~0;
15416 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
15417 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
15420 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15422 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15424 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15426 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
15428 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
15430 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
15432 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15434 else if (unformat (input, "del"))
15440 if (sw_if_index == ~0)
15442 errmsg ("Interface required but not specified\n");
15448 errmsg ("VRF ID required but not specified\n");
15452 if (tcp_out_vrf_id == 0
15453 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15456 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15460 /* Construct the API message */
15461 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15462 ip_source_and_port_range_check_interface_add_del);
15464 mp->sw_if_index = ntohl (sw_if_index);
15465 mp->is_add = is_add;
15466 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15467 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15468 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15469 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15474 /* Wait for a reply... */
15479 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15481 unformat_input_t *i = vam->input;
15482 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15484 u32 local_sa_id = 0;
15485 u32 remote_sa_id = 0;
15486 ip4_address_t src_address;
15487 ip4_address_t dst_address;
15490 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15492 if (unformat (i, "local_sa %d", &local_sa_id))
15494 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15496 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15498 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15500 else if (unformat (i, "del"))
15504 clib_warning ("parse error '%U'", format_unformat_error, i);
15509 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15511 mp->local_sa_id = ntohl (local_sa_id);
15512 mp->remote_sa_id = ntohl (remote_sa_id);
15513 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15514 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15515 mp->is_add = is_add;
15524 api_punt (vat_main_t * vam)
15526 unformat_input_t *i = vam->input;
15534 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15536 if (unformat (i, "ip %d", &ipv))
15538 else if (unformat (i, "protocol %d", &protocol))
15540 else if (unformat (i, "port %d", &port))
15542 else if (unformat (i, "del"))
15546 clib_warning ("parse error '%U'", format_unformat_error, i);
15553 mp->is_add = (u8) is_add;
15554 mp->ipv = (u8) ipv;
15555 mp->l4_protocol = (u8) protocol;
15556 mp->l4_port = htons ((u16) port);
15564 static void vl_api_ipsec_gre_tunnel_details_t_handler
15565 (vl_api_ipsec_gre_tunnel_details_t * mp)
15567 vat_main_t *vam = &vat_main;
15569 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15570 ntohl (mp->sw_if_index),
15571 format_ip4_address, &mp->src_address,
15572 format_ip4_address, &mp->dst_address,
15573 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15576 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15577 (vl_api_ipsec_gre_tunnel_details_t * mp)
15579 vat_main_t *vam = &vat_main;
15580 vat_json_node_t *node = NULL;
15581 struct in_addr ip4;
15583 if (VAT_JSON_ARRAY != vam->json_tree.type)
15585 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15586 vat_json_init_array (&vam->json_tree);
15588 node = vat_json_array_add (&vam->json_tree);
15590 vat_json_init_object (node);
15591 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15592 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15593 vat_json_object_add_ip4 (node, "src_address", ip4);
15594 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15595 vat_json_object_add_ip4 (node, "dst_address", ip4);
15596 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15597 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15601 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15603 unformat_input_t *i = vam->input;
15604 vl_api_ipsec_gre_tunnel_dump_t *mp;
15607 u8 sw_if_index_set = 0;
15609 /* Parse args required to build the message */
15610 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15612 if (unformat (i, "sw_if_index %d", &sw_if_index))
15613 sw_if_index_set = 1;
15618 if (sw_if_index_set == 0)
15623 if (!vam->json_output)
15625 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15626 "sw_if_index", "src_address", "dst_address",
15627 "local_sa_id", "remote_sa_id");
15630 /* Get list of gre-tunnel interfaces */
15631 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15633 mp->sw_if_index = htonl (sw_if_index);
15637 /* Use a control ping for synchronization */
15639 vl_api_control_ping_t *mp;
15640 M (CONTROL_PING, control_ping);
15647 api_delete_subif (vat_main_t * vam)
15649 unformat_input_t *i = vam->input;
15650 vl_api_delete_subif_t *mp;
15652 u32 sw_if_index = ~0;
15654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15656 if (unformat (i, "sw_if_index %d", &sw_if_index))
15662 if (sw_if_index == ~0)
15664 errmsg ("missing sw_if_index\n");
15668 /* Construct the API message */
15669 M (DELETE_SUBIF, delete_subif);
15670 mp->sw_if_index = ntohl (sw_if_index);
15676 #define foreach_pbb_vtr_op \
15677 _("disable", L2_VTR_DISABLED) \
15678 _("pop", L2_VTR_POP_2) \
15679 _("push", L2_VTR_PUSH_2)
15682 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
15684 unformat_input_t *i = vam->input;
15685 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
15687 u32 sw_if_index = ~0, vtr_op = ~0;
15688 u16 outer_tag = ~0;
15689 u8 dmac[6], smac[6];
15690 u8 dmac_set = 0, smac_set = 0;
15695 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15697 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
15699 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15701 else if (unformat (i, "vtr_op %d", &vtr_op))
15703 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
15706 else if (unformat (i, "translate_pbb_stag"))
15708 if (unformat (i, "%d", &tmp))
15710 vtr_op = L2_VTR_TRANSLATE_2_1;
15716 ("translate_pbb_stag operation requires outer tag definition\n");
15720 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
15722 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
15724 else if (unformat (i, "sid %d", &sid))
15726 else if (unformat (i, "vlanid %d", &tmp))
15730 clib_warning ("parse error '%U'", format_unformat_error, i);
15735 if ((sw_if_index == ~0) || (vtr_op == ~0))
15737 errmsg ("missing sw_if_index or vtr operation\n");
15740 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
15741 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
15744 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid\n");
15748 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
15749 mp->sw_if_index = ntohl (sw_if_index);
15750 mp->vtr_op = ntohl (vtr_op);
15751 mp->outer_tag = ntohs (outer_tag);
15752 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
15753 clib_memcpy (mp->b_smac, smac, sizeof (smac));
15754 mp->b_vlanid = ntohs (vlanid);
15755 mp->i_sid = ntohl (sid);
15764 api_flow_classify_set_interface (vat_main_t * vam)
15766 unformat_input_t *i = vam->input;
15767 vl_api_flow_classify_set_interface_t *mp;
15770 int sw_if_index_set;
15771 u32 ip4_table_index = ~0;
15772 u32 ip6_table_index = ~0;
15775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15777 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
15778 sw_if_index_set = 1;
15779 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15780 sw_if_index_set = 1;
15781 else if (unformat (i, "del"))
15783 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15785 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15789 clib_warning ("parse error '%U'", format_unformat_error, i);
15794 if (sw_if_index_set == 0)
15796 errmsg ("missing interface name or sw_if_index\n");
15800 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
15802 mp->sw_if_index = ntohl (sw_if_index);
15803 mp->ip4_table_index = ntohl (ip4_table_index);
15804 mp->ip6_table_index = ntohl (ip6_table_index);
15805 mp->is_add = is_add;
15814 api_flow_classify_dump (vat_main_t * vam)
15816 unformat_input_t *i = vam->input;
15817 vl_api_flow_classify_dump_t *mp;
15819 u8 type = FLOW_CLASSIFY_N_TABLES;
15821 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
15825 errmsg ("classify table type must be specified\n");
15829 if (!vam->json_output)
15831 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
15834 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
15839 /* Use a control ping for synchronization */
15841 vl_api_control_ping_t *mp;
15842 M (CONTROL_PING, control_ping);
15845 /* Wait for a reply... */
15853 q_or_quit (vat_main_t * vam)
15855 longjmp (vam->jump_buf, 1);
15856 return 0; /* not so much */
15860 q (vat_main_t * vam)
15862 return q_or_quit (vam);
15866 quit (vat_main_t * vam)
15868 return q_or_quit (vam);
15872 comment (vat_main_t * vam)
15878 cmd_cmp (void *a1, void *a2)
15883 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
15887 help (vat_main_t * vam)
15892 unformat_input_t *i = vam->input;
15895 if (unformat (i, "%s", &name))
15899 vec_add1 (name, 0);
15901 hs = hash_get_mem (vam->help_by_name, name);
15903 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
15905 fformat (vam->ofp, "No such msg / command '%s'\n", name);
15910 fformat (vam->ofp, "Help is available for the following:\n");
15913 hash_foreach_pair (p, vam->function_by_name,
15915 vec_add1 (cmds, (u8 *)(p->key));
15919 vec_sort_with_function (cmds, cmd_cmp);
15921 for (j = 0; j < vec_len (cmds); j++)
15922 fformat (vam->ofp, "%s\n", cmds[j]);
15929 set (vat_main_t * vam)
15931 u8 *name = 0, *value = 0;
15932 unformat_input_t *i = vam->input;
15934 if (unformat (i, "%s", &name))
15936 /* The input buffer is a vector, not a string. */
15937 value = vec_dup (i->buffer);
15938 vec_delete (value, i->index, 0);
15939 /* Almost certainly has a trailing newline */
15940 if (value[vec_len (value) - 1] == '\n')
15941 value[vec_len (value) - 1] = 0;
15942 /* Make sure it's a proper string, one way or the other */
15943 vec_add1 (value, 0);
15944 (void) clib_macro_set_value (&vam->macro_main,
15945 (char *) name, (char *) value);
15948 errmsg ("usage: set <name> <value>\n");
15956 unset (vat_main_t * vam)
15960 if (unformat (vam->input, "%s", &name))
15961 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
15962 errmsg ("unset: %s wasn't set\n", name);
15975 macro_sort_cmp (void *a1, void *a2)
15977 macro_sort_t *s1 = a1;
15978 macro_sort_t *s2 = a2;
15980 return strcmp ((char *) (s1->name), (char *) (s2->name));
15984 dump_macro_table (vat_main_t * vam)
15986 macro_sort_t *sort_me = 0, *sm;
15991 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
15993 vec_add2 (sort_me, sm, 1);
15994 sm->name = (u8 *)(p->key);
15995 sm->value = (u8 *) (p->value[0]);
15999 vec_sort_with_function (sort_me, macro_sort_cmp);
16001 if (vec_len (sort_me))
16002 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
16004 fformat (vam->ofp, "The macro table is empty...\n");
16006 for (i = 0; i < vec_len (sort_me); i++)
16007 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
16012 dump_node_table (vat_main_t * vam)
16015 vlib_node_t *node, *next_node;
16017 if (vec_len (vam->graph_nodes) == 0)
16019 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16023 for (i = 0; i < vec_len (vam->graph_nodes); i++)
16025 node = vam->graph_nodes[i];
16026 fformat (vam->ofp, "[%d] %s\n", i, node->name);
16027 for (j = 0; j < vec_len (node->next_nodes); j++)
16029 if (node->next_nodes[j] != ~0)
16031 next_node = vam->graph_nodes[node->next_nodes[j]];
16032 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16040 search_node_table (vat_main_t * vam)
16042 unformat_input_t *line_input = vam->input;
16045 vlib_node_t *node, *next_node;
16048 if (vam->graph_node_index_by_name == 0)
16050 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16054 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16056 if (unformat (line_input, "%s", &node_to_find))
16058 vec_add1 (node_to_find, 0);
16059 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
16062 fformat (vam->ofp, "%s not found...\n", node_to_find);
16065 node = vam->graph_nodes[p[0]];
16066 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
16067 for (j = 0; j < vec_len (node->next_nodes); j++)
16069 if (node->next_nodes[j] != ~0)
16071 next_node = vam->graph_nodes[node->next_nodes[j]];
16072 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16079 clib_warning ("parse error '%U'", format_unformat_error,
16085 vec_free (node_to_find);
16094 script (vat_main_t * vam)
16097 char *save_current_file;
16098 unformat_input_t save_input;
16099 jmp_buf save_jump_buf;
16100 u32 save_line_number;
16102 FILE *new_fp, *save_ifp;
16104 if (unformat (vam->input, "%s", &s))
16106 new_fp = fopen ((char *) s, "r");
16109 errmsg ("Couldn't open script file %s\n", s);
16116 errmsg ("Missing script name\n");
16120 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
16121 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
16122 save_ifp = vam->ifp;
16123 save_line_number = vam->input_line_number;
16124 save_current_file = (char *) vam->current_file;
16126 vam->input_line_number = 0;
16128 vam->current_file = s;
16131 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
16132 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
16133 vam->ifp = save_ifp;
16134 vam->input_line_number = save_line_number;
16135 vam->current_file = (u8 *) save_current_file;
16142 echo (vat_main_t * vam)
16144 fformat (vam->ofp, "%v", vam->input->buffer);
16148 /* List of API message constructors, CLI names map to api_xxx */
16149 #define foreach_vpe_api_msg \
16150 _(create_loopback,"[mac <mac-addr>]") \
16151 _(sw_interface_dump,"") \
16152 _(sw_interface_set_flags, \
16153 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
16154 _(sw_interface_add_del_address, \
16155 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
16156 _(sw_interface_set_table, \
16157 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
16158 _(sw_interface_set_vpath, \
16159 "<intfc> | sw_if_index <id> enable | disable") \
16160 _(sw_interface_set_l2_xconnect, \
16161 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16162 "enable | disable") \
16163 _(sw_interface_set_l2_bridge, \
16164 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
16165 "[shg <split-horizon-group>] [bvi]\n" \
16166 "enable | disable") \
16167 _(sw_interface_set_dpdk_hqos_pipe, \
16168 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
16169 "profile <profile-id>\n") \
16170 _(sw_interface_set_dpdk_hqos_subport, \
16171 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
16172 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
16173 _(sw_interface_set_dpdk_hqos_tctbl, \
16174 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
16175 _(bridge_domain_add_del, \
16176 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
16177 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
16179 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
16181 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
16183 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
16185 "tapname <name> mac <mac-addr> | random-mac") \
16187 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
16189 "<vpp-if-name> | sw_if_index <id>") \
16190 _(sw_interface_tap_dump, "") \
16191 _(ip_add_del_route, \
16192 "<addr>/<mask> via <addr> [table-id <n>]\n" \
16193 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16194 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16195 "[multipath] [count <n>]") \
16196 _(mpls_route_add_del, \
16197 "<label> <eos> via <addr> [table-id <n>]\n" \
16198 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16199 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16200 "[multipath] [count <n>]") \
16201 _(mpls_ip_bind_unbind, \
16202 "<label> <addr/len>") \
16203 _(proxy_arp_add_del, \
16204 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
16205 _(proxy_arp_intfc_enable_disable, \
16206 "<intfc> | sw_if_index <id> enable | disable") \
16207 _(mpls_add_del_encap, \
16208 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
16209 _(sw_interface_set_unnumbered, \
16210 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
16211 _(ip_neighbor_add_del, \
16212 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
16213 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
16214 _(reset_vrf, "vrf <id> [ipv6]") \
16215 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
16216 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
16217 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
16218 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
16219 "[outer_vlan_id_any][inner_vlan_id_any]") \
16220 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
16221 _(reset_fib, "vrf <n> [ipv6]") \
16222 _(dhcp_proxy_config, \
16223 "svr <v46-address> src <v46-address>\n" \
16224 "insert-cid <n> [del]") \
16225 _(dhcp_proxy_config_2, \
16226 "svr <v46-address> src <v46-address>\n" \
16227 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
16228 _(dhcp_proxy_set_vss, \
16229 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
16230 _(dhcp_client_config, \
16231 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
16232 _(set_ip_flow_hash, \
16233 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
16234 _(sw_interface_ip6_enable_disable, \
16235 "<intfc> | sw_if_index <id> enable | disable") \
16236 _(sw_interface_ip6_set_link_local_address, \
16237 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
16238 _(sw_interface_ip6nd_ra_prefix, \
16239 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
16240 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
16241 "[nolink] [isno]") \
16242 _(sw_interface_ip6nd_ra_config, \
16243 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
16244 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
16245 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
16246 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
16247 _(l2_patch_add_del, \
16248 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16249 "enable | disable") \
16250 _(mpls_ethernet_add_del_tunnel, \
16251 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
16252 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
16253 _(mpls_ethernet_add_del_tunnel_2, \
16254 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
16255 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
16256 _(sr_tunnel_add_del, \
16257 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
16258 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
16259 "[policy <policy_name>]") \
16260 _(sr_policy_add_del, \
16261 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
16262 _(sr_multicast_map_add_del, \
16263 "address [ip6 multicast address] sr-policy [policy name] [del]") \
16264 _(classify_add_del_table, \
16265 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
16266 "[del] mask <mask-value>\n" \
16267 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
16268 _(classify_add_del_session, \
16269 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
16270 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
16271 " [l3 [ip4|ip6]]") \
16272 _(classify_set_interface_ip_table, \
16273 "<intfc> | sw_if_index <nn> table <nn>") \
16274 _(classify_set_interface_l2_tables, \
16275 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16276 " [other-table <nn>]") \
16277 _(get_node_index, "node <node-name") \
16278 _(add_node_next, "node <node-name> next <next-node-name>") \
16279 _(l2tpv3_create_tunnel, \
16280 "client_address <ip6-addr> our_address <ip6-addr>\n" \
16281 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
16282 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
16283 _(l2tpv3_set_tunnel_cookies, \
16284 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
16285 "[new_remote_cookie <nn>]\n") \
16286 _(l2tpv3_interface_enable_disable, \
16287 "<intfc> | sw_if_index <nn> enable | disable") \
16288 _(l2tpv3_set_lookup_key, \
16289 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
16290 _(sw_if_l2tpv3_tunnel_dump, "") \
16291 _(vxlan_add_del_tunnel, \
16292 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
16293 " [decap-next l2|ip4|ip6] [del]") \
16294 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16295 _(gre_add_del_tunnel, \
16296 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
16297 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16298 _(l2_fib_clear_table, "") \
16299 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
16300 _(l2_interface_vlan_tag_rewrite, \
16301 "<intfc> | sw_if_index <nn> \n" \
16302 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
16303 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
16304 _(create_vhost_user_if, \
16305 "socket <filename> [server] [renumber <dev_instance>] " \
16306 "[mac <mac_address>]") \
16307 _(modify_vhost_user_if, \
16308 "<intfc> | sw_if_index <nn> socket <filename>\n" \
16309 "[server] [renumber <dev_instance>]") \
16310 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
16311 _(sw_interface_vhost_user_dump, "") \
16312 _(show_version, "") \
16313 _(vxlan_gpe_add_del_tunnel, \
16314 "local <addr> remote <addr> vni <nn>\n" \
16315 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
16316 "[next-ethernet] [next-nsh]\n") \
16317 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16318 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
16319 _(interface_name_renumber, \
16320 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
16321 _(input_acl_set_interface, \
16322 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16323 " [l2-table <nn>] [del]") \
16324 _(want_ip4_arp_events, "address <ip4-address> [del]") \
16325 _(want_ip6_nd_events, "address <ip6-address> [del]") \
16326 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
16327 _(ip_dump, "ipv4 | ipv6") \
16328 _(ipsec_spd_add_del, "spd_id <n> [del]") \
16329 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
16331 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
16332 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
16333 " integ_alg <alg> integ_key <hex>") \
16334 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
16335 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
16336 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
16337 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
16338 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
16339 _(ikev2_profile_add_del, "name <profile_name> [del]") \
16340 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
16341 "(auth_data 0x<data> | auth_data <data>)") \
16342 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
16343 "(id_data 0x<data> | id_data <data>) (local|remote)") \
16344 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
16345 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
16346 "(local|remote)") \
16347 _(ikev2_set_local_key, "file <absolute_file_path>") \
16348 _(delete_loopback,"sw_if_index <nn>") \
16349 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
16350 _(map_add_domain, \
16351 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
16352 "ip6-src <ip6addr> " \
16353 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
16354 _(map_del_domain, "index <n>") \
16355 _(map_add_del_rule, \
16356 "index <n> psid <n> dst <ip6addr> [del]") \
16357 _(map_domain_dump, "") \
16358 _(map_rule_dump, "index <map-domain>") \
16359 _(want_interface_events, "enable|disable") \
16360 _(want_stats,"enable|disable") \
16361 _(get_first_msg_id, "client <name>") \
16362 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
16363 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
16364 "fib-id <nn> [ip4][ip6][default]") \
16365 _(get_node_graph, " ") \
16366 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
16367 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
16368 _(ioam_disable, "") \
16369 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
16370 " sw_if_index <sw_if_index> p <priority> " \
16371 "w <weight>] [del]") \
16372 _(lisp_add_del_locator, "locator-set <locator_name> " \
16373 "iface <intf> | sw_if_index <sw_if_index> " \
16374 "p <priority> w <weight> [del]") \
16375 _(lisp_add_del_local_eid,"vni <vni> eid " \
16376 "<ipv4|ipv6>/<prefix> | <L2 address> " \
16377 "locator-set <locator_name> [del]") \
16378 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
16379 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
16380 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
16381 _(lisp_gpe_enable_disable, "enable|disable") \
16382 _(lisp_enable_disable, "enable|disable") \
16383 _(lisp_gpe_add_del_iface, "up|down") \
16384 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
16386 "rloc <locator> p <prio> " \
16387 "w <weight> [rloc <loc> ... ] " \
16388 "action <action> [del-all]") \
16389 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
16391 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
16392 _(lisp_map_request_mode, "src-dst|dst-only") \
16393 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
16394 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
16395 _(lisp_locator_set_dump, "[local | remote]") \
16396 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
16397 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
16398 "[local] | [remote]") \
16399 _(lisp_eid_table_vni_dump, "") \
16400 _(lisp_eid_table_map_dump, "l2|l3") \
16401 _(lisp_gpe_tunnel_dump, "") \
16402 _(lisp_map_resolver_dump, "") \
16403 _(lisp_adjacencies_get, "vni <vni>") \
16404 _(show_lisp_status, "") \
16405 _(lisp_get_map_request_itr_rlocs, "") \
16406 _(show_lisp_pitr, "") \
16407 _(show_lisp_map_request_mode, "") \
16408 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
16409 _(af_packet_delete, "name <host interface name>") \
16410 _(policer_add_del, "name <policer name> <params> [del]") \
16411 _(policer_dump, "[name <policer name>]") \
16412 _(policer_classify_set_interface, \
16413 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16414 " [l2-table <nn>] [del]") \
16415 _(policer_classify_dump, "type [ip4|ip6|l2]") \
16416 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
16417 "[master|slave]") \
16418 _(netmap_delete, "name <interface name>") \
16419 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
16420 _(mpls_fib_encap_dump, "") \
16421 _(mpls_fib_dump, "") \
16422 _(classify_table_ids, "") \
16423 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
16424 _(classify_table_info, "table_id <nn>") \
16425 _(classify_session_dump, "table_id <nn>") \
16426 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
16427 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
16428 "[template_interval <nn>] [udp_checksum]") \
16429 _(ipfix_exporter_dump, "") \
16430 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
16431 _(ipfix_classify_stream_dump, "") \
16432 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
16433 _(ipfix_classify_table_dump, "") \
16434 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
16435 _(pg_create_interface, "if_id <nn>") \
16436 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
16437 _(pg_enable_disable, "[stream <id>] disable") \
16438 _(ip_source_and_port_range_check_add_del, \
16439 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
16440 _(ip_source_and_port_range_check_interface_add_del, \
16441 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
16442 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
16443 _(ipsec_gre_add_del_tunnel, \
16444 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
16445 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
16446 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>") \
16447 _(l2_interface_pbb_tag_rewrite, \
16448 "<intfc> | sw_if_index <nn> \n" \
16449 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
16450 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
16451 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
16452 _(flow_classify_set_interface, \
16453 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
16454 _(flow_classify_dump, "type [ip4|ip6]")
16456 /* List of command functions, CLI names map directly to functions */
16457 #define foreach_cli_function \
16458 _(comment, "usage: comment <ignore-rest-of-line>") \
16459 _(dump_interface_table, "usage: dump_interface_table") \
16460 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
16461 _(dump_ipv4_table, "usage: dump_ipv4_table") \
16462 _(dump_ipv6_table, "usage: dump_ipv6_table") \
16463 _(dump_stats_table, "usage: dump_stats_table") \
16464 _(dump_macro_table, "usage: dump_macro_table ") \
16465 _(dump_node_table, "usage: dump_node_table") \
16466 _(echo, "usage: echo <message>") \
16467 _(exec, "usage: exec <vpe-debug-CLI-command>") \
16468 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
16469 _(help, "usage: help") \
16470 _(q, "usage: quit") \
16471 _(quit, "usage: quit") \
16472 _(search_node_table, "usage: search_node_table <name>...") \
16473 _(set, "usage: set <variable-name> <value>") \
16474 _(script, "usage: script <file-name>") \
16475 _(unset, "usage: unset <variable-name>")
16478 static void vl_api_##n##_t_handler_uni \
16479 (vl_api_##n##_t * mp) \
16481 vat_main_t * vam = &vat_main; \
16482 if (vam->json_output) { \
16483 vl_api_##n##_t_handler_json(mp); \
16485 vl_api_##n##_t_handler(mp); \
16488 foreach_vpe_api_reply_msg;
16492 vat_api_hookup (vat_main_t * vam)
16495 vl_msg_api_set_handlers(VL_API_##N, #n, \
16496 vl_api_##n##_t_handler_uni, \
16498 vl_api_##n##_t_endian, \
16499 vl_api_##n##_t_print, \
16500 sizeof(vl_api_##n##_t), 1);
16501 foreach_vpe_api_reply_msg;
16504 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
16506 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
16508 vam->function_by_name = hash_create_string (0, sizeof (uword));
16510 vam->help_by_name = hash_create_string (0, sizeof (uword));
16512 /* API messages we can send */
16513 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
16514 foreach_vpe_api_msg;
16518 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16519 foreach_vpe_api_msg;
16522 /* CLI functions */
16523 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
16524 foreach_cli_function;
16528 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16529 foreach_cli_function;
16533 #undef vl_api_version
16534 #define vl_api_version(n,v) static u32 vpe_api_version = v;
16535 #include <vpp-api/vpe.api.h>
16536 #undef vl_api_version
16539 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
16542 * Send the main API signature in slot 0. This bit of code must
16543 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
16545 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
16549 * fd.io coding-style-patch-verification: ON
16552 * eval: (c-set-style "gnu")