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_mpls_enable_reply) \
3479 _(sw_interface_set_vpath_reply) \
3480 _(sw_interface_set_l2_bridge_reply) \
3481 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3482 _(sw_interface_set_dpdk_hqos_subport_reply) \
3483 _(sw_interface_set_dpdk_hqos_tctbl_reply) \
3484 _(bridge_domain_add_del_reply) \
3485 _(sw_interface_set_l2_xconnect_reply) \
3486 _(l2fib_add_del_reply) \
3487 _(ip_add_del_route_reply) \
3488 _(mpls_route_add_del_reply) \
3489 _(mpls_ip_bind_unbind_reply) \
3490 _(proxy_arp_add_del_reply) \
3491 _(proxy_arp_intfc_enable_disable_reply) \
3492 _(mpls_add_del_encap_reply) \
3493 _(mpls_ethernet_add_del_tunnel_2_reply) \
3494 _(sw_interface_set_unnumbered_reply) \
3495 _(ip_neighbor_add_del_reply) \
3496 _(reset_vrf_reply) \
3497 _(oam_add_del_reply) \
3498 _(reset_fib_reply) \
3499 _(dhcp_proxy_config_reply) \
3500 _(dhcp_proxy_config_2_reply) \
3501 _(dhcp_proxy_set_vss_reply) \
3502 _(dhcp_client_config_reply) \
3503 _(set_ip_flow_hash_reply) \
3504 _(sw_interface_ip6_enable_disable_reply) \
3505 _(sw_interface_ip6_set_link_local_address_reply) \
3506 _(sw_interface_ip6nd_ra_prefix_reply) \
3507 _(sw_interface_ip6nd_ra_config_reply) \
3508 _(set_arp_neighbor_limit_reply) \
3509 _(l2_patch_add_del_reply) \
3510 _(sr_tunnel_add_del_reply) \
3511 _(sr_policy_add_del_reply) \
3512 _(sr_multicast_map_add_del_reply) \
3513 _(classify_add_del_session_reply) \
3514 _(classify_set_interface_ip_table_reply) \
3515 _(classify_set_interface_l2_tables_reply) \
3516 _(l2tpv3_set_tunnel_cookies_reply) \
3517 _(l2tpv3_interface_enable_disable_reply) \
3518 _(l2tpv3_set_lookup_key_reply) \
3519 _(l2_fib_clear_table_reply) \
3520 _(l2_interface_efp_filter_reply) \
3521 _(l2_interface_vlan_tag_rewrite_reply) \
3522 _(modify_vhost_user_if_reply) \
3523 _(delete_vhost_user_if_reply) \
3524 _(want_ip4_arp_events_reply) \
3525 _(want_ip6_nd_events_reply) \
3526 _(input_acl_set_interface_reply) \
3527 _(ipsec_spd_add_del_reply) \
3528 _(ipsec_interface_add_del_spd_reply) \
3529 _(ipsec_spd_add_del_entry_reply) \
3530 _(ipsec_sad_add_del_entry_reply) \
3531 _(ipsec_sa_set_key_reply) \
3532 _(ikev2_profile_add_del_reply) \
3533 _(ikev2_profile_set_auth_reply) \
3534 _(ikev2_profile_set_id_reply) \
3535 _(ikev2_profile_set_ts_reply) \
3536 _(ikev2_set_local_key_reply) \
3537 _(delete_loopback_reply) \
3538 _(bd_ip_mac_add_del_reply) \
3539 _(map_del_domain_reply) \
3540 _(map_add_del_rule_reply) \
3541 _(want_interface_events_reply) \
3542 _(want_stats_reply) \
3543 _(cop_interface_enable_disable_reply) \
3544 _(cop_whitelist_enable_disable_reply) \
3545 _(sw_interface_clear_stats_reply) \
3546 _(ioam_enable_reply) \
3547 _(ioam_disable_reply) \
3548 _(lisp_add_del_locator_reply) \
3549 _(lisp_add_del_local_eid_reply) \
3550 _(lisp_add_del_remote_mapping_reply) \
3551 _(lisp_add_del_adjacency_reply) \
3552 _(lisp_gpe_add_del_fwd_entry_reply) \
3553 _(lisp_add_del_map_resolver_reply) \
3554 _(lisp_gpe_enable_disable_reply) \
3555 _(lisp_gpe_add_del_iface_reply) \
3556 _(lisp_enable_disable_reply) \
3557 _(lisp_pitr_set_locator_set_reply) \
3558 _(lisp_map_request_mode_reply) \
3559 _(lisp_add_del_map_request_itr_rlocs_reply) \
3560 _(lisp_eid_table_add_del_map_reply) \
3561 _(vxlan_gpe_add_del_tunnel_reply) \
3562 _(af_packet_delete_reply) \
3563 _(policer_classify_set_interface_reply) \
3564 _(netmap_create_reply) \
3565 _(netmap_delete_reply) \
3566 _(set_ipfix_exporter_reply) \
3567 _(set_ipfix_classify_stream_reply) \
3568 _(ipfix_classify_table_add_del_reply) \
3569 _(flow_classify_set_interface_reply) \
3570 _(pg_capture_reply) \
3571 _(pg_enable_disable_reply) \
3572 _(ip_source_and_port_range_check_add_del_reply) \
3573 _(ip_source_and_port_range_check_interface_add_del_reply)\
3574 _(delete_subif_reply) \
3575 _(l2_interface_pbb_tag_rewrite_reply) \
3579 static void vl_api_##n##_t_handler \
3580 (vl_api_##n##_t * mp) \
3582 vat_main_t * vam = &vat_main; \
3583 i32 retval = ntohl(mp->retval); \
3584 if (vam->async_mode) { \
3585 vam->async_errors += (retval < 0); \
3587 vam->retval = retval; \
3588 vam->result_ready = 1; \
3591 foreach_standard_reply_retval_handler;
3595 static void vl_api_##n##_t_handler_json \
3596 (vl_api_##n##_t * mp) \
3598 vat_main_t * vam = &vat_main; \
3599 vat_json_node_t node; \
3600 vat_json_init_object(&node); \
3601 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3602 vat_json_print(vam->ofp, &node); \
3603 vam->retval = ntohl(mp->retval); \
3604 vam->result_ready = 1; \
3606 foreach_standard_reply_retval_handler;
3610 * Table of message reply handlers, must include boilerplate handlers
3614 #define foreach_vpe_api_reply_msg \
3615 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3616 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3617 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3618 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3619 _(CONTROL_PING_REPLY, control_ping_reply) \
3620 _(CLI_REPLY, cli_reply) \
3621 _(CLI_INBAND_REPLY, cli_inband_reply) \
3622 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3623 sw_interface_add_del_address_reply) \
3624 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3625 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3626 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3627 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3628 sw_interface_set_l2_xconnect_reply) \
3629 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3630 sw_interface_set_l2_bridge_reply) \
3631 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
3632 sw_interface_set_dpdk_hqos_pipe_reply) \
3633 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
3634 sw_interface_set_dpdk_hqos_subport_reply) \
3635 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
3636 sw_interface_set_dpdk_hqos_tctbl_reply) \
3637 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3638 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3639 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3640 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3641 _(L2_FLAGS_REPLY, l2_flags_reply) \
3642 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3643 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3644 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3645 _(TAP_DELETE_REPLY, tap_delete_reply) \
3646 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3647 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3648 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
3649 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
3650 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3651 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3652 proxy_arp_intfc_enable_disable_reply) \
3653 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
3654 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
3655 mpls_ethernet_add_del_tunnel_reply) \
3656 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
3657 mpls_ethernet_add_del_tunnel_2_reply) \
3658 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3659 sw_interface_set_unnumbered_reply) \
3660 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3661 _(RESET_VRF_REPLY, reset_vrf_reply) \
3662 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3663 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3664 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3665 _(RESET_FIB_REPLY, reset_fib_reply) \
3666 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3667 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3668 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3669 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3670 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3671 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3672 sw_interface_ip6_enable_disable_reply) \
3673 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3674 sw_interface_ip6_set_link_local_address_reply) \
3675 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3676 sw_interface_ip6nd_ra_prefix_reply) \
3677 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3678 sw_interface_ip6nd_ra_config_reply) \
3679 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3680 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3681 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3682 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3683 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3684 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3685 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3686 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3687 classify_set_interface_ip_table_reply) \
3688 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3689 classify_set_interface_l2_tables_reply) \
3690 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3691 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3692 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3693 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3694 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3695 l2tpv3_interface_enable_disable_reply) \
3696 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3697 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3698 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3699 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3700 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3701 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3702 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3703 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3704 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3705 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3706 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3707 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3708 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3709 _(SHOW_VERSION_REPLY, show_version_reply) \
3710 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3711 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3712 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3713 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3714 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3715 _(IP4_ARP_EVENT, ip4_arp_event) \
3716 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3717 _(IP6_ND_EVENT, ip6_nd_event) \
3718 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3719 _(IP_ADDRESS_DETAILS, ip_address_details) \
3720 _(IP_DETAILS, ip_details) \
3721 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3722 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3723 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3724 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3725 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3726 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3727 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3728 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3729 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3730 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3731 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3732 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3733 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3734 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3735 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3736 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3737 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3738 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3739 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3740 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3741 _(MAP_RULE_DETAILS, map_rule_details) \
3742 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3743 _(WANT_STATS_REPLY, want_stats_reply) \
3744 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3745 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3746 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3747 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3748 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3749 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3750 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3751 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3752 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3753 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3754 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3755 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3756 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3757 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3758 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3759 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3760 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3761 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3762 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3763 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3764 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3765 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3766 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3767 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3768 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3769 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3770 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3771 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
3772 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3773 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3774 lisp_add_del_map_request_itr_rlocs_reply) \
3775 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3776 lisp_get_map_request_itr_rlocs_reply) \
3777 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3778 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3779 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3780 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3781 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3782 _(POLICER_DETAILS, policer_details) \
3783 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3784 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3785 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3786 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3787 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
3788 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
3789 _(MPLS_FIB_DETAILS, mpls_fib_details) \
3790 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3791 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3792 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3793 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3794 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3795 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3796 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3797 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3798 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3799 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3800 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
3801 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
3802 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3803 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3804 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3805 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3806 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3807 ip_source_and_port_range_check_add_del_reply) \
3808 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3809 ip_source_and_port_range_check_interface_add_del_reply) \
3810 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3811 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3812 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3813 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3814 _(PUNT_REPLY, punt_reply) \
3815 _(IP_FIB_DETAILS, ip_fib_details) \
3816 _(IP6_FIB_DETAILS, ip6_fib_details)
3818 /* M: construct, but don't yet send a message */
3822 vam->result_ready = 0; \
3823 mp = vl_msg_api_alloc(sizeof(*mp)); \
3824 memset (mp, 0, sizeof (*mp)); \
3825 mp->_vl_msg_id = ntohs (VL_API_##T); \
3826 mp->client_index = vam->my_client_index; \
3831 vam->result_ready = 0; \
3832 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3833 memset (mp, 0, sizeof (*mp)); \
3834 mp->_vl_msg_id = ntohs (VL_API_##T); \
3835 mp->client_index = vam->my_client_index; \
3839 /* S: send a message */
3840 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3842 /* W: wait for results, with timeout */
3845 timeout = vat_time_now (vam) + 1.0; \
3847 while (vat_time_now (vam) < timeout) { \
3848 if (vam->result_ready == 1) { \
3849 return (vam->retval); \
3855 /* W2: wait for results, with timeout */
3858 timeout = vat_time_now (vam) + 1.0; \
3860 while (vat_time_now (vam) < timeout) { \
3861 if (vam->result_ready == 1) { \
3863 return (vam->retval); \
3876 #define STR_VTR_OP_CASE(op) \
3877 case L2_VTR_ ## op: \
3881 str_vtr_op (u32 vtr_op)
3885 STR_VTR_OP_CASE (DISABLED);
3886 STR_VTR_OP_CASE (PUSH_1);
3887 STR_VTR_OP_CASE (PUSH_2);
3888 STR_VTR_OP_CASE (POP_1);
3889 STR_VTR_OP_CASE (POP_2);
3890 STR_VTR_OP_CASE (TRANSLATE_1_1);
3891 STR_VTR_OP_CASE (TRANSLATE_1_2);
3892 STR_VTR_OP_CASE (TRANSLATE_2_1);
3893 STR_VTR_OP_CASE (TRANSLATE_2_2);
3900 dump_sub_interface_table (vat_main_t * vam)
3902 const sw_interface_subif_t *sub = NULL;
3904 if (vam->json_output)
3907 ("JSON output supported only for VPE API calls and dump_stats_table");
3912 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
3913 "Interface", "sw_if_index",
3914 "sub id", "dot1ad", "tags", "outer id",
3915 "inner id", "exact", "default", "outer any", "inner any");
3917 vec_foreach (sub, vam->sw_if_subif_table)
3920 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
3921 sub->interface_name,
3923 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
3924 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
3925 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
3926 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
3927 if (sub->vtr_op != L2_VTR_DISABLED)
3930 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
3931 "tag1: %d tag2: %d ]\n",
3932 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
3933 sub->vtr_tag1, sub->vtr_tag2);
3941 name_sort_cmp (void *a1, void *a2)
3943 name_sort_t *n1 = a1;
3944 name_sort_t *n2 = a2;
3946 return strcmp ((char *) n1->name, (char *) n2->name);
3950 dump_interface_table (vat_main_t * vam)
3953 name_sort_t *nses = 0, *ns;
3955 if (vam->json_output)
3958 ("JSON output supported only for VPE API calls and dump_stats_table");
3963 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3965 vec_add2 (nses, ns, 1);
3966 ns->name = (u8 *)(p->key);
3967 ns->value = (u32) p->value[0];
3971 vec_sort_with_function (nses, name_sort_cmp);
3973 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3974 vec_foreach (ns, nses)
3976 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3983 dump_ip_table (vat_main_t * vam, int is_ipv6)
3985 const ip_details_t *det = NULL;
3986 const ip_address_details_t *address = NULL;
3989 fformat (vam->ofp, "%-12s\n", "sw_if_index");
3991 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
3998 fformat (vam->ofp, "%-12d\n", i);
4000 " %-30s%-13s\n", "Address", "Prefix length");
4005 vec_foreach (address, det->addr)
4009 is_ipv6 ? format_ip6_address : format_ip4_address,
4010 address->ip, address->prefix_length);
4018 dump_ipv4_table (vat_main_t * vam)
4020 if (vam->json_output)
4023 ("JSON output supported only for VPE API calls and dump_stats_table");
4027 return dump_ip_table (vam, 0);
4031 dump_ipv6_table (vat_main_t * vam)
4033 if (vam->json_output)
4036 ("JSON output supported only for VPE API calls and dump_stats_table");
4040 return dump_ip_table (vam, 1);
4044 counter_type_to_str (u8 counter_type, u8 is_combined)
4048 switch (counter_type)
4050 case VNET_INTERFACE_COUNTER_DROP:
4052 case VNET_INTERFACE_COUNTER_PUNT:
4054 case VNET_INTERFACE_COUNTER_IP4:
4056 case VNET_INTERFACE_COUNTER_IP6:
4058 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4060 case VNET_INTERFACE_COUNTER_RX_MISS:
4062 case VNET_INTERFACE_COUNTER_RX_ERROR:
4064 case VNET_INTERFACE_COUNTER_TX_ERROR:
4067 return "INVALID-COUNTER-TYPE";
4072 switch (counter_type)
4074 case VNET_INTERFACE_COUNTER_RX:
4076 case VNET_INTERFACE_COUNTER_TX:
4079 return "INVALID-COUNTER-TYPE";
4085 dump_stats_table (vat_main_t * vam)
4087 vat_json_node_t node;
4088 vat_json_node_t *msg_array;
4089 vat_json_node_t *msg;
4090 vat_json_node_t *counter_array;
4091 vat_json_node_t *counter;
4092 interface_counter_t c;
4094 ip4_fib_counter_t *c4;
4095 ip6_fib_counter_t *c6;
4098 if (!vam->json_output)
4100 clib_warning ("dump_stats_table supported only in JSON format");
4104 vat_json_init_object (&node);
4106 /* interface counters */
4107 msg_array = vat_json_object_add (&node, "interface_counters");
4108 vat_json_init_array (msg_array);
4109 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4111 msg = vat_json_array_add (msg_array);
4112 vat_json_init_object (msg);
4113 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4114 (u8 *) counter_type_to_str (i, 0));
4115 vat_json_object_add_int (msg, "is_combined", 0);
4116 counter_array = vat_json_object_add (msg, "data");
4117 vat_json_init_array (counter_array);
4118 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4120 packets = vam->simple_interface_counters[i][j];
4121 vat_json_array_add_uint (counter_array, packets);
4124 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4126 msg = vat_json_array_add (msg_array);
4127 vat_json_init_object (msg);
4128 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4129 (u8 *) counter_type_to_str (i, 1));
4130 vat_json_object_add_int (msg, "is_combined", 1);
4131 counter_array = vat_json_object_add (msg, "data");
4132 vat_json_init_array (counter_array);
4133 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4135 c = vam->combined_interface_counters[i][j];
4136 counter = vat_json_array_add (counter_array);
4137 vat_json_init_object (counter);
4138 vat_json_object_add_uint (counter, "packets", c.packets);
4139 vat_json_object_add_uint (counter, "bytes", c.bytes);
4143 /* ip4 fib counters */
4144 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4145 vat_json_init_array (msg_array);
4146 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4148 msg = vat_json_array_add (msg_array);
4149 vat_json_init_object (msg);
4150 vat_json_object_add_uint (msg, "vrf_id",
4151 vam->ip4_fib_counters_vrf_id_by_index[i]);
4152 counter_array = vat_json_object_add (msg, "c");
4153 vat_json_init_array (counter_array);
4154 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4156 counter = vat_json_array_add (counter_array);
4157 vat_json_init_object (counter);
4158 c4 = &vam->ip4_fib_counters[i][j];
4159 vat_json_object_add_ip4 (counter, "address", c4->address);
4160 vat_json_object_add_uint (counter, "address_length",
4161 c4->address_length);
4162 vat_json_object_add_uint (counter, "packets", c4->packets);
4163 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4167 /* ip6 fib counters */
4168 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4169 vat_json_init_array (msg_array);
4170 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4172 msg = vat_json_array_add (msg_array);
4173 vat_json_init_object (msg);
4174 vat_json_object_add_uint (msg, "vrf_id",
4175 vam->ip6_fib_counters_vrf_id_by_index[i]);
4176 counter_array = vat_json_object_add (msg, "c");
4177 vat_json_init_array (counter_array);
4178 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4180 counter = vat_json_array_add (counter_array);
4181 vat_json_init_object (counter);
4182 c6 = &vam->ip6_fib_counters[i][j];
4183 vat_json_object_add_ip6 (counter, "address", c6->address);
4184 vat_json_object_add_uint (counter, "address_length",
4185 c6->address_length);
4186 vat_json_object_add_uint (counter, "packets", c6->packets);
4187 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4191 vat_json_print (vam->ofp, &node);
4192 vat_json_free (&node);
4198 exec (vat_main_t * vam)
4200 api_main_t *am = &api_main;
4201 vl_api_cli_request_t *mp;
4205 unformat_input_t *i = vam->input;
4207 if (vec_len (i->buffer) == 0)
4210 if (vam->exec_mode == 0 && unformat (i, "mode"))
4215 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4222 M (CLI_REQUEST, cli_request);
4225 * Copy cmd into shared memory.
4226 * In order for the CLI command to work, it
4227 * must be a vector ending in \n, not a C-string ending
4230 pthread_mutex_lock (&am->vlib_rp->mutex);
4231 oldheap = svm_push_data_heap (am->vlib_rp);
4233 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4234 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4236 svm_pop_heap (oldheap);
4237 pthread_mutex_unlock (&am->vlib_rp->mutex);
4239 mp->cmd_in_shmem = (u64) cmd;
4241 timeout = vat_time_now (vam) + 10.0;
4243 while (vat_time_now (vam) < timeout)
4245 if (vam->result_ready == 1)
4248 if (vam->shmem_result != NULL)
4249 fformat (vam->ofp, "%s", vam->shmem_result);
4250 pthread_mutex_lock (&am->vlib_rp->mutex);
4251 oldheap = svm_push_data_heap (am->vlib_rp);
4253 free_me = (u8 *) vam->shmem_result;
4256 svm_pop_heap (oldheap);
4257 pthread_mutex_unlock (&am->vlib_rp->mutex);
4265 * Future replacement of exec() that passes CLI buffers directly in
4266 * the API messages instead of an additional shared memory area.
4269 exec_inband (vat_main_t * vam)
4271 vl_api_cli_inband_t *mp;
4273 unformat_input_t *i = vam->input;
4275 if (vec_len (i->buffer) == 0)
4278 if (vam->exec_mode == 0 && unformat (i, "mode"))
4283 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4290 * In order for the CLI command to work, it
4291 * must be a vector ending in \n, not a C-string ending
4294 u32 len = vec_len (vam->input->buffer);
4295 M2 (CLI_INBAND, cli_inband, len);
4296 clib_memcpy (mp->cmd, vam->input->buffer, len);
4297 mp->length = htonl (len);
4300 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4304 api_create_loopback (vat_main_t * vam)
4306 unformat_input_t *i = vam->input;
4307 vl_api_create_loopback_t *mp;
4312 memset (mac_address, 0, sizeof (mac_address));
4314 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4316 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4322 /* Construct the API message */
4323 M (CREATE_LOOPBACK, create_loopback);
4325 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4332 api_delete_loopback (vat_main_t * vam)
4334 unformat_input_t *i = vam->input;
4335 vl_api_delete_loopback_t *mp;
4337 u32 sw_if_index = ~0;
4339 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4341 if (unformat (i, "sw_if_index %d", &sw_if_index))
4347 if (sw_if_index == ~0)
4349 errmsg ("missing sw_if_index\n");
4353 /* Construct the API message */
4354 M (DELETE_LOOPBACK, delete_loopback);
4355 mp->sw_if_index = ntohl (sw_if_index);
4362 api_want_stats (vat_main_t * vam)
4364 unformat_input_t *i = vam->input;
4365 vl_api_want_stats_t *mp;
4369 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4371 if (unformat (i, "enable"))
4373 else if (unformat (i, "disable"))
4381 errmsg ("missing enable|disable\n");
4385 M (WANT_STATS, want_stats);
4386 mp->enable_disable = enable;
4393 api_want_interface_events (vat_main_t * vam)
4395 unformat_input_t *i = vam->input;
4396 vl_api_want_interface_events_t *mp;
4400 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4402 if (unformat (i, "enable"))
4404 else if (unformat (i, "disable"))
4412 errmsg ("missing enable|disable\n");
4416 M (WANT_INTERFACE_EVENTS, want_interface_events);
4417 mp->enable_disable = enable;
4419 vam->interface_event_display = enable;
4426 /* Note: non-static, called once to set up the initial intfc table */
4428 api_sw_interface_dump (vat_main_t * vam)
4430 vl_api_sw_interface_dump_t *mp;
4433 name_sort_t *nses = 0, *ns;
4434 sw_interface_subif_t *sub = NULL;
4436 /* Toss the old name table */
4438 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4440 vec_add2 (nses, ns, 1);
4441 ns->name = (u8 *)(p->key);
4442 ns->value = (u32) p->value[0];
4446 hash_free (vam->sw_if_index_by_interface_name);
4448 vec_foreach (ns, nses) vec_free (ns->name);
4452 vec_foreach (sub, vam->sw_if_subif_table)
4454 vec_free (sub->interface_name);
4456 vec_free (vam->sw_if_subif_table);
4458 /* recreate the interface name hash table */
4459 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4461 /* Get list of ethernets */
4462 M (SW_INTERFACE_DUMP, sw_interface_dump);
4463 mp->name_filter_valid = 1;
4464 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4467 /* and local / loopback interfaces */
4468 M (SW_INTERFACE_DUMP, sw_interface_dump);
4469 mp->name_filter_valid = 1;
4470 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4473 /* and packet-generator interfaces */
4474 M (SW_INTERFACE_DUMP, sw_interface_dump);
4475 mp->name_filter_valid = 1;
4476 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4479 /* and vxlan-gpe tunnel interfaces */
4480 M (SW_INTERFACE_DUMP, sw_interface_dump);
4481 mp->name_filter_valid = 1;
4482 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4483 sizeof (mp->name_filter) - 1);
4486 /* and vxlan tunnel interfaces */
4487 M (SW_INTERFACE_DUMP, sw_interface_dump);
4488 mp->name_filter_valid = 1;
4489 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4492 /* and host (af_packet) interfaces */
4493 M (SW_INTERFACE_DUMP, sw_interface_dump);
4494 mp->name_filter_valid = 1;
4495 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4498 /* and l2tpv3 tunnel interfaces */
4499 M (SW_INTERFACE_DUMP, sw_interface_dump);
4500 mp->name_filter_valid = 1;
4501 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4502 sizeof (mp->name_filter) - 1);
4505 /* and GRE tunnel interfaces */
4506 M (SW_INTERFACE_DUMP, sw_interface_dump);
4507 mp->name_filter_valid = 1;
4508 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4511 /* and LISP-GPE interfaces */
4512 M (SW_INTERFACE_DUMP, sw_interface_dump);
4513 mp->name_filter_valid = 1;
4514 strncpy ((char *) mp->name_filter, "lisp_gpe",
4515 sizeof (mp->name_filter) - 1);
4518 /* and IPSEC tunnel interfaces */
4519 M (SW_INTERFACE_DUMP, sw_interface_dump);
4520 mp->name_filter_valid = 1;
4521 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4524 /* Use a control ping for synchronization */
4526 vl_api_control_ping_t *mp;
4527 M (CONTROL_PING, control_ping);
4534 api_sw_interface_set_flags (vat_main_t * vam)
4536 unformat_input_t *i = vam->input;
4537 vl_api_sw_interface_set_flags_t *mp;
4540 u8 sw_if_index_set = 0;
4541 u8 admin_up = 0, link_up = 0;
4543 /* Parse args required to build the message */
4544 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4546 if (unformat (i, "admin-up"))
4548 else if (unformat (i, "admin-down"))
4550 else if (unformat (i, "link-up"))
4552 else if (unformat (i, "link-down"))
4554 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4555 sw_if_index_set = 1;
4556 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4557 sw_if_index_set = 1;
4562 if (sw_if_index_set == 0)
4564 errmsg ("missing interface name or sw_if_index\n");
4568 /* Construct the API message */
4569 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4570 mp->sw_if_index = ntohl (sw_if_index);
4571 mp->admin_up_down = admin_up;
4572 mp->link_up_down = link_up;
4577 /* Wait for a reply, return the good/bad news... */
4582 api_sw_interface_clear_stats (vat_main_t * vam)
4584 unformat_input_t *i = vam->input;
4585 vl_api_sw_interface_clear_stats_t *mp;
4588 u8 sw_if_index_set = 0;
4590 /* Parse args required to build the message */
4591 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4593 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4594 sw_if_index_set = 1;
4595 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4596 sw_if_index_set = 1;
4601 /* Construct the API message */
4602 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4604 if (sw_if_index_set == 1)
4605 mp->sw_if_index = ntohl (sw_if_index);
4607 mp->sw_if_index = ~0;
4612 /* Wait for a reply, return the good/bad news... */
4617 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4619 unformat_input_t *i = vam->input;
4620 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4623 u8 sw_if_index_set = 0;
4631 /* Parse args required to build the message */
4632 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4634 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4635 sw_if_index_set = 1;
4636 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4637 sw_if_index_set = 1;
4638 else if (unformat (i, "subport %u", &subport))
4640 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4641 sw_if_index_set = 1;
4642 else if (unformat (i, "pipe %u", &pipe))
4644 else if (unformat (i, "profile %u", &profile))
4650 if (sw_if_index_set == 0)
4652 errmsg ("missing interface name or sw_if_index\n");
4656 if (subport_set == 0)
4658 errmsg ("missing subport \n");
4664 errmsg ("missing pipe\n");
4668 if (profile_set == 0)
4670 errmsg ("missing profile\n");
4674 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
4676 mp->sw_if_index = ntohl (sw_if_index);
4677 mp->subport = ntohl (subport);
4678 mp->pipe = ntohl (pipe);
4679 mp->profile = ntohl (profile);
4689 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
4691 unformat_input_t *i = vam->input;
4692 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
4695 u8 sw_if_index_set = 0;
4698 u32 tb_rate = 1250000000; /* 10GbE */
4699 u32 tb_size = 1000000;
4700 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
4703 /* Parse args required to build the message */
4704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4706 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4707 sw_if_index_set = 1;
4708 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4709 sw_if_index_set = 1;
4710 else if (unformat (i, "subport %u", &subport))
4712 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4713 sw_if_index_set = 1;
4714 else if (unformat (i, "rate %u", &tb_rate))
4718 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
4720 tc_rate[tc_id] = tb_rate;
4722 else if (unformat (i, "bktsize %u", &tb_size))
4724 else if (unformat (i, "tc0 %u", &tc_rate[0]))
4726 else if (unformat (i, "tc1 %u", &tc_rate[1]))
4728 else if (unformat (i, "tc2 %u", &tc_rate[2]))
4730 else if (unformat (i, "tc3 %u", &tc_rate[3]))
4732 else if (unformat (i, "period %u", &tc_period))
4738 if (sw_if_index_set == 0)
4740 errmsg ("missing interface name or sw_if_index\n");
4744 if (subport_set == 0)
4746 errmsg ("missing subport \n");
4750 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
4752 mp->sw_if_index = ntohl (sw_if_index);
4753 mp->subport = ntohl (subport);
4754 mp->tb_rate = ntohl (tb_rate);
4755 mp->tb_size = ntohl (tb_size);
4756 mp->tc_rate[0] = ntohl (tc_rate[0]);
4757 mp->tc_rate[1] = ntohl (tc_rate[1]);
4758 mp->tc_rate[2] = ntohl (tc_rate[2]);
4759 mp->tc_rate[3] = ntohl (tc_rate[3]);
4760 mp->tc_period = ntohl (tc_period);
4769 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
4771 unformat_input_t *i = vam->input;
4772 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
4775 u8 sw_if_index_set = 0;
4779 u32 entry, tc, queue;
4781 /* Parse args required to build the message */
4782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4784 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4785 sw_if_index_set = 1;
4786 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4787 sw_if_index_set = 1;
4788 else if (unformat (i, "entry %d", &entry))
4790 else if (unformat (i, "tc %d", &tc))
4792 else if (unformat (i, "queue %d", &queue))
4798 if (sw_if_index_set == 0)
4800 errmsg ("missing interface name or sw_if_index\n");
4806 errmsg ("missing entry \n");
4812 errmsg ("missing traffic class \n");
4818 errmsg ("missing queue \n");
4822 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
4824 mp->sw_if_index = ntohl (sw_if_index);
4825 mp->entry = ntohl (entry);
4826 mp->tc = ntohl (tc);
4827 mp->queue = ntohl (queue);
4836 api_sw_interface_add_del_address (vat_main_t * vam)
4838 unformat_input_t *i = vam->input;
4839 vl_api_sw_interface_add_del_address_t *mp;
4842 u8 sw_if_index_set = 0;
4843 u8 is_add = 1, del_all = 0;
4844 u32 address_length = 0;
4845 u8 v4_address_set = 0;
4846 u8 v6_address_set = 0;
4847 ip4_address_t v4address;
4848 ip6_address_t v6address;
4850 /* Parse args required to build the message */
4851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4853 if (unformat (i, "del-all"))
4855 else if (unformat (i, "del"))
4857 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4858 sw_if_index_set = 1;
4859 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4860 sw_if_index_set = 1;
4861 else if (unformat (i, "%U/%d",
4862 unformat_ip4_address, &v4address, &address_length))
4864 else if (unformat (i, "%U/%d",
4865 unformat_ip6_address, &v6address, &address_length))
4871 if (sw_if_index_set == 0)
4873 errmsg ("missing interface name or sw_if_index\n");
4876 if (v4_address_set && v6_address_set)
4878 errmsg ("both v4 and v6 addresses set\n");
4881 if (!v4_address_set && !v6_address_set && !del_all)
4883 errmsg ("no addresses set\n");
4887 /* Construct the API message */
4888 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4890 mp->sw_if_index = ntohl (sw_if_index);
4891 mp->is_add = is_add;
4892 mp->del_all = del_all;
4896 clib_memcpy (mp->address, &v6address, sizeof (v6address));
4900 clib_memcpy (mp->address, &v4address, sizeof (v4address));
4902 mp->address_length = address_length;
4907 /* Wait for a reply, return good/bad news */
4912 api_sw_interface_set_mpls_enable (vat_main_t * vam)
4914 unformat_input_t *i = vam->input;
4915 vl_api_sw_interface_set_mpls_enable_t *mp;
4918 u8 sw_if_index_set = 0;
4921 /* Parse args required to build the message */
4922 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4924 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4925 sw_if_index_set = 1;
4926 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4927 sw_if_index_set = 1;
4928 else if (unformat (i, "disable"))
4930 else if (unformat (i, "dis"))
4936 if (sw_if_index_set == 0)
4938 errmsg ("missing interface name or sw_if_index\n");
4942 /* Construct the API message */
4943 M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable);
4945 mp->sw_if_index = ntohl (sw_if_index);
4946 mp->enable = enable;
4951 /* Wait for a reply... */
4956 api_sw_interface_set_table (vat_main_t * vam)
4958 unformat_input_t *i = vam->input;
4959 vl_api_sw_interface_set_table_t *mp;
4961 u32 sw_if_index, vrf_id = 0;
4962 u8 sw_if_index_set = 0;
4965 /* Parse args required to build the message */
4966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4968 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4969 sw_if_index_set = 1;
4970 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4971 sw_if_index_set = 1;
4972 else if (unformat (i, "vrf %d", &vrf_id))
4974 else if (unformat (i, "ipv6"))
4980 if (sw_if_index_set == 0)
4982 errmsg ("missing interface name or sw_if_index\n");
4986 /* Construct the API message */
4987 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
4989 mp->sw_if_index = ntohl (sw_if_index);
4990 mp->is_ipv6 = is_ipv6;
4991 mp->vrf_id = ntohl (vrf_id);
4996 /* Wait for a reply... */
5001 api_sw_interface_set_vpath (vat_main_t * vam)
5003 unformat_input_t *i = vam->input;
5004 vl_api_sw_interface_set_vpath_t *mp;
5006 u32 sw_if_index = 0;
5007 u8 sw_if_index_set = 0;
5010 /* Parse args required to build the message */
5011 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5013 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5014 sw_if_index_set = 1;
5015 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5016 sw_if_index_set = 1;
5017 else if (unformat (i, "enable"))
5019 else if (unformat (i, "disable"))
5025 if (sw_if_index_set == 0)
5027 errmsg ("missing interface name or sw_if_index\n");
5031 /* Construct the API message */
5032 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
5034 mp->sw_if_index = ntohl (sw_if_index);
5035 mp->enable = is_enable;
5040 /* Wait for a reply... */
5045 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5047 unformat_input_t *i = vam->input;
5048 vl_api_sw_interface_set_l2_xconnect_t *mp;
5051 u8 rx_sw_if_index_set = 0;
5053 u8 tx_sw_if_index_set = 0;
5056 /* Parse args required to build the message */
5057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5059 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5060 rx_sw_if_index_set = 1;
5061 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5062 tx_sw_if_index_set = 1;
5063 else if (unformat (i, "rx"))
5065 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5067 if (unformat (i, "%U", unformat_sw_if_index, vam,
5069 rx_sw_if_index_set = 1;
5074 else if (unformat (i, "tx"))
5076 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5078 if (unformat (i, "%U", unformat_sw_if_index, vam,
5080 tx_sw_if_index_set = 1;
5085 else if (unformat (i, "enable"))
5087 else if (unformat (i, "disable"))
5093 if (rx_sw_if_index_set == 0)
5095 errmsg ("missing rx interface name or rx_sw_if_index\n");
5099 if (enable && (tx_sw_if_index_set == 0))
5101 errmsg ("missing tx interface name or tx_sw_if_index\n");
5105 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
5107 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5108 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5109 mp->enable = enable;
5118 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5120 unformat_input_t *i = vam->input;
5121 vl_api_sw_interface_set_l2_bridge_t *mp;
5124 u8 rx_sw_if_index_set = 0;
5131 /* Parse args required to build the message */
5132 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5134 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5135 rx_sw_if_index_set = 1;
5136 else if (unformat (i, "bd_id %d", &bd_id))
5138 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
5139 rx_sw_if_index_set = 1;
5140 else if (unformat (i, "shg %d", &shg))
5142 else if (unformat (i, "bvi"))
5144 else if (unformat (i, "enable"))
5146 else if (unformat (i, "disable"))
5152 if (rx_sw_if_index_set == 0)
5154 errmsg ("missing rx interface name or sw_if_index\n");
5158 if (enable && (bd_id_set == 0))
5160 errmsg ("missing bridge domain\n");
5164 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5166 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5167 mp->bd_id = ntohl (bd_id);
5170 mp->enable = enable;
5179 api_bridge_domain_dump (vat_main_t * vam)
5181 unformat_input_t *i = vam->input;
5182 vl_api_bridge_domain_dump_t *mp;
5186 /* Parse args required to build the message */
5187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5189 if (unformat (i, "bd_id %d", &bd_id))
5195 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5196 mp->bd_id = ntohl (bd_id);
5199 /* Use a control ping for synchronization */
5201 vl_api_control_ping_t *mp;
5202 M (CONTROL_PING, control_ping);
5212 api_bridge_domain_add_del (vat_main_t * vam)
5214 unformat_input_t *i = vam->input;
5215 vl_api_bridge_domain_add_del_t *mp;
5219 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5221 /* Parse args required to build the message */
5222 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5224 if (unformat (i, "bd_id %d", &bd_id))
5226 else if (unformat (i, "flood %d", &flood))
5228 else if (unformat (i, "uu-flood %d", &uu_flood))
5230 else if (unformat (i, "forward %d", &forward))
5232 else if (unformat (i, "learn %d", &learn))
5234 else if (unformat (i, "arp-term %d", &arp_term))
5236 else if (unformat (i, "del"))
5239 flood = uu_flood = forward = learn = 0;
5247 errmsg ("missing bridge domain\n");
5251 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5253 mp->bd_id = ntohl (bd_id);
5255 mp->uu_flood = uu_flood;
5256 mp->forward = forward;
5258 mp->arp_term = arp_term;
5259 mp->is_add = is_add;
5268 api_l2fib_add_del (vat_main_t * vam)
5270 unformat_input_t *i = vam->input;
5271 vl_api_l2fib_add_del_t *mp;
5278 u8 sw_if_index_set = 0;
5287 /* Parse args required to build the message */
5288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5290 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5292 else if (unformat (i, "bd_id %d", &bd_id))
5294 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5295 sw_if_index_set = 1;
5296 else if (unformat (i, "sw_if"))
5298 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5300 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5301 sw_if_index_set = 1;
5306 else if (unformat (i, "static"))
5308 else if (unformat (i, "filter"))
5313 else if (unformat (i, "bvi"))
5318 else if (unformat (i, "del"))
5320 else if (unformat (i, "count %d", &count))
5328 errmsg ("missing mac address\n");
5334 errmsg ("missing bridge domain\n");
5338 if (is_add && (sw_if_index_set == 0))
5340 errmsg ("missing interface name or sw_if_index\n");
5346 /* Turn on async mode */
5347 vam->async_mode = 1;
5348 vam->async_errors = 0;
5349 before = vat_time_now (vam);
5352 for (j = 0; j < count; j++)
5354 M (L2FIB_ADD_DEL, l2fib_add_del);
5357 mp->bd_id = ntohl (bd_id);
5358 mp->is_add = is_add;
5362 mp->sw_if_index = ntohl (sw_if_index);
5363 mp->static_mac = static_mac;
5364 mp->filter_mac = filter_mac;
5365 mp->bvi_mac = bvi_mac;
5367 increment_mac_address (&mac);
5374 vl_api_control_ping_t *mp;
5377 /* Shut off async mode */
5378 vam->async_mode = 0;
5380 M (CONTROL_PING, control_ping);
5383 timeout = vat_time_now (vam) + 1.0;
5384 while (vat_time_now (vam) < timeout)
5385 if (vam->result_ready == 1)
5390 if (vam->retval == -99)
5391 errmsg ("timeout\n");
5393 if (vam->async_errors > 0)
5395 errmsg ("%d asynchronous errors\n", vam->async_errors);
5398 vam->async_errors = 0;
5399 after = vat_time_now (vam);
5401 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5402 count, after - before, count / (after - before));
5406 /* Wait for a reply... */
5409 /* Return the good/bad news */
5410 return (vam->retval);
5414 api_l2_flags (vat_main_t * vam)
5416 unformat_input_t *i = vam->input;
5417 vl_api_l2_flags_t *mp;
5420 u32 feature_bitmap = 0;
5421 u8 sw_if_index_set = 0;
5423 /* Parse args required to build the message */
5424 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5426 if (unformat (i, "sw_if_index %d", &sw_if_index))
5427 sw_if_index_set = 1;
5428 else if (unformat (i, "sw_if"))
5430 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5432 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5433 sw_if_index_set = 1;
5438 else if (unformat (i, "learn"))
5439 feature_bitmap |= L2INPUT_FEAT_LEARN;
5440 else if (unformat (i, "forward"))
5441 feature_bitmap |= L2INPUT_FEAT_FWD;
5442 else if (unformat (i, "flood"))
5443 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5444 else if (unformat (i, "uu-flood"))
5445 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5450 if (sw_if_index_set == 0)
5452 errmsg ("missing interface name or sw_if_index\n");
5456 M (L2_FLAGS, l2_flags);
5458 mp->sw_if_index = ntohl (sw_if_index);
5459 mp->feature_bitmap = ntohl (feature_bitmap);
5468 api_bridge_flags (vat_main_t * vam)
5470 unformat_input_t *i = vam->input;
5471 vl_api_bridge_flags_t *mp;
5478 /* Parse args required to build the message */
5479 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5481 if (unformat (i, "bd_id %d", &bd_id))
5483 else if (unformat (i, "learn"))
5485 else if (unformat (i, "forward"))
5487 else if (unformat (i, "flood"))
5489 else if (unformat (i, "uu-flood"))
5490 flags |= L2_UU_FLOOD;
5491 else if (unformat (i, "arp-term"))
5492 flags |= L2_ARP_TERM;
5493 else if (unformat (i, "off"))
5495 else if (unformat (i, "disable"))
5503 errmsg ("missing bridge domain\n");
5507 M (BRIDGE_FLAGS, bridge_flags);
5509 mp->bd_id = ntohl (bd_id);
5510 mp->feature_bitmap = ntohl (flags);
5511 mp->is_set = is_set;
5520 api_bd_ip_mac_add_del (vat_main_t * vam)
5522 unformat_input_t *i = vam->input;
5523 vl_api_bd_ip_mac_add_del_t *mp;
5531 ip4_address_t v4addr;
5532 ip6_address_t v6addr;
5536 /* Parse args required to build the message */
5537 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5539 if (unformat (i, "bd_id %d", &bd_id))
5543 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5547 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5552 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5556 else if (unformat (i, "del"))
5564 errmsg ("missing bridge domain\n");
5567 else if (ip_set == 0)
5569 errmsg ("missing IP address\n");
5572 else if (mac_set == 0)
5574 errmsg ("missing MAC address\n");
5578 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5580 mp->bd_id = ntohl (bd_id);
5581 mp->is_ipv6 = is_ipv6;
5582 mp->is_add = is_add;
5584 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5586 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5587 clib_memcpy (mp->mac_address, macaddr, 6);
5595 api_tap_connect (vat_main_t * vam)
5597 unformat_input_t *i = vam->input;
5598 vl_api_tap_connect_t *mp;
5605 memset (mac_address, 0, sizeof (mac_address));
5607 /* Parse args required to build the message */
5608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5610 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5614 else if (unformat (i, "random-mac"))
5616 else if (unformat (i, "tapname %s", &tap_name))
5624 errmsg ("missing tap name\n");
5627 if (vec_len (tap_name) > 63)
5629 errmsg ("tap name too long\n");
5631 vec_add1 (tap_name, 0);
5633 /* Construct the API message */
5634 M (TAP_CONNECT, tap_connect);
5636 mp->use_random_mac = random_mac;
5637 clib_memcpy (mp->mac_address, mac_address, 6);
5638 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5639 vec_free (tap_name);
5644 /* Wait for a reply... */
5649 api_tap_modify (vat_main_t * vam)
5651 unformat_input_t *i = vam->input;
5652 vl_api_tap_modify_t *mp;
5658 u32 sw_if_index = ~0;
5659 u8 sw_if_index_set = 0;
5661 memset (mac_address, 0, sizeof (mac_address));
5663 /* Parse args required to build the message */
5664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5666 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5667 sw_if_index_set = 1;
5668 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5669 sw_if_index_set = 1;
5670 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5674 else if (unformat (i, "random-mac"))
5676 else if (unformat (i, "tapname %s", &tap_name))
5682 if (sw_if_index_set == 0)
5684 errmsg ("missing vpp interface name");
5689 errmsg ("missing tap name\n");
5692 if (vec_len (tap_name) > 63)
5694 errmsg ("tap name too long\n");
5696 vec_add1 (tap_name, 0);
5698 /* Construct the API message */
5699 M (TAP_MODIFY, tap_modify);
5701 mp->use_random_mac = random_mac;
5702 mp->sw_if_index = ntohl (sw_if_index);
5703 clib_memcpy (mp->mac_address, mac_address, 6);
5704 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5705 vec_free (tap_name);
5710 /* Wait for a reply... */
5715 api_tap_delete (vat_main_t * vam)
5717 unformat_input_t *i = vam->input;
5718 vl_api_tap_delete_t *mp;
5720 u32 sw_if_index = ~0;
5721 u8 sw_if_index_set = 0;
5723 /* Parse args required to build the message */
5724 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5726 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5727 sw_if_index_set = 1;
5728 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5729 sw_if_index_set = 1;
5734 if (sw_if_index_set == 0)
5736 errmsg ("missing vpp interface name");
5740 /* Construct the API message */
5741 M (TAP_DELETE, tap_delete);
5743 mp->sw_if_index = ntohl (sw_if_index);
5748 /* Wait for a reply... */
5753 api_ip_add_del_route (vat_main_t * vam)
5755 unformat_input_t *i = vam->input;
5756 vl_api_ip_add_del_route_t *mp;
5758 u32 sw_if_index = ~0, vrf_id = 0;
5759 u8 sw_if_index_set = 0;
5761 u8 is_local = 0, is_drop = 0;
5762 u8 is_unreach = 0, is_prohibit = 0;
5763 u8 create_vrf_if_needed = 0;
5765 u8 next_hop_weight = 1;
5767 u8 is_multipath = 0;
5769 u8 address_length_set = 0;
5770 u32 next_hop_table_id = 0;
5771 u32 resolve_attempts = 0;
5772 u32 dst_address_length = 0;
5773 u8 next_hop_set = 0;
5774 ip4_address_t v4_dst_address, v4_next_hop_address;
5775 ip6_address_t v6_dst_address, v6_next_hop_address;
5779 u32 random_add_del = 0;
5780 u32 *random_vector = 0;
5782 u32 random_seed = 0xdeaddabe;
5783 u32 classify_table_index = ~0;
5785 u8 resolve_host = 0, resolve_attached = 0;
5786 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
5788 /* Parse args required to build the message */
5789 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5791 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5792 sw_if_index_set = 1;
5793 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5794 sw_if_index_set = 1;
5795 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
5800 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
5805 else if (unformat (i, "/%d", &dst_address_length))
5807 address_length_set = 1;
5810 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
5811 &v4_next_hop_address))
5815 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
5816 &v6_next_hop_address))
5820 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
5822 else if (unformat (i, "weight %d", &next_hop_weight))
5824 else if (unformat (i, "drop"))
5828 else if (unformat (i, "null-send-unreach"))
5832 else if (unformat (i, "null-send-prohibit"))
5836 else if (unformat (i, "local"))
5840 else if (unformat (i, "classify %d", &classify_table_index))
5844 else if (unformat (i, "del"))
5846 else if (unformat (i, "add"))
5848 else if (unformat (i, "not-last"))
5850 else if (unformat (i, "resolve-via-host"))
5852 else if (unformat (i, "resolve-via-attached"))
5853 resolve_attached = 1;
5854 else if (unformat (i, "multipath"))
5856 else if (unformat (i, "vrf %d", &vrf_id))
5858 else if (unformat (i, "create-vrf"))
5859 create_vrf_if_needed = 1;
5860 else if (unformat (i, "count %d", &count))
5862 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
5864 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
5866 else if (unformat (i, "out-label %d", &next_hop_out_label))
5868 else if (unformat (i, "random"))
5870 else if (unformat (i, "seed %d", &random_seed))
5874 clib_warning ("parse error '%U'", format_unformat_error, i);
5879 if (resolve_attempts > 0 && sw_if_index_set == 0)
5881 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
5885 if (!next_hop_set && !is_drop && !is_local &&
5886 !is_classify && !is_unreach && !is_prohibit)
5889 ("next hop / local / drop / unreach / prohibit / classify not set\n");
5893 if (address_set == 0)
5895 errmsg ("missing addresses\n");
5899 if (address_length_set == 0)
5901 errmsg ("missing address length\n");
5905 /* Generate a pile of unique, random routes */
5908 u32 this_random_address;
5909 random_hash = hash_create (count, sizeof (uword));
5911 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
5912 for (j = 0; j <= count; j++)
5916 this_random_address = random_u32 (&random_seed);
5917 this_random_address =
5918 clib_host_to_net_u32 (this_random_address);
5920 while (hash_get (random_hash, this_random_address));
5921 vec_add1 (random_vector, this_random_address);
5922 hash_set (random_hash, this_random_address, 1);
5924 hash_free (random_hash);
5925 v4_dst_address.as_u32 = random_vector[0];
5930 /* Turn on async mode */
5931 vam->async_mode = 1;
5932 vam->async_errors = 0;
5933 before = vat_time_now (vam);
5936 for (j = 0; j < count; j++)
5938 /* Construct the API message */
5939 M (IP_ADD_DEL_ROUTE, ip_add_del_route);
5941 mp->next_hop_sw_if_index = ntohl (sw_if_index);
5942 mp->table_id = ntohl (vrf_id);
5943 if (resolve_attempts > 0)
5945 mp->resolve_attempts = ntohl (resolve_attempts);
5946 mp->resolve_if_needed = 1;
5948 mp->create_vrf_if_needed = create_vrf_if_needed;
5950 mp->is_add = is_add;
5951 mp->is_drop = is_drop;
5952 mp->is_unreach = is_unreach;
5953 mp->is_prohibit = is_prohibit;
5954 mp->is_ipv6 = is_ipv6;
5955 mp->is_local = is_local;
5956 mp->is_classify = is_classify;
5957 mp->is_multipath = is_multipath;
5958 mp->is_resolve_host = resolve_host;
5959 mp->is_resolve_attached = resolve_attached;
5960 mp->not_last = not_last;
5961 mp->next_hop_weight = next_hop_weight;
5962 mp->dst_address_length = dst_address_length;
5963 mp->next_hop_table_id = ntohl (next_hop_table_id);
5964 mp->classify_table_index = ntohl (classify_table_index);
5965 mp->next_hop_out_label = ntohl (next_hop_out_label);
5969 clib_memcpy (mp->dst_address, &v6_dst_address,
5970 sizeof (v6_dst_address));
5972 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
5973 sizeof (v6_next_hop_address));
5974 increment_v6_address (&v6_dst_address);
5978 clib_memcpy (mp->dst_address, &v4_dst_address,
5979 sizeof (v4_dst_address));
5981 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
5982 sizeof (v4_next_hop_address));
5984 v4_dst_address.as_u32 = random_vector[j + 1];
5986 increment_v4_address (&v4_dst_address);
5990 /* If we receive SIGTERM, stop now... */
5995 /* When testing multiple add/del ops, use a control-ping to sync */
5998 vl_api_control_ping_t *mp;
6001 /* Shut off async mode */
6002 vam->async_mode = 0;
6004 M (CONTROL_PING, control_ping);
6007 timeout = vat_time_now (vam) + 1.0;
6008 while (vat_time_now (vam) < timeout)
6009 if (vam->result_ready == 1)
6014 if (vam->retval == -99)
6015 errmsg ("timeout\n");
6017 if (vam->async_errors > 0)
6019 errmsg ("%d asynchronous errors\n", vam->async_errors);
6022 vam->async_errors = 0;
6023 after = vat_time_now (vam);
6025 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6029 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6030 count, after - before, count / (after - before));
6034 /* Wait for a reply... */
6038 /* Return the good/bad news */
6039 return (vam->retval);
6043 api_mpls_route_add_del (vat_main_t * vam)
6045 unformat_input_t *i = vam->input;
6046 vl_api_mpls_route_add_del_t *mp;
6048 u32 sw_if_index = ~0, table_id = 0;
6049 u8 create_table_if_needed = 0;
6051 u8 next_hop_weight = 1;
6052 u8 is_multipath = 0;
6053 u32 next_hop_table_id = 0;
6054 u8 next_hop_set = 0;
6055 ip4_address_t v4_next_hop_address = {
6058 ip6_address_t v6_next_hop_address = { {0} };
6062 u32 classify_table_index = ~0;
6064 u8 resolve_host = 0, resolve_attached = 0;
6065 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6066 mpls_label_t local_label = MPLS_LABEL_INVALID;
6068 u8 next_hop_proto_is_ip4 = 1;
6070 /* Parse args required to build the message */
6071 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6073 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6075 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6077 else if (unformat (i, "%d", &local_label))
6079 else if (unformat (i, "eos"))
6081 else if (unformat (i, "non-eos"))
6083 else if (unformat (i, "via %U", unformat_ip4_address,
6084 &v4_next_hop_address))
6087 next_hop_proto_is_ip4 = 1;
6089 else if (unformat (i, "via %U", unformat_ip6_address,
6090 &v6_next_hop_address))
6093 next_hop_proto_is_ip4 = 0;
6095 else if (unformat (i, "weight %d", &next_hop_weight))
6097 else if (unformat (i, "create-table"))
6098 create_table_if_needed = 1;
6099 else if (unformat (i, "classify %d", &classify_table_index))
6103 else if (unformat (i, "del"))
6105 else if (unformat (i, "add"))
6107 else if (unformat (i, "resolve-via-host"))
6109 else if (unformat (i, "resolve-via-attached"))
6110 resolve_attached = 1;
6111 else if (unformat (i, "multipath"))
6113 else if (unformat (i, "count %d", &count))
6115 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6118 next_hop_proto_is_ip4 = 1;
6120 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6123 next_hop_proto_is_ip4 = 0;
6125 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6127 else if (unformat (i, "out-label %d", &next_hop_out_label))
6131 clib_warning ("parse error '%U'", format_unformat_error, i);
6136 if (!next_hop_set && !is_classify)
6138 errmsg ("next hop / classify not set\n");
6142 if (MPLS_LABEL_INVALID == local_label)
6144 errmsg ("missing label\n");
6150 /* Turn on async mode */
6151 vam->async_mode = 1;
6152 vam->async_errors = 0;
6153 before = vat_time_now (vam);
6156 for (j = 0; j < count; j++)
6158 /* Construct the API message */
6159 M (MPLS_ROUTE_ADD_DEL, mpls_route_add_del);
6161 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6162 mp->mr_table_id = ntohl (table_id);
6163 mp->mr_create_table_if_needed = create_table_if_needed;
6165 mp->mr_is_add = is_add;
6166 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6167 mp->mr_is_classify = is_classify;
6168 mp->mr_is_multipath = is_multipath;
6169 mp->mr_is_resolve_host = resolve_host;
6170 mp->mr_is_resolve_attached = resolve_attached;
6171 mp->mr_next_hop_weight = next_hop_weight;
6172 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6173 mp->mr_classify_table_index = ntohl (classify_table_index);
6174 mp->mr_next_hop_out_label = ntohl (next_hop_out_label);
6175 mp->mr_label = ntohl (local_label);
6176 mp->mr_eos = is_eos;
6180 if (next_hop_proto_is_ip4)
6182 clib_memcpy (mp->mr_next_hop,
6183 &v4_next_hop_address,
6184 sizeof (v4_next_hop_address));
6188 clib_memcpy (mp->mr_next_hop,
6189 &v6_next_hop_address,
6190 sizeof (v6_next_hop_address));
6197 /* If we receive SIGTERM, stop now... */
6202 /* When testing multiple add/del ops, use a control-ping to sync */
6205 vl_api_control_ping_t *mp;
6208 /* Shut off async mode */
6209 vam->async_mode = 0;
6211 M (CONTROL_PING, control_ping);
6214 timeout = vat_time_now (vam) + 1.0;
6215 while (vat_time_now (vam) < timeout)
6216 if (vam->result_ready == 1)
6221 if (vam->retval == -99)
6222 errmsg ("timeout\n");
6224 if (vam->async_errors > 0)
6226 errmsg ("%d asynchronous errors\n", vam->async_errors);
6229 vam->async_errors = 0;
6230 after = vat_time_now (vam);
6232 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6236 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6237 count, after - before, count / (after - before));
6241 /* Wait for a reply... */
6245 /* Return the good/bad news */
6246 return (vam->retval);
6250 api_mpls_ip_bind_unbind (vat_main_t * vam)
6252 unformat_input_t *i = vam->input;
6253 vl_api_mpls_ip_bind_unbind_t *mp;
6255 u32 ip_table_id = 0;
6256 u8 create_table_if_needed = 0;
6259 ip4_address_t v4_address;
6260 ip6_address_t v6_address;
6263 mpls_label_t local_label = MPLS_LABEL_INVALID;
6265 /* Parse args required to build the message */
6266 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6268 if (unformat (i, "%U/%d", unformat_ip4_address,
6269 &v4_address, &address_length))
6274 else if (unformat (i, "%U/%d", unformat_ip6_address,
6275 &v6_address, &address_length))
6280 else if (unformat (i, "%d", &local_label))
6282 else if (unformat (i, "create-table"))
6283 create_table_if_needed = 1;
6284 else if (unformat (i, "table-id %d", &ip_table_id))
6286 else if (unformat (i, "unbind"))
6288 else if (unformat (i, "bind"))
6292 clib_warning ("parse error '%U'", format_unformat_error, i);
6299 errmsg ("IP addres not set\n");
6303 if (MPLS_LABEL_INVALID == local_label)
6305 errmsg ("missing label\n");
6309 /* Construct the API message */
6310 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6312 mp->mb_create_table_if_needed = create_table_if_needed;
6313 mp->mb_is_bind = is_bind;
6314 mp->mb_is_ip4 = is_ip4;
6315 mp->mb_ip_table_id = ntohl (ip_table_id);
6316 mp->mb_mpls_table_id = 0;
6317 mp->mb_label = ntohl (local_label);
6318 mp->mb_address_length = address_length;
6321 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6323 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6328 /* Wait for a reply... */
6333 api_proxy_arp_add_del (vat_main_t * vam)
6335 unformat_input_t *i = vam->input;
6336 vl_api_proxy_arp_add_del_t *mp;
6340 ip4_address_t lo, hi;
6343 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6345 if (unformat (i, "vrf %d", &vrf_id))
6347 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6348 unformat_ip4_address, &hi))
6350 else if (unformat (i, "del"))
6354 clib_warning ("parse error '%U'", format_unformat_error, i);
6361 errmsg ("address range not set\n");
6365 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
6367 mp->vrf_id = ntohl (vrf_id);
6368 mp->is_add = is_add;
6369 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6370 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6379 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6381 unformat_input_t *i = vam->input;
6382 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6386 u8 sw_if_index_set = 0;
6388 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6390 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6391 sw_if_index_set = 1;
6392 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6393 sw_if_index_set = 1;
6394 else if (unformat (i, "enable"))
6396 else if (unformat (i, "disable"))
6400 clib_warning ("parse error '%U'", format_unformat_error, i);
6405 if (sw_if_index_set == 0)
6407 errmsg ("missing interface name or sw_if_index\n");
6411 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
6413 mp->sw_if_index = ntohl (sw_if_index);
6414 mp->enable_disable = enable;
6423 api_mpls_add_del_encap (vat_main_t * vam)
6425 unformat_input_t *i = vam->input;
6426 vl_api_mpls_add_del_encap_t *mp;
6431 ip4_address_t dst_address;
6434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6436 if (unformat (i, "vrf %d", &vrf_id))
6438 else if (unformat (i, "label %d", &label))
6439 vec_add1 (labels, ntohl (label));
6440 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
6442 else if (unformat (i, "del"))
6446 clib_warning ("parse error '%U'", format_unformat_error, i);
6451 if (vec_len (labels) == 0)
6453 errmsg ("missing encap label stack\n");
6457 M2 (MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
6458 sizeof (u32) * vec_len (labels));
6460 mp->vrf_id = ntohl (vrf_id);
6461 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
6462 mp->is_add = is_add;
6463 mp->nlabels = vec_len (labels);
6464 clib_memcpy (mp->labels, labels, sizeof (u32) * mp->nlabels);
6475 api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
6477 unformat_input_t *i = vam->input;
6478 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
6480 u32 inner_vrf_id = 0;
6481 ip4_address_t intfc_address;
6482 u8 dst_mac_address[6];
6485 u8 intfc_address_length = 0;
6489 int tx_sw_if_index_set = 0;
6491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6493 if (unformat (i, "vrf %d", &inner_vrf_id))
6495 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6496 &intfc_address, &tmp))
6497 intfc_address_length = tmp;
6498 else if (unformat (i, "%U", unformat_sw_if_index, vam, &tx_sw_if_index))
6499 tx_sw_if_index_set = 1;
6500 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
6501 tx_sw_if_index_set = 1;
6502 else if (unformat (i, "dst %U", unformat_ethernet_address,
6505 else if (unformat (i, "l2-only"))
6507 else if (unformat (i, "del"))
6511 clib_warning ("parse error '%U'", format_unformat_error, i);
6518 errmsg ("dst (mac address) not set\n");
6521 if (!tx_sw_if_index_set)
6523 errmsg ("tx-intfc not set\n");
6527 M (MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
6529 mp->vrf_id = ntohl (inner_vrf_id);
6530 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
6531 mp->adj_address_length = intfc_address_length;
6532 clib_memcpy (mp->dst_mac_address, dst_mac_address,
6533 sizeof (dst_mac_address));
6534 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
6535 mp->l2_only = l2_only;
6536 mp->is_add = is_add;
6545 api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
6547 unformat_input_t *i = vam->input;
6548 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
6550 u32 inner_vrf_id = 0;
6551 u32 outer_vrf_id = 0;
6552 ip4_address_t adj_address;
6553 int adj_address_set = 0;
6554 ip4_address_t next_hop_address;
6555 int next_hop_address_set = 0;
6557 u8 adj_address_length = 0;
6560 u32 resolve_attempts = 5;
6561 u8 resolve_if_needed = 1;
6563 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6565 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
6567 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
6569 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
6570 &adj_address, &tmp))
6572 adj_address_length = tmp;
6573 adj_address_set = 1;
6575 else if (unformat (i, "next-hop %U", unformat_ip4_address,
6577 next_hop_address_set = 1;
6578 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6580 else if (unformat (i, "resolve-if-needed %d", &tmp))
6581 resolve_if_needed = tmp;
6582 else if (unformat (i, "l2-only"))
6584 else if (unformat (i, "del"))
6588 clib_warning ("parse error '%U'", format_unformat_error, i);
6593 if (!adj_address_set)
6595 errmsg ("adjacency address/mask not set\n");
6598 if (!next_hop_address_set)
6600 errmsg ("ip4 next hop address (in outer fib) not set\n");
6604 M (MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
6606 mp->inner_vrf_id = ntohl (inner_vrf_id);
6607 mp->outer_vrf_id = ntohl (outer_vrf_id);
6608 mp->resolve_attempts = ntohl (resolve_attempts);
6609 mp->resolve_if_needed = resolve_if_needed;
6610 mp->is_add = is_add;
6611 mp->l2_only = l2_only;
6612 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
6613 mp->adj_address_length = adj_address_length;
6614 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
6615 sizeof (next_hop_address));
6624 api_sw_interface_set_unnumbered (vat_main_t * vam)
6626 unformat_input_t *i = vam->input;
6627 vl_api_sw_interface_set_unnumbered_t *mp;
6630 u32 unnum_sw_index = ~0;
6632 u8 sw_if_index_set = 0;
6634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6636 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6637 sw_if_index_set = 1;
6638 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6639 sw_if_index_set = 1;
6640 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6642 else if (unformat (i, "del"))
6646 clib_warning ("parse error '%U'", format_unformat_error, i);
6651 if (sw_if_index_set == 0)
6653 errmsg ("missing interface name or sw_if_index\n");
6657 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6659 mp->sw_if_index = ntohl (sw_if_index);
6660 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6661 mp->is_add = is_add;
6670 api_ip_neighbor_add_del (vat_main_t * vam)
6672 unformat_input_t *i = vam->input;
6673 vl_api_ip_neighbor_add_del_t *mp;
6676 u8 sw_if_index_set = 0;
6682 u8 v4_address_set = 0;
6683 u8 v6_address_set = 0;
6684 ip4_address_t v4address;
6685 ip6_address_t v6address;
6687 memset (mac_address, 0, sizeof (mac_address));
6689 /* Parse args required to build the message */
6690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6692 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6696 else if (unformat (i, "del"))
6698 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6699 sw_if_index_set = 1;
6700 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6701 sw_if_index_set = 1;
6702 else if (unformat (i, "is_static"))
6704 else if (unformat (i, "vrf %d", &vrf_id))
6706 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6708 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6712 clib_warning ("parse error '%U'", format_unformat_error, i);
6717 if (sw_if_index_set == 0)
6719 errmsg ("missing interface name or sw_if_index\n");
6722 if (v4_address_set && v6_address_set)
6724 errmsg ("both v4 and v6 addresses set\n");
6727 if (!v4_address_set && !v6_address_set)
6729 errmsg ("no address set\n");
6733 /* Construct the API message */
6734 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6736 mp->sw_if_index = ntohl (sw_if_index);
6737 mp->is_add = is_add;
6738 mp->vrf_id = ntohl (vrf_id);
6739 mp->is_static = is_static;
6741 clib_memcpy (mp->mac_address, mac_address, 6);
6745 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6749 /* mp->is_ipv6 = 0; via memset in M macro above */
6750 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6756 /* Wait for a reply, return good/bad news */
6764 api_reset_vrf (vat_main_t * vam)
6766 unformat_input_t *i = vam->input;
6767 vl_api_reset_vrf_t *mp;
6773 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6775 if (unformat (i, "vrf %d", &vrf_id))
6777 else if (unformat (i, "ipv6"))
6781 clib_warning ("parse error '%U'", format_unformat_error, i);
6786 if (vrf_id_set == 0)
6788 errmsg ("missing vrf id\n");
6792 M (RESET_VRF, reset_vrf);
6794 mp->vrf_id = ntohl (vrf_id);
6795 mp->is_ipv6 = is_ipv6;
6804 api_create_vlan_subif (vat_main_t * vam)
6806 unformat_input_t *i = vam->input;
6807 vl_api_create_vlan_subif_t *mp;
6810 u8 sw_if_index_set = 0;
6814 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6816 if (unformat (i, "sw_if_index %d", &sw_if_index))
6817 sw_if_index_set = 1;
6818 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6819 sw_if_index_set = 1;
6820 else if (unformat (i, "vlan %d", &vlan_id))
6824 clib_warning ("parse error '%U'", format_unformat_error, i);
6829 if (sw_if_index_set == 0)
6831 errmsg ("missing interface name or sw_if_index\n");
6835 if (vlan_id_set == 0)
6837 errmsg ("missing vlan_id\n");
6840 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6842 mp->sw_if_index = ntohl (sw_if_index);
6843 mp->vlan_id = ntohl (vlan_id);
6851 #define foreach_create_subif_bit \
6858 _(outer_vlan_id_any) \
6859 _(inner_vlan_id_any)
6862 api_create_subif (vat_main_t * vam)
6864 unformat_input_t *i = vam->input;
6865 vl_api_create_subif_t *mp;
6868 u8 sw_if_index_set = 0;
6875 u32 exact_match = 0;
6876 u32 default_sub = 0;
6877 u32 outer_vlan_id_any = 0;
6878 u32 inner_vlan_id_any = 0;
6880 u16 outer_vlan_id = 0;
6881 u16 inner_vlan_id = 0;
6883 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6885 if (unformat (i, "sw_if_index %d", &sw_if_index))
6886 sw_if_index_set = 1;
6887 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6888 sw_if_index_set = 1;
6889 else if (unformat (i, "sub_id %d", &sub_id))
6891 else if (unformat (i, "outer_vlan_id %d", &tmp))
6892 outer_vlan_id = tmp;
6893 else if (unformat (i, "inner_vlan_id %d", &tmp))
6894 inner_vlan_id = tmp;
6896 #define _(a) else if (unformat (i, #a)) a = 1 ;
6897 foreach_create_subif_bit
6901 clib_warning ("parse error '%U'", format_unformat_error, i);
6906 if (sw_if_index_set == 0)
6908 errmsg ("missing interface name or sw_if_index\n");
6912 if (sub_id_set == 0)
6914 errmsg ("missing sub_id\n");
6917 M (CREATE_SUBIF, create_subif);
6919 mp->sw_if_index = ntohl (sw_if_index);
6920 mp->sub_id = ntohl (sub_id);
6922 #define _(a) mp->a = a;
6923 foreach_create_subif_bit;
6926 mp->outer_vlan_id = ntohs (outer_vlan_id);
6927 mp->inner_vlan_id = ntohs (inner_vlan_id);
6936 api_oam_add_del (vat_main_t * vam)
6938 unformat_input_t *i = vam->input;
6939 vl_api_oam_add_del_t *mp;
6943 ip4_address_t src, dst;
6947 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6949 if (unformat (i, "vrf %d", &vrf_id))
6951 else if (unformat (i, "src %U", unformat_ip4_address, &src))
6953 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
6955 else if (unformat (i, "del"))
6959 clib_warning ("parse error '%U'", format_unformat_error, i);
6966 errmsg ("missing src addr\n");
6972 errmsg ("missing dst addr\n");
6976 M (OAM_ADD_DEL, oam_add_del);
6978 mp->vrf_id = ntohl (vrf_id);
6979 mp->is_add = is_add;
6980 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
6981 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
6990 api_reset_fib (vat_main_t * vam)
6992 unformat_input_t *i = vam->input;
6993 vl_api_reset_fib_t *mp;
6999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7001 if (unformat (i, "vrf %d", &vrf_id))
7003 else if (unformat (i, "ipv6"))
7007 clib_warning ("parse error '%U'", format_unformat_error, i);
7012 if (vrf_id_set == 0)
7014 errmsg ("missing vrf id\n");
7018 M (RESET_FIB, reset_fib);
7020 mp->vrf_id = ntohl (vrf_id);
7021 mp->is_ipv6 = is_ipv6;
7030 api_dhcp_proxy_config (vat_main_t * vam)
7032 unformat_input_t *i = vam->input;
7033 vl_api_dhcp_proxy_config_t *mp;
7038 u8 v4_address_set = 0;
7039 u8 v6_address_set = 0;
7040 ip4_address_t v4address;
7041 ip6_address_t v6address;
7042 u8 v4_src_address_set = 0;
7043 u8 v6_src_address_set = 0;
7044 ip4_address_t v4srcaddress;
7045 ip6_address_t v6srcaddress;
7047 /* Parse args required to build the message */
7048 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7050 if (unformat (i, "del"))
7052 else if (unformat (i, "vrf %d", &vrf_id))
7054 else if (unformat (i, "insert-cid %d", &insert_cid))
7056 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7058 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7060 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7061 v4_src_address_set = 1;
7062 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7063 v6_src_address_set = 1;
7068 if (v4_address_set && v6_address_set)
7070 errmsg ("both v4 and v6 server addresses set\n");
7073 if (!v4_address_set && !v6_address_set)
7075 errmsg ("no server addresses set\n");
7079 if (v4_src_address_set && v6_src_address_set)
7081 errmsg ("both v4 and v6 src addresses set\n");
7084 if (!v4_src_address_set && !v6_src_address_set)
7086 errmsg ("no src addresses set\n");
7090 if (!(v4_src_address_set && v4_address_set) &&
7091 !(v6_src_address_set && v6_address_set))
7093 errmsg ("no matching server and src addresses set\n");
7097 /* Construct the API message */
7098 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7100 mp->insert_circuit_id = insert_cid;
7101 mp->is_add = is_add;
7102 mp->vrf_id = ntohl (vrf_id);
7106 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7107 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7111 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7112 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7118 /* Wait for a reply, return good/bad news */
7125 api_dhcp_proxy_config_2 (vat_main_t * vam)
7127 unformat_input_t *i = vam->input;
7128 vl_api_dhcp_proxy_config_2_t *mp;
7131 u32 server_vrf_id = 0;
7134 u8 v4_address_set = 0;
7135 u8 v6_address_set = 0;
7136 ip4_address_t v4address;
7137 ip6_address_t v6address;
7138 u8 v4_src_address_set = 0;
7139 u8 v6_src_address_set = 0;
7140 ip4_address_t v4srcaddress;
7141 ip6_address_t v6srcaddress;
7143 /* Parse args required to build the message */
7144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7146 if (unformat (i, "del"))
7148 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7150 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7152 else if (unformat (i, "insert-cid %d", &insert_cid))
7154 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7156 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7158 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7159 v4_src_address_set = 1;
7160 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7161 v6_src_address_set = 1;
7166 if (v4_address_set && v6_address_set)
7168 errmsg ("both v4 and v6 server addresses set\n");
7171 if (!v4_address_set && !v6_address_set)
7173 errmsg ("no server addresses set\n");
7177 if (v4_src_address_set && v6_src_address_set)
7179 errmsg ("both v4 and v6 src addresses set\n");
7182 if (!v4_src_address_set && !v6_src_address_set)
7184 errmsg ("no src addresses set\n");
7188 if (!(v4_src_address_set && v4_address_set) &&
7189 !(v6_src_address_set && v6_address_set))
7191 errmsg ("no matching server and src addresses set\n");
7195 /* Construct the API message */
7196 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7198 mp->insert_circuit_id = insert_cid;
7199 mp->is_add = is_add;
7200 mp->rx_vrf_id = ntohl (rx_vrf_id);
7201 mp->server_vrf_id = ntohl (server_vrf_id);
7205 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7206 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7210 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7211 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7217 /* Wait for a reply, return good/bad news */
7224 api_dhcp_proxy_set_vss (vat_main_t * vam)
7226 unformat_input_t *i = vam->input;
7227 vl_api_dhcp_proxy_set_vss_t *mp;
7238 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7240 if (unformat (i, "tbl_id %d", &tbl_id))
7242 if (unformat (i, "fib_id %d", &fib_id))
7244 if (unformat (i, "oui %d", &oui))
7246 else if (unformat (i, "ipv6"))
7248 else if (unformat (i, "del"))
7252 clib_warning ("parse error '%U'", format_unformat_error, i);
7257 if (tbl_id_set == 0)
7259 errmsg ("missing tbl id\n");
7263 if (fib_id_set == 0)
7265 errmsg ("missing fib id\n");
7270 errmsg ("missing oui\n");
7274 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7275 mp->tbl_id = ntohl (tbl_id);
7276 mp->fib_id = ntohl (fib_id);
7277 mp->oui = ntohl (oui);
7278 mp->is_ipv6 = is_ipv6;
7279 mp->is_add = is_add;
7288 api_dhcp_client_config (vat_main_t * vam)
7290 unformat_input_t *i = vam->input;
7291 vl_api_dhcp_client_config_t *mp;
7294 u8 sw_if_index_set = 0;
7297 u8 disable_event = 0;
7299 /* Parse args required to build the message */
7300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7302 if (unformat (i, "del"))
7304 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7305 sw_if_index_set = 1;
7306 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7307 sw_if_index_set = 1;
7308 else if (unformat (i, "hostname %s", &hostname))
7310 else if (unformat (i, "disable_event"))
7316 if (sw_if_index_set == 0)
7318 errmsg ("missing interface name or sw_if_index\n");
7322 if (vec_len (hostname) > 63)
7324 errmsg ("hostname too long\n");
7326 vec_add1 (hostname, 0);
7328 /* Construct the API message */
7329 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7331 mp->sw_if_index = ntohl (sw_if_index);
7332 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7333 vec_free (hostname);
7334 mp->is_add = is_add;
7335 mp->want_dhcp_event = disable_event ? 0 : 1;
7336 mp->pid = getpid ();
7341 /* Wait for a reply, return good/bad news */
7348 api_set_ip_flow_hash (vat_main_t * vam)
7350 unformat_input_t *i = vam->input;
7351 vl_api_set_ip_flow_hash_t *mp;
7363 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7365 if (unformat (i, "vrf %d", &vrf_id))
7367 else if (unformat (i, "ipv6"))
7369 else if (unformat (i, "src"))
7371 else if (unformat (i, "dst"))
7373 else if (unformat (i, "sport"))
7375 else if (unformat (i, "dport"))
7377 else if (unformat (i, "proto"))
7379 else if (unformat (i, "reverse"))
7384 clib_warning ("parse error '%U'", format_unformat_error, i);
7389 if (vrf_id_set == 0)
7391 errmsg ("missing vrf id\n");
7395 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7401 mp->reverse = reverse;
7402 mp->vrf_id = ntohl (vrf_id);
7403 mp->is_ipv6 = is_ipv6;
7412 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7414 unformat_input_t *i = vam->input;
7415 vl_api_sw_interface_ip6_enable_disable_t *mp;
7418 u8 sw_if_index_set = 0;
7421 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7423 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7424 sw_if_index_set = 1;
7425 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7426 sw_if_index_set = 1;
7427 else if (unformat (i, "enable"))
7429 else if (unformat (i, "disable"))
7433 clib_warning ("parse error '%U'", format_unformat_error, i);
7438 if (sw_if_index_set == 0)
7440 errmsg ("missing interface name or sw_if_index\n");
7444 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
7446 mp->sw_if_index = ntohl (sw_if_index);
7447 mp->enable = enable;
7456 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7458 unformat_input_t *i = vam->input;
7459 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7462 u8 sw_if_index_set = 0;
7463 u32 address_length = 0;
7464 u8 v6_address_set = 0;
7465 ip6_address_t v6address;
7467 /* Parse args required to build the message */
7468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7470 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7471 sw_if_index_set = 1;
7472 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7473 sw_if_index_set = 1;
7474 else if (unformat (i, "%U/%d",
7475 unformat_ip6_address, &v6address, &address_length))
7481 if (sw_if_index_set == 0)
7483 errmsg ("missing interface name or sw_if_index\n");
7486 if (!v6_address_set)
7488 errmsg ("no address set\n");
7492 /* Construct the API message */
7493 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
7494 sw_interface_ip6_set_link_local_address);
7496 mp->sw_if_index = ntohl (sw_if_index);
7497 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7498 mp->address_length = address_length;
7503 /* Wait for a reply, return good/bad news */
7512 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7514 unformat_input_t *i = vam->input;
7515 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7518 u8 sw_if_index_set = 0;
7519 u32 address_length = 0;
7520 u8 v6_address_set = 0;
7521 ip6_address_t v6address;
7523 u8 no_advertise = 0;
7525 u8 no_autoconfig = 0;
7528 u32 val_lifetime = 0;
7529 u32 pref_lifetime = 0;
7531 /* Parse args required to build the message */
7532 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7534 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7535 sw_if_index_set = 1;
7536 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7537 sw_if_index_set = 1;
7538 else if (unformat (i, "%U/%d",
7539 unformat_ip6_address, &v6address, &address_length))
7541 else if (unformat (i, "val_life %d", &val_lifetime))
7543 else if (unformat (i, "pref_life %d", &pref_lifetime))
7545 else if (unformat (i, "def"))
7547 else if (unformat (i, "noadv"))
7549 else if (unformat (i, "offl"))
7551 else if (unformat (i, "noauto"))
7553 else if (unformat (i, "nolink"))
7555 else if (unformat (i, "isno"))
7559 clib_warning ("parse error '%U'", format_unformat_error, i);
7564 if (sw_if_index_set == 0)
7566 errmsg ("missing interface name or sw_if_index\n");
7569 if (!v6_address_set)
7571 errmsg ("no address set\n");
7575 /* Construct the API message */
7576 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
7578 mp->sw_if_index = ntohl (sw_if_index);
7579 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7580 mp->address_length = address_length;
7581 mp->use_default = use_default;
7582 mp->no_advertise = no_advertise;
7583 mp->off_link = off_link;
7584 mp->no_autoconfig = no_autoconfig;
7585 mp->no_onlink = no_onlink;
7587 mp->val_lifetime = ntohl (val_lifetime);
7588 mp->pref_lifetime = ntohl (pref_lifetime);
7593 /* Wait for a reply, return good/bad news */
7601 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7603 unformat_input_t *i = vam->input;
7604 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7607 u8 sw_if_index_set = 0;
7612 u8 send_unicast = 0;
7615 u8 default_router = 0;
7616 u32 max_interval = 0;
7617 u32 min_interval = 0;
7619 u32 initial_count = 0;
7620 u32 initial_interval = 0;
7623 /* Parse args required to build the message */
7624 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7626 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7627 sw_if_index_set = 1;
7628 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7629 sw_if_index_set = 1;
7630 else if (unformat (i, "maxint %d", &max_interval))
7632 else if (unformat (i, "minint %d", &min_interval))
7634 else if (unformat (i, "life %d", &lifetime))
7636 else if (unformat (i, "count %d", &initial_count))
7638 else if (unformat (i, "interval %d", &initial_interval))
7640 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7642 else if (unformat (i, "managed"))
7644 else if (unformat (i, "other"))
7646 else if (unformat (i, "ll"))
7648 else if (unformat (i, "send"))
7650 else if (unformat (i, "cease"))
7652 else if (unformat (i, "isno"))
7654 else if (unformat (i, "def"))
7658 clib_warning ("parse error '%U'", format_unformat_error, i);
7663 if (sw_if_index_set == 0)
7665 errmsg ("missing interface name or sw_if_index\n");
7669 /* Construct the API message */
7670 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7672 mp->sw_if_index = ntohl (sw_if_index);
7673 mp->max_interval = ntohl (max_interval);
7674 mp->min_interval = ntohl (min_interval);
7675 mp->lifetime = ntohl (lifetime);
7676 mp->initial_count = ntohl (initial_count);
7677 mp->initial_interval = ntohl (initial_interval);
7678 mp->suppress = suppress;
7679 mp->managed = managed;
7681 mp->ll_option = ll_option;
7682 mp->send_unicast = send_unicast;
7685 mp->default_router = default_router;
7690 /* Wait for a reply, return good/bad news */
7698 api_set_arp_neighbor_limit (vat_main_t * vam)
7700 unformat_input_t *i = vam->input;
7701 vl_api_set_arp_neighbor_limit_t *mp;
7707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7709 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7711 else if (unformat (i, "ipv6"))
7715 clib_warning ("parse error '%U'", format_unformat_error, i);
7722 errmsg ("missing limit value\n");
7726 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7728 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7729 mp->is_ipv6 = is_ipv6;
7738 api_l2_patch_add_del (vat_main_t * vam)
7740 unformat_input_t *i = vam->input;
7741 vl_api_l2_patch_add_del_t *mp;
7744 u8 rx_sw_if_index_set = 0;
7746 u8 tx_sw_if_index_set = 0;
7749 /* Parse args required to build the message */
7750 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7752 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7753 rx_sw_if_index_set = 1;
7754 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7755 tx_sw_if_index_set = 1;
7756 else if (unformat (i, "rx"))
7758 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7760 if (unformat (i, "%U", unformat_sw_if_index, vam,
7762 rx_sw_if_index_set = 1;
7767 else if (unformat (i, "tx"))
7769 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7771 if (unformat (i, "%U", unformat_sw_if_index, vam,
7773 tx_sw_if_index_set = 1;
7778 else if (unformat (i, "del"))
7784 if (rx_sw_if_index_set == 0)
7786 errmsg ("missing rx interface name or rx_sw_if_index\n");
7790 if (tx_sw_if_index_set == 0)
7792 errmsg ("missing tx interface name or tx_sw_if_index\n");
7796 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7798 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7799 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7800 mp->is_add = is_add;
7809 api_ioam_enable (vat_main_t * vam)
7811 unformat_input_t *input = vam->input;
7812 vl_api_ioam_enable_t *mp;
7815 int has_trace_option = 0;
7816 int has_pot_option = 0;
7817 int has_seqno_option = 0;
7818 int has_analyse_option = 0;
7820 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7822 if (unformat (input, "trace"))
7823 has_trace_option = 1;
7824 else if (unformat (input, "pot"))
7826 else if (unformat (input, "seqno"))
7827 has_seqno_option = 1;
7828 else if (unformat (input, "analyse"))
7829 has_analyse_option = 1;
7833 M (IOAM_ENABLE, ioam_enable);
7834 mp->id = htons (id);
7835 mp->seqno = has_seqno_option;
7836 mp->analyse = has_analyse_option;
7837 mp->pot_enable = has_pot_option;
7838 mp->trace_enable = has_trace_option;
7849 api_ioam_disable (vat_main_t * vam)
7851 vl_api_ioam_disable_t *mp;
7854 M (IOAM_DISABLE, ioam_disable);
7861 api_sr_tunnel_add_del (vat_main_t * vam)
7863 unformat_input_t *i = vam->input;
7864 vl_api_sr_tunnel_add_del_t *mp;
7868 ip6_address_t src_address;
7869 int src_address_set = 0;
7870 ip6_address_t dst_address;
7872 int dst_address_set = 0;
7874 u32 rx_table_id = 0;
7875 u32 tx_table_id = 0;
7876 ip6_address_t *segments = 0;
7877 ip6_address_t *this_seg;
7878 ip6_address_t *tags = 0;
7879 ip6_address_t *this_tag;
7880 ip6_address_t next_address, tag;
7882 u8 *policy_name = 0;
7884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7886 if (unformat (i, "del"))
7888 else if (unformat (i, "name %s", &name))
7890 else if (unformat (i, "policy %s", &policy_name))
7892 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
7894 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
7896 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
7897 src_address_set = 1;
7898 else if (unformat (i, "dst %U/%d",
7899 unformat_ip6_address, &dst_address, &dst_mask_width))
7900 dst_address_set = 1;
7901 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
7903 vec_add2 (segments, this_seg, 1);
7904 clib_memcpy (this_seg->as_u8, next_address.as_u8,
7905 sizeof (*this_seg));
7907 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
7909 vec_add2 (tags, this_tag, 1);
7910 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
7912 else if (unformat (i, "clean"))
7913 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
7914 else if (unformat (i, "protected"))
7915 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
7916 else if (unformat (i, "InPE %d", &pl_index))
7918 if (pl_index <= 0 || pl_index > 4)
7920 pl_index_range_error:
7921 errmsg ("pl index %d out of range\n", pl_index);
7925 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
7927 else if (unformat (i, "EgPE %d", &pl_index))
7929 if (pl_index <= 0 || pl_index > 4)
7930 goto pl_index_range_error;
7932 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
7934 else if (unformat (i, "OrgSrc %d", &pl_index))
7936 if (pl_index <= 0 || pl_index > 4)
7937 goto pl_index_range_error;
7939 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
7945 if (!src_address_set)
7947 errmsg ("src address required\n");
7951 if (!dst_address_set)
7953 errmsg ("dst address required\n");
7959 errmsg ("at least one sr segment required\n");
7963 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
7964 vec_len (segments) * sizeof (ip6_address_t)
7965 + vec_len (tags) * sizeof (ip6_address_t));
7967 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
7968 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
7969 mp->dst_mask_width = dst_mask_width;
7970 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
7971 mp->n_segments = vec_len (segments);
7972 mp->n_tags = vec_len (tags);
7973 mp->is_add = is_del == 0;
7974 clib_memcpy (mp->segs_and_tags, segments,
7975 vec_len (segments) * sizeof (ip6_address_t));
7976 clib_memcpy (mp->segs_and_tags +
7977 vec_len (segments) * sizeof (ip6_address_t), tags,
7978 vec_len (tags) * sizeof (ip6_address_t));
7980 mp->outer_vrf_id = ntohl (rx_table_id);
7981 mp->inner_vrf_id = ntohl (tx_table_id);
7982 memcpy (mp->name, name, vec_len (name));
7983 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
7985 vec_free (segments);
7994 api_sr_policy_add_del (vat_main_t * vam)
7996 unformat_input_t *input = vam->input;
7997 vl_api_sr_policy_add_del_t *mp;
8001 u8 *tunnel_name = 0;
8002 u8 **tunnel_names = 0;
8007 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8008 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8010 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8012 if (unformat (input, "del"))
8014 else if (unformat (input, "name %s", &name))
8016 else if (unformat (input, "tunnel %s", &tunnel_name))
8020 vec_add1 (tunnel_names, tunnel_name);
8022 - length = #bytes to store in serial vector
8023 - +1 = byte to store that length
8025 tunnel_names_length += (vec_len (tunnel_name) + 1);
8036 errmsg ("policy name required\n");
8040 if ((!tunnel_set) && (!is_del))
8042 errmsg ("tunnel name required\n");
8046 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
8050 mp->is_add = !is_del;
8052 memcpy (mp->name, name, vec_len (name));
8053 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8054 u8 *serial_orig = 0;
8055 vec_validate (serial_orig, tunnel_names_length);
8056 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8057 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8059 for (j = 0; j < vec_len (tunnel_names); j++)
8061 tun_name_len = vec_len (tunnel_names[j]);
8062 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8063 serial_orig += 1; // Move along one byte to store the actual tunnel name
8064 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8065 serial_orig += tun_name_len; // Advance past the copy
8067 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8069 vec_free (tunnel_names);
8070 vec_free (tunnel_name);
8078 api_sr_multicast_map_add_del (vat_main_t * vam)
8080 unformat_input_t *input = vam->input;
8081 vl_api_sr_multicast_map_add_del_t *mp;
8084 ip6_address_t multicast_address;
8085 u8 *policy_name = 0;
8086 int multicast_address_set = 0;
8088 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8090 if (unformat (input, "del"))
8094 (input, "address %U", unformat_ip6_address, &multicast_address))
8095 multicast_address_set = 1;
8096 else if (unformat (input, "sr-policy %s", &policy_name))
8102 if (!is_del && !policy_name)
8104 errmsg ("sr-policy name required\n");
8109 if (!multicast_address_set)
8111 errmsg ("address required\n");
8115 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8117 mp->is_add = !is_del;
8118 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8119 clib_memcpy (mp->multicast_address, &multicast_address,
8120 sizeof (mp->multicast_address));
8123 vec_free (policy_name);
8131 #define foreach_tcp_proto_field \
8135 #define foreach_udp_proto_field \
8139 #define foreach_ip4_proto_field \
8150 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8152 u8 **maskp = va_arg (*args, u8 **);
8154 u8 found_something = 0;
8157 #define _(a) u8 a=0;
8158 foreach_tcp_proto_field;
8161 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8164 #define _(a) else if (unformat (input, #a)) a=1;
8165 foreach_tcp_proto_field
8171 #define _(a) found_something += a;
8172 foreach_tcp_proto_field;
8175 if (found_something == 0)
8178 vec_validate (mask, sizeof (*tcp) - 1);
8180 tcp = (tcp_header_t *) mask;
8182 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8183 foreach_tcp_proto_field;
8191 unformat_udp_mask (unformat_input_t * input, va_list * args)
8193 u8 **maskp = va_arg (*args, u8 **);
8195 u8 found_something = 0;
8198 #define _(a) u8 a=0;
8199 foreach_udp_proto_field;
8202 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8205 #define _(a) else if (unformat (input, #a)) a=1;
8206 foreach_udp_proto_field
8212 #define _(a) found_something += a;
8213 foreach_udp_proto_field;
8216 if (found_something == 0)
8219 vec_validate (mask, sizeof (*udp) - 1);
8221 udp = (udp_header_t *) mask;
8223 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8224 foreach_udp_proto_field;
8233 u16 src_port, dst_port;
8237 unformat_l4_mask (unformat_input_t * input, va_list * args)
8239 u8 **maskp = va_arg (*args, u8 **);
8240 u16 src_port = 0, dst_port = 0;
8241 tcpudp_header_t *tcpudp;
8243 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8245 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8247 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8249 else if (unformat (input, "src_port"))
8251 else if (unformat (input, "dst_port"))
8257 if (!src_port && !dst_port)
8261 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8263 tcpudp = (tcpudp_header_t *) mask;
8264 tcpudp->src_port = src_port;
8265 tcpudp->dst_port = dst_port;
8273 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8275 u8 **maskp = va_arg (*args, u8 **);
8277 u8 found_something = 0;
8280 #define _(a) u8 a=0;
8281 foreach_ip4_proto_field;
8287 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8289 if (unformat (input, "version"))
8291 else if (unformat (input, "hdr_length"))
8293 else if (unformat (input, "src"))
8295 else if (unformat (input, "dst"))
8297 else if (unformat (input, "proto"))
8300 #define _(a) else if (unformat (input, #a)) a=1;
8301 foreach_ip4_proto_field
8307 #define _(a) found_something += a;
8308 foreach_ip4_proto_field;
8311 if (found_something == 0)
8314 vec_validate (mask, sizeof (*ip) - 1);
8316 ip = (ip4_header_t *) mask;
8318 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8319 foreach_ip4_proto_field;
8322 ip->ip_version_and_header_length = 0;
8325 ip->ip_version_and_header_length |= 0xF0;
8328 ip->ip_version_and_header_length |= 0x0F;
8334 #define foreach_ip6_proto_field \
8342 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8344 u8 **maskp = va_arg (*args, u8 **);
8346 u8 found_something = 0;
8348 u32 ip_version_traffic_class_and_flow_label;
8350 #define _(a) u8 a=0;
8351 foreach_ip6_proto_field;
8354 u8 traffic_class = 0;
8357 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8359 if (unformat (input, "version"))
8361 else if (unformat (input, "traffic-class"))
8363 else if (unformat (input, "flow-label"))
8365 else if (unformat (input, "src"))
8367 else if (unformat (input, "dst"))
8369 else if (unformat (input, "proto"))
8372 #define _(a) else if (unformat (input, #a)) a=1;
8373 foreach_ip6_proto_field
8379 #define _(a) found_something += a;
8380 foreach_ip6_proto_field;
8383 if (found_something == 0)
8386 vec_validate (mask, sizeof (*ip) - 1);
8388 ip = (ip6_header_t *) mask;
8390 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8391 foreach_ip6_proto_field;
8394 ip_version_traffic_class_and_flow_label = 0;
8397 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8400 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8403 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8405 ip->ip_version_traffic_class_and_flow_label =
8406 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8413 unformat_l3_mask (unformat_input_t * input, va_list * args)
8415 u8 **maskp = va_arg (*args, u8 **);
8417 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8419 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8421 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8430 unformat_l2_mask (unformat_input_t * input, va_list * args)
8432 u8 **maskp = va_arg (*args, u8 **);
8447 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8449 if (unformat (input, "src"))
8451 else if (unformat (input, "dst"))
8453 else if (unformat (input, "proto"))
8455 else if (unformat (input, "tag1"))
8457 else if (unformat (input, "tag2"))
8459 else if (unformat (input, "ignore-tag1"))
8461 else if (unformat (input, "ignore-tag2"))
8463 else if (unformat (input, "cos1"))
8465 else if (unformat (input, "cos2"))
8467 else if (unformat (input, "dot1q"))
8469 else if (unformat (input, "dot1ad"))
8474 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8475 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8478 if (tag1 || ignore_tag1 || cos1 || dot1q)
8480 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8483 vec_validate (mask, len - 1);
8486 memset (mask, 0xff, 6);
8489 memset (mask + 6, 0xff, 6);
8493 /* inner vlan tag */
8502 mask[21] = mask[20] = 0xff;
8523 mask[16] = mask[17] = 0xff;
8533 mask[12] = mask[13] = 0xff;
8540 unformat_classify_mask (unformat_input_t * input, va_list * args)
8542 u8 **maskp = va_arg (*args, u8 **);
8543 u32 *skipp = va_arg (*args, u32 *);
8544 u32 *matchp = va_arg (*args, u32 *);
8552 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8554 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8556 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8558 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8560 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8574 if (mask || l2 || l3 || l4)
8578 /* "With a free Ethernet header in every package" */
8580 vec_validate (l2, 13);
8584 vec_append (mask, l3);
8589 vec_append (mask, l4);
8594 /* Scan forward looking for the first significant mask octet */
8595 for (i = 0; i < vec_len (mask); i++)
8599 /* compute (skip, match) params */
8600 *skipp = i / sizeof (u32x4);
8601 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8603 /* Pad mask to an even multiple of the vector size */
8604 while (vec_len (mask) % sizeof (u32x4))
8607 match = vec_len (mask) / sizeof (u32x4);
8609 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8611 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8612 if (*tmp || *(tmp + 1))
8617 clib_warning ("BUG: match 0");
8619 _vec_len (mask) = match * sizeof (u32x4);
8630 #define foreach_l2_next \
8632 _(ethernet, ETHERNET_INPUT) \
8637 unformat_l2_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 = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8648 if (unformat (input, "%d", &tmp))
8657 *miss_next_indexp = next_index;
8661 #define foreach_ip_next \
8667 unformat_ip_next_index (unformat_input_t * input, va_list * args)
8669 u32 *miss_next_indexp = va_arg (*args, u32 *);
8674 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8678 if (unformat (input, "%d", &tmp))
8687 *miss_next_indexp = next_index;
8691 #define foreach_acl_next \
8695 unformat_acl_next_index (unformat_input_t * input, va_list * args)
8697 u32 *miss_next_indexp = va_arg (*args, u32 *);
8702 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8706 if (unformat (input, "permit"))
8711 else if (unformat (input, "%d", &tmp))
8720 *miss_next_indexp = next_index;
8725 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8727 u32 *r = va_arg (*args, u32 *);
8729 if (unformat (input, "conform-color"))
8730 *r = POLICE_CONFORM;
8731 else if (unformat (input, "exceed-color"))
8740 api_classify_add_del_table (vat_main_t * vam)
8742 unformat_input_t *i = vam->input;
8743 vl_api_classify_add_del_table_t *mp;
8749 u32 table_index = ~0;
8750 u32 next_table_index = ~0;
8751 u32 miss_next_index = ~0;
8752 u32 memory_size = 32 << 20;
8756 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8758 if (unformat (i, "del"))
8760 else if (unformat (i, "buckets %d", &nbuckets))
8762 else if (unformat (i, "memory_size %d", &memory_size))
8764 else if (unformat (i, "skip %d", &skip))
8766 else if (unformat (i, "match %d", &match))
8768 else if (unformat (i, "table %d", &table_index))
8770 else if (unformat (i, "mask %U", unformat_classify_mask,
8771 &mask, &skip, &match))
8773 else if (unformat (i, "next-table %d", &next_table_index))
8775 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8778 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8781 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8788 if (is_add && mask == 0)
8790 errmsg ("Mask required\n");
8794 if (is_add && skip == ~0)
8796 errmsg ("skip count required\n");
8800 if (is_add && match == ~0)
8802 errmsg ("match count required\n");
8806 if (!is_add && table_index == ~0)
8808 errmsg ("table index required for delete\n");
8812 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8814 mp->is_add = is_add;
8815 mp->table_index = ntohl (table_index);
8816 mp->nbuckets = ntohl (nbuckets);
8817 mp->memory_size = ntohl (memory_size);
8818 mp->skip_n_vectors = ntohl (skip);
8819 mp->match_n_vectors = ntohl (match);
8820 mp->next_table_index = ntohl (next_table_index);
8821 mp->miss_next_index = ntohl (miss_next_index);
8822 clib_memcpy (mp->mask, mask, vec_len (mask));
8832 unformat_l4_match (unformat_input_t * input, va_list * args)
8834 u8 **matchp = va_arg (*args, u8 **);
8836 u8 *proto_header = 0;
8842 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8844 if (unformat (input, "src_port %d", &src_port))
8846 else if (unformat (input, "dst_port %d", &dst_port))
8852 h.src_port = clib_host_to_net_u16 (src_port);
8853 h.dst_port = clib_host_to_net_u16 (dst_port);
8854 vec_validate (proto_header, sizeof (h) - 1);
8855 memcpy (proto_header, &h, sizeof (h));
8857 *matchp = proto_header;
8863 unformat_ip4_match (unformat_input_t * input, va_list * args)
8865 u8 **matchp = va_arg (*args, u8 **);
8872 int src = 0, dst = 0;
8873 ip4_address_t src_val, dst_val;
8880 int fragment_id = 0;
8881 u32 fragment_id_val;
8887 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8889 if (unformat (input, "version %d", &version_val))
8891 else if (unformat (input, "hdr_length %d", &hdr_length_val))
8893 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
8895 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
8897 else if (unformat (input, "proto %d", &proto_val))
8899 else if (unformat (input, "tos %d", &tos_val))
8901 else if (unformat (input, "length %d", &length_val))
8903 else if (unformat (input, "fragment_id %d", &fragment_id_val))
8905 else if (unformat (input, "ttl %d", &ttl_val))
8907 else if (unformat (input, "checksum %d", &checksum_val))
8913 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
8914 + ttl + checksum == 0)
8918 * Aligned because we use the real comparison functions
8920 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
8922 ip = (ip4_header_t *) match;
8924 /* These are realistically matched in practice */
8926 ip->src_address.as_u32 = src_val.as_u32;
8929 ip->dst_address.as_u32 = dst_val.as_u32;
8932 ip->protocol = proto_val;
8935 /* These are not, but they're included for completeness */
8937 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
8940 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
8946 ip->length = clib_host_to_net_u16 (length_val);
8952 ip->checksum = clib_host_to_net_u16 (checksum_val);
8959 unformat_ip6_match (unformat_input_t * input, va_list * args)
8961 u8 **matchp = va_arg (*args, u8 **);
8966 u8 traffic_class = 0;
8967 u32 traffic_class_val = 0;
8970 int src = 0, dst = 0;
8971 ip6_address_t src_val, dst_val;
8974 int payload_length = 0;
8975 u32 payload_length_val;
8978 u32 ip_version_traffic_class_and_flow_label;
8980 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8982 if (unformat (input, "version %d", &version_val))
8984 else if (unformat (input, "traffic_class %d", &traffic_class_val))
8986 else if (unformat (input, "flow_label %d", &flow_label_val))
8988 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
8990 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
8992 else if (unformat (input, "proto %d", &proto_val))
8994 else if (unformat (input, "payload_length %d", &payload_length_val))
8996 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9002 if (version + traffic_class + flow_label + src + dst + proto +
9003 payload_length + hop_limit == 0)
9007 * Aligned because we use the real comparison functions
9009 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9011 ip = (ip6_header_t *) match;
9014 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9017 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9020 ip->protocol = proto_val;
9022 ip_version_traffic_class_and_flow_label = 0;
9025 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9028 ip_version_traffic_class_and_flow_label |=
9029 (traffic_class_val & 0xFF) << 20;
9032 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9034 ip->ip_version_traffic_class_and_flow_label =
9035 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9038 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9041 ip->hop_limit = hop_limit_val;
9048 unformat_l3_match (unformat_input_t * input, va_list * args)
9050 u8 **matchp = va_arg (*args, u8 **);
9052 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9054 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9056 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9065 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9067 u8 *tagp = va_arg (*args, u8 *);
9070 if (unformat (input, "%d", &tag))
9072 tagp[0] = (tag >> 8) & 0x0F;
9073 tagp[1] = tag & 0xFF;
9081 unformat_l2_match (unformat_input_t * input, va_list * args)
9083 u8 **matchp = va_arg (*args, u8 **);
9103 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9105 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9108 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9110 else if (unformat (input, "proto %U",
9111 unformat_ethernet_type_host_byte_order, &proto_val))
9113 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9115 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9117 else if (unformat (input, "ignore-tag1"))
9119 else if (unformat (input, "ignore-tag2"))
9121 else if (unformat (input, "cos1 %d", &cos1_val))
9123 else if (unformat (input, "cos2 %d", &cos2_val))
9128 if ((src + dst + proto + tag1 + tag2 +
9129 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9132 if (tag1 || ignore_tag1 || cos1)
9134 if (tag2 || ignore_tag2 || cos2)
9137 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9140 clib_memcpy (match, dst_val, 6);
9143 clib_memcpy (match + 6, src_val, 6);
9147 /* inner vlan tag */
9148 match[19] = tag2_val[1];
9149 match[18] = tag2_val[0];
9151 match[18] |= (cos2_val & 0x7) << 5;
9154 match[21] = proto_val & 0xff;
9155 match[20] = proto_val >> 8;
9159 match[15] = tag1_val[1];
9160 match[14] = tag1_val[0];
9163 match[14] |= (cos1_val & 0x7) << 5;
9169 match[15] = tag1_val[1];
9170 match[14] = tag1_val[0];
9173 match[17] = proto_val & 0xff;
9174 match[16] = proto_val >> 8;
9177 match[14] |= (cos1_val & 0x7) << 5;
9183 match[18] |= (cos2_val & 0x7) << 5;
9185 match[14] |= (cos1_val & 0x7) << 5;
9188 match[13] = proto_val & 0xff;
9189 match[12] = proto_val >> 8;
9198 unformat_classify_match (unformat_input_t * input, va_list * args)
9200 u8 **matchp = va_arg (*args, u8 **);
9201 u32 skip_n_vectors = va_arg (*args, u32);
9202 u32 match_n_vectors = va_arg (*args, u32);
9209 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9211 if (unformat (input, "hex %U", unformat_hex_string, &match))
9213 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9215 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9217 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9231 if (match || l2 || l3 || l4)
9235 /* "Win a free Ethernet header in every packet" */
9237 vec_validate_aligned (l2, 13, sizeof (u32x4));
9241 vec_append_aligned (match, l3, sizeof (u32x4));
9246 vec_append_aligned (match, l4, sizeof (u32x4));
9251 /* Make sure the vector is big enough even if key is all 0's */
9252 vec_validate_aligned
9253 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9256 /* Set size, include skipped vectors */
9257 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9268 api_classify_add_del_session (vat_main_t * vam)
9270 unformat_input_t *i = vam->input;
9271 vl_api_classify_add_del_session_t *mp;
9273 u32 table_index = ~0;
9274 u32 hit_next_index = ~0;
9275 u32 opaque_index = ~0;
9279 u32 skip_n_vectors = 0;
9280 u32 match_n_vectors = 0;
9283 * Warning: you have to supply skip_n and match_n
9284 * because the API client cant simply look at the classify
9288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9290 if (unformat (i, "del"))
9292 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9295 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9298 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9301 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9303 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9305 else if (unformat (i, "opaque-index %d", &opaque_index))
9307 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9309 else if (unformat (i, "match_n %d", &match_n_vectors))
9311 else if (unformat (i, "match %U", unformat_classify_match,
9312 &match, skip_n_vectors, match_n_vectors))
9314 else if (unformat (i, "advance %d", &advance))
9316 else if (unformat (i, "table-index %d", &table_index))
9322 if (table_index == ~0)
9324 errmsg ("Table index required\n");
9328 if (is_add && match == 0)
9330 errmsg ("Match value required\n");
9334 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9336 mp->is_add = is_add;
9337 mp->table_index = ntohl (table_index);
9338 mp->hit_next_index = ntohl (hit_next_index);
9339 mp->opaque_index = ntohl (opaque_index);
9340 mp->advance = ntohl (advance);
9341 clib_memcpy (mp->match, match, vec_len (match));
9350 api_classify_set_interface_ip_table (vat_main_t * vam)
9352 unformat_input_t *i = vam->input;
9353 vl_api_classify_set_interface_ip_table_t *mp;
9356 int sw_if_index_set;
9357 u32 table_index = ~0;
9360 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9362 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9363 sw_if_index_set = 1;
9364 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9365 sw_if_index_set = 1;
9366 else if (unformat (i, "table %d", &table_index))
9370 clib_warning ("parse error '%U'", format_unformat_error, i);
9375 if (sw_if_index_set == 0)
9377 errmsg ("missing interface name or sw_if_index\n");
9382 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9384 mp->sw_if_index = ntohl (sw_if_index);
9385 mp->table_index = ntohl (table_index);
9386 mp->is_ipv6 = is_ipv6;
9395 api_classify_set_interface_l2_tables (vat_main_t * vam)
9397 unformat_input_t *i = vam->input;
9398 vl_api_classify_set_interface_l2_tables_t *mp;
9401 int sw_if_index_set;
9402 u32 ip4_table_index = ~0;
9403 u32 ip6_table_index = ~0;
9404 u32 other_table_index = ~0;
9407 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9409 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9410 sw_if_index_set = 1;
9411 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9412 sw_if_index_set = 1;
9413 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9415 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9417 else if (unformat (i, "other-table %d", &other_table_index))
9419 else if (unformat (i, "is-input %d", &is_input))
9423 clib_warning ("parse error '%U'", format_unformat_error, i);
9428 if (sw_if_index_set == 0)
9430 errmsg ("missing interface name or sw_if_index\n");
9435 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
9437 mp->sw_if_index = ntohl (sw_if_index);
9438 mp->ip4_table_index = ntohl (ip4_table_index);
9439 mp->ip6_table_index = ntohl (ip6_table_index);
9440 mp->other_table_index = ntohl (other_table_index);
9441 mp->is_input = (u8) is_input;
9450 api_set_ipfix_exporter (vat_main_t * vam)
9452 unformat_input_t *i = vam->input;
9453 vl_api_set_ipfix_exporter_t *mp;
9454 ip4_address_t collector_address;
9455 u8 collector_address_set = 0;
9456 u32 collector_port = ~0;
9457 ip4_address_t src_address;
9458 u8 src_address_set = 0;
9461 u32 template_interval = ~0;
9462 u8 udp_checksum = 0;
9465 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9467 if (unformat (i, "collector_address %U", unformat_ip4_address,
9468 &collector_address))
9469 collector_address_set = 1;
9470 else if (unformat (i, "collector_port %d", &collector_port))
9472 else if (unformat (i, "src_address %U", unformat_ip4_address,
9474 src_address_set = 1;
9475 else if (unformat (i, "vrf_id %d", &vrf_id))
9477 else if (unformat (i, "path_mtu %d", &path_mtu))
9479 else if (unformat (i, "template_interval %d", &template_interval))
9481 else if (unformat (i, "udp_checksum"))
9487 if (collector_address_set == 0)
9489 errmsg ("collector_address required\n");
9493 if (src_address_set == 0)
9495 errmsg ("src_address required\n");
9499 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
9501 memcpy (mp->collector_address, collector_address.data,
9502 sizeof (collector_address.data));
9503 mp->collector_port = htons ((u16) collector_port);
9504 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9505 mp->vrf_id = htonl (vrf_id);
9506 mp->path_mtu = htonl (path_mtu);
9507 mp->template_interval = htonl (template_interval);
9508 mp->udp_checksum = udp_checksum;
9516 api_set_ipfix_classify_stream (vat_main_t * vam)
9518 unformat_input_t *i = vam->input;
9519 vl_api_set_ipfix_classify_stream_t *mp;
9521 u32 src_port = UDP_DST_PORT_ipfix;
9524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9526 if (unformat (i, "domain %d", &domain_id))
9528 else if (unformat (i, "src_port %d", &src_port))
9532 errmsg ("unknown input `%U'", format_unformat_error, i);
9537 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
9539 mp->domain_id = htonl (domain_id);
9540 mp->src_port = htons ((u16) src_port);
9548 api_ipfix_classify_table_add_del (vat_main_t * vam)
9550 unformat_input_t *i = vam->input;
9551 vl_api_ipfix_classify_table_add_del_t *mp;
9553 u32 classify_table_index = ~0;
9555 u8 transport_protocol = 255;
9558 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9560 if (unformat (i, "add"))
9562 else if (unformat (i, "del"))
9564 else if (unformat (i, "table %d", &classify_table_index))
9566 else if (unformat (i, "ip4"))
9568 else if (unformat (i, "ip6"))
9570 else if (unformat (i, "tcp"))
9571 transport_protocol = 6;
9572 else if (unformat (i, "udp"))
9573 transport_protocol = 17;
9576 errmsg ("unknown input `%U'", format_unformat_error, i);
9583 errmsg ("expecting: add|del");
9586 if (classify_table_index == ~0)
9588 errmsg ("classifier table not specified");
9591 if (ip_version == 0)
9593 errmsg ("IP version not specified");
9597 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
9599 mp->is_add = is_add;
9600 mp->table_id = htonl (classify_table_index);
9601 mp->ip_version = ip_version;
9602 mp->transport_protocol = transport_protocol;
9610 api_get_node_index (vat_main_t * vam)
9612 unformat_input_t *i = vam->input;
9613 vl_api_get_node_index_t *mp;
9617 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9619 if (unformat (i, "node %s", &name))
9626 errmsg ("node name required\n");
9629 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9631 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9635 M (GET_NODE_INDEX, get_node_index);
9636 clib_memcpy (mp->node_name, name, vec_len (name));
9646 api_get_next_index (vat_main_t * vam)
9648 unformat_input_t *i = vam->input;
9649 vl_api_get_next_index_t *mp;
9651 u8 *node_name = 0, *next_node_name = 0;
9653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9655 if (unformat (i, "node-name %s", &node_name))
9657 else if (unformat (i, "next-node-name %s", &next_node_name))
9663 errmsg ("node name required\n");
9666 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9668 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9672 if (next_node_name == 0)
9674 errmsg ("next node name required\n");
9677 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9679 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
9683 M (GET_NEXT_INDEX, get_next_index);
9684 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9685 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9686 vec_free (node_name);
9687 vec_free (next_node_name);
9696 api_add_node_next (vat_main_t * vam)
9698 unformat_input_t *i = vam->input;
9699 vl_api_add_node_next_t *mp;
9704 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9706 if (unformat (i, "node %s", &name))
9708 else if (unformat (i, "next %s", &next))
9715 errmsg ("node name required\n");
9718 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9720 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9725 errmsg ("next node required\n");
9728 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9730 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
9734 M (ADD_NODE_NEXT, add_node_next);
9735 clib_memcpy (mp->node_name, name, vec_len (name));
9736 clib_memcpy (mp->next_name, next, vec_len (next));
9747 api_l2tpv3_create_tunnel (vat_main_t * vam)
9749 unformat_input_t *i = vam->input;
9750 ip6_address_t client_address, our_address;
9751 int client_address_set = 0;
9752 int our_address_set = 0;
9753 u32 local_session_id = 0;
9754 u32 remote_session_id = 0;
9755 u64 local_cookie = 0;
9756 u64 remote_cookie = 0;
9757 u8 l2_sublayer_present = 0;
9758 vl_api_l2tpv3_create_tunnel_t *mp;
9761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9763 if (unformat (i, "client_address %U", unformat_ip6_address,
9765 client_address_set = 1;
9766 else if (unformat (i, "our_address %U", unformat_ip6_address,
9768 our_address_set = 1;
9769 else if (unformat (i, "local_session_id %d", &local_session_id))
9771 else if (unformat (i, "remote_session_id %d", &remote_session_id))
9773 else if (unformat (i, "local_cookie %lld", &local_cookie))
9775 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
9777 else if (unformat (i, "l2-sublayer-present"))
9778 l2_sublayer_present = 1;
9783 if (client_address_set == 0)
9785 errmsg ("client_address required\n");
9789 if (our_address_set == 0)
9791 errmsg ("our_address required\n");
9795 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9797 clib_memcpy (mp->client_address, client_address.as_u8,
9798 sizeof (mp->client_address));
9800 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9802 mp->local_session_id = ntohl (local_session_id);
9803 mp->remote_session_id = ntohl (remote_session_id);
9804 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9805 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9806 mp->l2_sublayer_present = l2_sublayer_present;
9816 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9818 unformat_input_t *i = vam->input;
9820 u8 sw_if_index_set = 0;
9821 u64 new_local_cookie = 0;
9822 u64 new_remote_cookie = 0;
9823 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9826 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9828 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9829 sw_if_index_set = 1;
9830 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9831 sw_if_index_set = 1;
9832 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9834 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
9840 if (sw_if_index_set == 0)
9842 errmsg ("missing interface name or sw_if_index\n");
9846 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
9848 mp->sw_if_index = ntohl (sw_if_index);
9849 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
9850 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
9859 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
9861 unformat_input_t *i = vam->input;
9862 vl_api_l2tpv3_interface_enable_disable_t *mp;
9865 u8 sw_if_index_set = 0;
9866 u8 enable_disable = 1;
9868 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9870 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9871 sw_if_index_set = 1;
9872 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9873 sw_if_index_set = 1;
9874 else if (unformat (i, "enable"))
9876 else if (unformat (i, "disable"))
9882 if (sw_if_index_set == 0)
9884 errmsg ("missing interface name or sw_if_index\n");
9888 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
9890 mp->sw_if_index = ntohl (sw_if_index);
9891 mp->enable_disable = enable_disable;
9900 api_l2tpv3_set_lookup_key (vat_main_t * vam)
9902 unformat_input_t *i = vam->input;
9903 vl_api_l2tpv3_set_lookup_key_t *mp;
9907 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9909 if (unformat (i, "lookup_v6_src"))
9910 key = L2T_LOOKUP_SRC_ADDRESS;
9911 else if (unformat (i, "lookup_v6_dst"))
9912 key = L2T_LOOKUP_DST_ADDRESS;
9913 else if (unformat (i, "lookup_session_id"))
9914 key = L2T_LOOKUP_SESSION_ID;
9919 if (key == (u8) ~ 0)
9921 errmsg ("l2tp session lookup key unset\n");
9925 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
9935 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
9936 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9938 vat_main_t *vam = &vat_main;
9940 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
9941 format_ip6_address, mp->our_address,
9942 format_ip6_address, mp->client_address,
9943 clib_net_to_host_u32 (mp->sw_if_index));
9946 " local cookies %016llx %016llx remote cookie %016llx\n",
9947 clib_net_to_host_u64 (mp->local_cookie[0]),
9948 clib_net_to_host_u64 (mp->local_cookie[1]),
9949 clib_net_to_host_u64 (mp->remote_cookie));
9951 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
9952 clib_net_to_host_u32 (mp->local_session_id),
9953 clib_net_to_host_u32 (mp->remote_session_id));
9955 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
9956 mp->l2_sublayer_present ? "preset" : "absent");
9960 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
9961 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
9963 vat_main_t *vam = &vat_main;
9964 vat_json_node_t *node = NULL;
9965 struct in6_addr addr;
9967 if (VAT_JSON_ARRAY != vam->json_tree.type)
9969 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
9970 vat_json_init_array (&vam->json_tree);
9972 node = vat_json_array_add (&vam->json_tree);
9974 vat_json_init_object (node);
9976 clib_memcpy (&addr, mp->our_address, sizeof (addr));
9977 vat_json_object_add_ip6 (node, "our_address", addr);
9978 clib_memcpy (&addr, mp->client_address, sizeof (addr));
9979 vat_json_object_add_ip6 (node, "client_address", addr);
9981 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
9982 vat_json_init_array (lc);
9983 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
9984 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
9985 vat_json_object_add_uint (node, "remote_cookie",
9986 clib_net_to_host_u64 (mp->remote_cookie));
9988 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
9989 vat_json_object_add_uint (node, "local_session_id",
9990 clib_net_to_host_u32 (mp->local_session_id));
9991 vat_json_object_add_uint (node, "remote_session_id",
9992 clib_net_to_host_u32 (mp->remote_session_id));
9993 vat_json_object_add_string_copy (node, "l2_sublayer",
9994 mp->l2_sublayer_present ? (u8 *) "present"
9999 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10001 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10004 /* Get list of l2tpv3-tunnel interfaces */
10005 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
10008 /* Use a control ping for synchronization */
10010 vl_api_control_ping_t *mp;
10011 M (CONTROL_PING, control_ping);
10018 static void vl_api_sw_interface_tap_details_t_handler
10019 (vl_api_sw_interface_tap_details_t * mp)
10021 vat_main_t *vam = &vat_main;
10023 fformat (vam->ofp, "%-16s %d\n",
10024 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10027 static void vl_api_sw_interface_tap_details_t_handler_json
10028 (vl_api_sw_interface_tap_details_t * mp)
10030 vat_main_t *vam = &vat_main;
10031 vat_json_node_t *node = NULL;
10033 if (VAT_JSON_ARRAY != vam->json_tree.type)
10035 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10036 vat_json_init_array (&vam->json_tree);
10038 node = vat_json_array_add (&vam->json_tree);
10040 vat_json_init_object (node);
10041 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10042 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10046 api_sw_interface_tap_dump (vat_main_t * vam)
10048 vl_api_sw_interface_tap_dump_t *mp;
10051 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
10052 /* Get list of tap interfaces */
10053 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
10056 /* Use a control ping for synchronization */
10058 vl_api_control_ping_t *mp;
10059 M (CONTROL_PING, control_ping);
10065 static uword unformat_vxlan_decap_next
10066 (unformat_input_t * input, va_list * args)
10068 u32 *result = va_arg (*args, u32 *);
10071 if (unformat (input, "l2"))
10072 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10073 else if (unformat (input, "%d", &tmp))
10081 api_vxlan_add_del_tunnel (vat_main_t * vam)
10083 unformat_input_t *line_input = vam->input;
10084 vl_api_vxlan_add_del_tunnel_t *mp;
10086 ip4_address_t src4, dst4;
10087 ip6_address_t src6, dst6;
10089 u8 ipv4_set = 0, ipv6_set = 0;
10092 u32 encap_vrf_id = 0;
10093 u32 decap_next_index = ~0;
10096 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10098 if (unformat (line_input, "del"))
10100 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10105 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10110 else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
10115 else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
10120 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10122 else if (unformat (line_input, "decap-next %U",
10123 unformat_vxlan_decap_next, &decap_next_index))
10125 else if (unformat (line_input, "vni %d", &vni))
10129 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10136 errmsg ("tunnel src address not specified\n");
10141 errmsg ("tunnel dst address not specified\n");
10145 if (ipv4_set && ipv6_set)
10147 errmsg ("both IPv4 and IPv6 addresses specified");
10151 if ((vni == 0) || (vni >> 24))
10153 errmsg ("vni not specified or out of range\n");
10157 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10161 clib_memcpy (&mp->src_address, &src6, sizeof (src6));
10162 clib_memcpy (&mp->dst_address, &dst6, sizeof (dst6));
10166 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10167 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10169 mp->encap_vrf_id = ntohl (encap_vrf_id);
10170 mp->decap_next_index = ntohl (decap_next_index);
10171 mp->vni = ntohl (vni);
10172 mp->is_add = is_add;
10173 mp->is_ipv6 = ipv6_set;
10181 static void vl_api_vxlan_tunnel_details_t_handler
10182 (vl_api_vxlan_tunnel_details_t * mp)
10184 vat_main_t *vam = &vat_main;
10186 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
10187 ntohl (mp->sw_if_index),
10188 format_ip46_address, &(mp->src_address[0]),
10190 format_ip46_address, &(mp->dst_address[0]),
10192 ntohl (mp->encap_vrf_id),
10193 ntohl (mp->decap_next_index), ntohl (mp->vni));
10196 static void vl_api_vxlan_tunnel_details_t_handler_json
10197 (vl_api_vxlan_tunnel_details_t * mp)
10199 vat_main_t *vam = &vat_main;
10200 vat_json_node_t *node = NULL;
10201 struct in_addr ip4;
10202 struct in6_addr ip6;
10204 if (VAT_JSON_ARRAY != vam->json_tree.type)
10206 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10207 vat_json_init_array (&vam->json_tree);
10209 node = vat_json_array_add (&vam->json_tree);
10211 vat_json_init_object (node);
10212 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10215 clib_memcpy (&ip6, &(mp->src_address[0]), sizeof (ip6));
10216 vat_json_object_add_ip6 (node, "src_address", ip6);
10217 clib_memcpy (&ip6, &(mp->dst_address[0]), sizeof (ip6));
10218 vat_json_object_add_ip6 (node, "dst_address", ip6);
10222 clib_memcpy (&ip4, &(mp->src_address[0]), sizeof (ip4));
10223 vat_json_object_add_ip4 (node, "src_address", ip4);
10224 clib_memcpy (&ip4, &(mp->dst_address[0]), sizeof (ip4));
10225 vat_json_object_add_ip4 (node, "dst_address", ip4);
10227 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10228 vat_json_object_add_uint (node, "decap_next_index",
10229 ntohl (mp->decap_next_index));
10230 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10231 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10235 api_vxlan_tunnel_dump (vat_main_t * vam)
10237 unformat_input_t *i = vam->input;
10238 vl_api_vxlan_tunnel_dump_t *mp;
10241 u8 sw_if_index_set = 0;
10243 /* Parse args required to build the message */
10244 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10246 if (unformat (i, "sw_if_index %d", &sw_if_index))
10247 sw_if_index_set = 1;
10252 if (sw_if_index_set == 0)
10257 if (!vam->json_output)
10259 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
10260 "sw_if_index", "src_address", "dst_address",
10261 "encap_vrf_id", "decap_next_index", "vni");
10264 /* Get list of vxlan-tunnel interfaces */
10265 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10267 mp->sw_if_index = htonl (sw_if_index);
10271 /* Use a control ping for synchronization */
10273 vl_api_control_ping_t *mp;
10274 M (CONTROL_PING, control_ping);
10281 api_gre_add_del_tunnel (vat_main_t * vam)
10283 unformat_input_t *line_input = vam->input;
10284 vl_api_gre_add_del_tunnel_t *mp;
10286 ip4_address_t src4, dst4;
10291 u32 outer_fib_id = 0;
10293 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10295 if (unformat (line_input, "del"))
10297 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10299 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10301 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10303 else if (unformat (line_input, "teb"))
10307 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10314 errmsg ("tunnel src address not specified\n");
10319 errmsg ("tunnel dst address not specified\n");
10324 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10326 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10327 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10328 mp->outer_fib_id = ntohl (outer_fib_id);
10329 mp->is_add = is_add;
10338 static void vl_api_gre_tunnel_details_t_handler
10339 (vl_api_gre_tunnel_details_t * mp)
10341 vat_main_t *vam = &vat_main;
10343 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
10344 ntohl (mp->sw_if_index),
10345 format_ip4_address, &mp->src_address,
10346 format_ip4_address, &mp->dst_address,
10347 mp->teb, ntohl (mp->outer_fib_id));
10350 static void vl_api_gre_tunnel_details_t_handler_json
10351 (vl_api_gre_tunnel_details_t * mp)
10353 vat_main_t *vam = &vat_main;
10354 vat_json_node_t *node = NULL;
10355 struct in_addr ip4;
10357 if (VAT_JSON_ARRAY != vam->json_tree.type)
10359 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10360 vat_json_init_array (&vam->json_tree);
10362 node = vat_json_array_add (&vam->json_tree);
10364 vat_json_init_object (node);
10365 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10366 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10367 vat_json_object_add_ip4 (node, "src_address", ip4);
10368 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10369 vat_json_object_add_ip4 (node, "dst_address", ip4);
10370 vat_json_object_add_uint (node, "teb", mp->teb);
10371 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10375 api_gre_tunnel_dump (vat_main_t * vam)
10377 unformat_input_t *i = vam->input;
10378 vl_api_gre_tunnel_dump_t *mp;
10381 u8 sw_if_index_set = 0;
10383 /* Parse args required to build the message */
10384 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10386 if (unformat (i, "sw_if_index %d", &sw_if_index))
10387 sw_if_index_set = 1;
10392 if (sw_if_index_set == 0)
10397 if (!vam->json_output)
10399 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
10400 "sw_if_index", "src_address", "dst_address", "teb",
10404 /* Get list of gre-tunnel interfaces */
10405 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
10407 mp->sw_if_index = htonl (sw_if_index);
10411 /* Use a control ping for synchronization */
10413 vl_api_control_ping_t *mp;
10414 M (CONTROL_PING, control_ping);
10421 api_l2_fib_clear_table (vat_main_t * vam)
10423 // unformat_input_t * i = vam->input;
10424 vl_api_l2_fib_clear_table_t *mp;
10427 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
10436 api_l2_interface_efp_filter (vat_main_t * vam)
10438 unformat_input_t *i = vam->input;
10439 vl_api_l2_interface_efp_filter_t *mp;
10443 u8 sw_if_index_set = 0;
10445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10447 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10448 sw_if_index_set = 1;
10449 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10450 sw_if_index_set = 1;
10451 else if (unformat (i, "enable"))
10453 else if (unformat (i, "disable"))
10457 clib_warning ("parse error '%U'", format_unformat_error, i);
10462 if (sw_if_index_set == 0)
10464 errmsg ("missing sw_if_index\n");
10468 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
10470 mp->sw_if_index = ntohl (sw_if_index);
10471 mp->enable_disable = enable;
10479 #define foreach_vtr_op \
10480 _("disable", L2_VTR_DISABLED) \
10481 _("push-1", L2_VTR_PUSH_1) \
10482 _("push-2", L2_VTR_PUSH_2) \
10483 _("pop-1", L2_VTR_POP_1) \
10484 _("pop-2", L2_VTR_POP_2) \
10485 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10486 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10487 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10488 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10491 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10493 unformat_input_t *i = vam->input;
10494 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10497 u8 sw_if_index_set = 0;
10500 u32 push_dot1q = 1;
10504 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10506 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10507 sw_if_index_set = 1;
10508 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10509 sw_if_index_set = 1;
10510 else if (unformat (i, "vtr_op %d", &vtr_op))
10512 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10515 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10517 else if (unformat (i, "tag1 %d", &tag1))
10519 else if (unformat (i, "tag2 %d", &tag2))
10523 clib_warning ("parse error '%U'", format_unformat_error, i);
10528 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10530 errmsg ("missing vtr operation or sw_if_index\n");
10534 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
10535 mp->sw_if_index = ntohl (sw_if_index);
10536 mp->vtr_op = ntohl (vtr_op);
10537 mp->push_dot1q = ntohl (push_dot1q);
10538 mp->tag1 = ntohl (tag1);
10539 mp->tag2 = ntohl (tag2);
10548 api_create_vhost_user_if (vat_main_t * vam)
10550 unformat_input_t *i = vam->input;
10551 vl_api_create_vhost_user_if_t *mp;
10555 u8 file_name_set = 0;
10556 u32 custom_dev_instance = ~0;
10558 u8 use_custom_mac = 0;
10560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10562 if (unformat (i, "socket %s", &file_name))
10566 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10568 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10569 use_custom_mac = 1;
10570 else if (unformat (i, "server"))
10576 if (file_name_set == 0)
10578 errmsg ("missing socket file name\n");
10582 if (vec_len (file_name) > 255)
10584 errmsg ("socket file name too long\n");
10587 vec_add1 (file_name, 0);
10589 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
10591 mp->is_server = is_server;
10592 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10593 vec_free (file_name);
10594 if (custom_dev_instance != ~0)
10597 mp->custom_dev_instance = ntohl (custom_dev_instance);
10599 mp->use_custom_mac = use_custom_mac;
10600 clib_memcpy (mp->mac_address, hwaddr, 6);
10609 api_modify_vhost_user_if (vat_main_t * vam)
10611 unformat_input_t *i = vam->input;
10612 vl_api_modify_vhost_user_if_t *mp;
10616 u8 file_name_set = 0;
10617 u32 custom_dev_instance = ~0;
10618 u8 sw_if_index_set = 0;
10619 u32 sw_if_index = (u32) ~ 0;
10621 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10623 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10624 sw_if_index_set = 1;
10625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10626 sw_if_index_set = 1;
10627 else if (unformat (i, "socket %s", &file_name))
10631 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10633 else if (unformat (i, "server"))
10639 if (sw_if_index_set == 0)
10641 errmsg ("missing sw_if_index or interface name\n");
10645 if (file_name_set == 0)
10647 errmsg ("missing socket file name\n");
10651 if (vec_len (file_name) > 255)
10653 errmsg ("socket file name too long\n");
10656 vec_add1 (file_name, 0);
10658 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
10660 mp->sw_if_index = ntohl (sw_if_index);
10661 mp->is_server = is_server;
10662 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10663 vec_free (file_name);
10664 if (custom_dev_instance != ~0)
10667 mp->custom_dev_instance = ntohl (custom_dev_instance);
10677 api_delete_vhost_user_if (vat_main_t * vam)
10679 unformat_input_t *i = vam->input;
10680 vl_api_delete_vhost_user_if_t *mp;
10682 u32 sw_if_index = ~0;
10683 u8 sw_if_index_set = 0;
10685 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10687 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10688 sw_if_index_set = 1;
10689 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10690 sw_if_index_set = 1;
10695 if (sw_if_index_set == 0)
10697 errmsg ("missing sw_if_index or interface name\n");
10702 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
10704 mp->sw_if_index = ntohl (sw_if_index);
10712 static void vl_api_sw_interface_vhost_user_details_t_handler
10713 (vl_api_sw_interface_vhost_user_details_t * mp)
10715 vat_main_t *vam = &vat_main;
10717 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
10718 (char *) mp->interface_name,
10719 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10720 clib_net_to_host_u64 (mp->features), mp->is_server,
10721 ntohl (mp->num_regions), (char *) mp->sock_filename);
10722 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
10725 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10726 (vl_api_sw_interface_vhost_user_details_t * mp)
10728 vat_main_t *vam = &vat_main;
10729 vat_json_node_t *node = NULL;
10731 if (VAT_JSON_ARRAY != vam->json_tree.type)
10733 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10734 vat_json_init_array (&vam->json_tree);
10736 node = vat_json_array_add (&vam->json_tree);
10738 vat_json_init_object (node);
10739 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10740 vat_json_object_add_string_copy (node, "interface_name",
10741 mp->interface_name);
10742 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10743 ntohl (mp->virtio_net_hdr_sz));
10744 vat_json_object_add_uint (node, "features",
10745 clib_net_to_host_u64 (mp->features));
10746 vat_json_object_add_uint (node, "is_server", mp->is_server);
10747 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10748 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10749 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10753 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10755 vl_api_sw_interface_vhost_user_dump_t *mp;
10758 "Interface name idx hdr_sz features server regions filename\n");
10760 /* Get list of vhost-user interfaces */
10761 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
10764 /* Use a control ping for synchronization */
10766 vl_api_control_ping_t *mp;
10767 M (CONTROL_PING, control_ping);
10774 api_show_version (vat_main_t * vam)
10776 vl_api_show_version_t *mp;
10779 M (SHOW_VERSION, show_version);
10789 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
10791 unformat_input_t *line_input = vam->input;
10792 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
10794 ip4_address_t local4, remote4;
10795 ip6_address_t local6, remote6;
10797 u8 ipv4_set = 0, ipv6_set = 0;
10800 u32 encap_vrf_id = 0;
10801 u32 decap_vrf_id = 0;
10806 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10808 if (unformat (line_input, "del"))
10810 else if (unformat (line_input, "local %U",
10811 unformat_ip4_address, &local4))
10816 else if (unformat (line_input, "remote %U",
10817 unformat_ip4_address, &remote4))
10822 else if (unformat (line_input, "local %U",
10823 unformat_ip6_address, &local6))
10828 else if (unformat (line_input, "remote %U",
10829 unformat_ip6_address, &remote6))
10834 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10836 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
10838 else if (unformat (line_input, "vni %d", &vni))
10840 else if (unformat (line_input, "next-ip4"))
10842 else if (unformat (line_input, "next-ip6"))
10844 else if (unformat (line_input, "next-ethernet"))
10846 else if (unformat (line_input, "next-nsh"))
10850 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10855 if (local_set == 0)
10857 errmsg ("tunnel local address not specified\n");
10860 if (remote_set == 0)
10862 errmsg ("tunnel remote address not specified\n");
10865 if (ipv4_set && ipv6_set)
10867 errmsg ("both IPv4 and IPv6 addresses specified");
10873 errmsg ("vni not specified\n");
10877 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
10882 clib_memcpy (&mp->local, &local6, sizeof (local6));
10883 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
10887 clib_memcpy (&mp->local, &local4, sizeof (local4));
10888 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
10891 mp->encap_vrf_id = ntohl (encap_vrf_id);
10892 mp->decap_vrf_id = ntohl (decap_vrf_id);
10893 mp->protocol = ntohl (protocol);
10894 mp->vni = ntohl (vni);
10895 mp->is_add = is_add;
10896 mp->is_ipv6 = ipv6_set;
10904 static void vl_api_vxlan_gpe_tunnel_details_t_handler
10905 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10907 vat_main_t *vam = &vat_main;
10909 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
10910 ntohl (mp->sw_if_index),
10911 format_ip46_address, &(mp->local[0]),
10912 format_ip46_address, &(mp->remote[0]),
10914 ntohl (mp->protocol),
10915 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
10918 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
10919 (vl_api_vxlan_gpe_tunnel_details_t * mp)
10921 vat_main_t *vam = &vat_main;
10922 vat_json_node_t *node = NULL;
10923 struct in_addr ip4;
10924 struct in6_addr ip6;
10926 if (VAT_JSON_ARRAY != vam->json_tree.type)
10928 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10929 vat_json_init_array (&vam->json_tree);
10931 node = vat_json_array_add (&vam->json_tree);
10933 vat_json_init_object (node);
10934 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10937 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
10938 vat_json_object_add_ip6 (node, "local", ip6);
10939 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
10940 vat_json_object_add_ip6 (node, "remote", ip6);
10944 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
10945 vat_json_object_add_ip4 (node, "local", ip4);
10946 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
10947 vat_json_object_add_ip4 (node, "remote", ip4);
10949 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10950 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
10951 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10952 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
10953 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10957 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
10959 unformat_input_t *i = vam->input;
10960 vl_api_vxlan_gpe_tunnel_dump_t *mp;
10963 u8 sw_if_index_set = 0;
10965 /* Parse args required to build the message */
10966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10968 if (unformat (i, "sw_if_index %d", &sw_if_index))
10969 sw_if_index_set = 1;
10974 if (sw_if_index_set == 0)
10979 if (!vam->json_output)
10981 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
10982 "sw_if_index", "local", "remote", "vni",
10983 "protocol", "encap_vrf_id", "decap_vrf_id");
10986 /* Get list of vxlan-tunnel interfaces */
10987 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
10989 mp->sw_if_index = htonl (sw_if_index);
10993 /* Use a control ping for synchronization */
10995 vl_api_control_ping_t *mp;
10996 M (CONTROL_PING, control_ping);
11003 format_l2_fib_mac_address (u8 * s, va_list * args)
11005 u8 *a = va_arg (*args, u8 *);
11007 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11008 a[2], a[3], a[4], a[5], a[6], a[7]);
11011 static void vl_api_l2_fib_table_entry_t_handler
11012 (vl_api_l2_fib_table_entry_t * mp)
11014 vat_main_t *vam = &vat_main;
11016 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11018 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11019 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11023 static void vl_api_l2_fib_table_entry_t_handler_json
11024 (vl_api_l2_fib_table_entry_t * mp)
11026 vat_main_t *vam = &vat_main;
11027 vat_json_node_t *node = NULL;
11029 if (VAT_JSON_ARRAY != vam->json_tree.type)
11031 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11032 vat_json_init_array (&vam->json_tree);
11034 node = vat_json_array_add (&vam->json_tree);
11036 vat_json_init_object (node);
11037 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11038 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11039 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11040 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11041 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11042 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11046 api_l2_fib_table_dump (vat_main_t * vam)
11048 unformat_input_t *i = vam->input;
11049 vl_api_l2_fib_table_dump_t *mp;
11054 /* Parse args required to build the message */
11055 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11057 if (unformat (i, "bd_id %d", &bd_id))
11063 if (bd_id_set == 0)
11065 errmsg ("missing bridge domain\n");
11070 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
11072 /* Get list of l2 fib entries */
11073 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11075 mp->bd_id = ntohl (bd_id);
11078 /* Use a control ping for synchronization */
11080 vl_api_control_ping_t *mp;
11081 M (CONTROL_PING, control_ping);
11089 api_interface_name_renumber (vat_main_t * vam)
11091 unformat_input_t *line_input = vam->input;
11092 vl_api_interface_name_renumber_t *mp;
11093 u32 sw_if_index = ~0;
11095 u32 new_show_dev_instance = ~0;
11097 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11099 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
11102 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11104 else if (unformat (line_input, "new_show_dev_instance %d",
11105 &new_show_dev_instance))
11111 if (sw_if_index == ~0)
11113 errmsg ("missing interface name or sw_if_index\n");
11117 if (new_show_dev_instance == ~0)
11119 errmsg ("missing new_show_dev_instance\n");
11123 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11125 mp->sw_if_index = ntohl (sw_if_index);
11126 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11133 api_want_ip4_arp_events (vat_main_t * vam)
11135 unformat_input_t *line_input = vam->input;
11136 vl_api_want_ip4_arp_events_t *mp;
11138 ip4_address_t address;
11139 int address_set = 0;
11140 u32 enable_disable = 1;
11142 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11144 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11146 else if (unformat (line_input, "del"))
11147 enable_disable = 0;
11152 if (address_set == 0)
11154 errmsg ("missing addresses\n");
11158 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11159 mp->enable_disable = enable_disable;
11160 mp->pid = getpid ();
11161 mp->address = address.as_u32;
11168 api_want_ip6_nd_events (vat_main_t * vam)
11170 unformat_input_t *line_input = vam->input;
11171 vl_api_want_ip6_nd_events_t *mp;
11173 ip6_address_t address;
11174 int address_set = 0;
11175 u32 enable_disable = 1;
11177 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11179 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11181 else if (unformat (line_input, "del"))
11182 enable_disable = 0;
11187 if (address_set == 0)
11189 errmsg ("missing addresses\n");
11193 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11194 mp->enable_disable = enable_disable;
11195 mp->pid = getpid ();
11196 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11203 api_input_acl_set_interface (vat_main_t * vam)
11205 unformat_input_t *i = vam->input;
11206 vl_api_input_acl_set_interface_t *mp;
11209 int sw_if_index_set;
11210 u32 ip4_table_index = ~0;
11211 u32 ip6_table_index = ~0;
11212 u32 l2_table_index = ~0;
11215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11217 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11218 sw_if_index_set = 1;
11219 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11220 sw_if_index_set = 1;
11221 else if (unformat (i, "del"))
11223 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11225 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11227 else if (unformat (i, "l2-table %d", &l2_table_index))
11231 clib_warning ("parse error '%U'", format_unformat_error, i);
11236 if (sw_if_index_set == 0)
11238 errmsg ("missing interface name or sw_if_index\n");
11242 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11244 mp->sw_if_index = ntohl (sw_if_index);
11245 mp->ip4_table_index = ntohl (ip4_table_index);
11246 mp->ip6_table_index = ntohl (ip6_table_index);
11247 mp->l2_table_index = ntohl (l2_table_index);
11248 mp->is_add = is_add;
11257 api_ip_address_dump (vat_main_t * vam)
11259 unformat_input_t *i = vam->input;
11260 vl_api_ip_address_dump_t *mp;
11261 u32 sw_if_index = ~0;
11262 u8 sw_if_index_set = 0;
11267 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11269 if (unformat (i, "sw_if_index %d", &sw_if_index))
11270 sw_if_index_set = 1;
11271 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11272 sw_if_index_set = 1;
11273 else if (unformat (i, "ipv4"))
11275 else if (unformat (i, "ipv6"))
11281 if (ipv4_set && ipv6_set)
11283 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11287 if ((!ipv4_set) && (!ipv6_set))
11289 errmsg ("no ipv4 nor ipv6 flag set\n");
11293 if (sw_if_index_set == 0)
11295 errmsg ("missing interface name or sw_if_index\n");
11299 vam->current_sw_if_index = sw_if_index;
11300 vam->is_ipv6 = ipv6_set;
11302 M (IP_ADDRESS_DUMP, ip_address_dump);
11303 mp->sw_if_index = ntohl (sw_if_index);
11304 mp->is_ipv6 = ipv6_set;
11307 /* Use a control ping for synchronization */
11309 vl_api_control_ping_t *mp;
11310 M (CONTROL_PING, control_ping);
11317 api_ip_dump (vat_main_t * vam)
11319 vl_api_ip_dump_t *mp;
11320 unformat_input_t *in = vam->input;
11327 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11329 if (unformat (in, "ipv4"))
11331 else if (unformat (in, "ipv6"))
11337 if (ipv4_set && ipv6_set)
11339 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11343 if ((!ipv4_set) && (!ipv6_set))
11345 errmsg ("no ipv4 nor ipv6 flag set\n");
11349 is_ipv6 = ipv6_set;
11350 vam->is_ipv6 = is_ipv6;
11352 /* free old data */
11353 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11355 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11357 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11359 M (IP_DUMP, ip_dump);
11360 mp->is_ipv6 = ipv6_set;
11363 /* Use a control ping for synchronization */
11365 vl_api_control_ping_t *mp;
11366 M (CONTROL_PING, control_ping);
11373 api_ipsec_spd_add_del (vat_main_t * vam)
11376 unformat_input_t *i = vam->input;
11377 vl_api_ipsec_spd_add_del_t *mp;
11382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11384 if (unformat (i, "spd_id %d", &spd_id))
11386 else if (unformat (i, "del"))
11390 clib_warning ("parse error '%U'", format_unformat_error, i);
11396 errmsg ("spd_id must be set\n");
11400 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
11402 mp->spd_id = ntohl (spd_id);
11403 mp->is_add = is_add;
11410 clib_warning ("unsupported (no dpdk)");
11416 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11419 unformat_input_t *i = vam->input;
11420 vl_api_ipsec_interface_add_del_spd_t *mp;
11423 u8 sw_if_index_set = 0;
11424 u32 spd_id = (u32) ~ 0;
11427 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11429 if (unformat (i, "del"))
11431 else if (unformat (i, "spd_id %d", &spd_id))
11433 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11434 sw_if_index_set = 1;
11435 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11436 sw_if_index_set = 1;
11439 clib_warning ("parse error '%U'", format_unformat_error, i);
11445 if (spd_id == (u32) ~ 0)
11447 errmsg ("spd_id must be set\n");
11451 if (sw_if_index_set == 0)
11453 errmsg ("missing interface name or sw_if_index\n");
11457 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
11459 mp->spd_id = ntohl (spd_id);
11460 mp->sw_if_index = ntohl (sw_if_index);
11461 mp->is_add = is_add;
11468 clib_warning ("unsupported (no dpdk)");
11474 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11477 unformat_input_t *i = vam->input;
11478 vl_api_ipsec_spd_add_del_entry_t *mp;
11480 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11481 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11483 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11484 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11485 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11486 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11488 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11489 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11490 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11491 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11492 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11493 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11495 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11497 if (unformat (i, "del"))
11499 if (unformat (i, "outbound"))
11501 if (unformat (i, "inbound"))
11503 else if (unformat (i, "spd_id %d", &spd_id))
11505 else if (unformat (i, "sa_id %d", &sa_id))
11507 else if (unformat (i, "priority %d", &priority))
11509 else if (unformat (i, "protocol %d", &protocol))
11511 else if (unformat (i, "lport_start %d", &lport_start))
11513 else if (unformat (i, "lport_stop %d", &lport_stop))
11515 else if (unformat (i, "rport_start %d", &rport_start))
11517 else if (unformat (i, "rport_stop %d", &rport_stop))
11521 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11527 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11534 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11540 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11547 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11553 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
11560 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
11566 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
11572 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11574 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11576 clib_warning ("unsupported action: 'resolve'");
11582 clib_warning ("parse error '%U'", format_unformat_error, i);
11588 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
11590 mp->spd_id = ntohl (spd_id);
11591 mp->priority = ntohl (priority);
11592 mp->is_outbound = is_outbound;
11594 mp->is_ipv6 = is_ipv6;
11595 if (is_ipv6 || is_ip_any)
11597 clib_memcpy (mp->remote_address_start, &raddr6_start,
11598 sizeof (ip6_address_t));
11599 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
11600 sizeof (ip6_address_t));
11601 clib_memcpy (mp->local_address_start, &laddr6_start,
11602 sizeof (ip6_address_t));
11603 clib_memcpy (mp->local_address_stop, &laddr6_stop,
11604 sizeof (ip6_address_t));
11608 clib_memcpy (mp->remote_address_start, &raddr4_start,
11609 sizeof (ip4_address_t));
11610 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
11611 sizeof (ip4_address_t));
11612 clib_memcpy (mp->local_address_start, &laddr4_start,
11613 sizeof (ip4_address_t));
11614 clib_memcpy (mp->local_address_stop, &laddr4_stop,
11615 sizeof (ip4_address_t));
11617 mp->protocol = (u8) protocol;
11618 mp->local_port_start = ntohs ((u16) lport_start);
11619 mp->local_port_stop = ntohs ((u16) lport_stop);
11620 mp->remote_port_start = ntohs ((u16) rport_start);
11621 mp->remote_port_stop = ntohs ((u16) rport_stop);
11622 mp->policy = (u8) policy;
11623 mp->sa_id = ntohl (sa_id);
11624 mp->is_add = is_add;
11625 mp->is_ip_any = is_ip_any;
11631 clib_warning ("unsupported (no dpdk)");
11637 api_ipsec_sad_add_del_entry (vat_main_t * vam)
11640 unformat_input_t *i = vam->input;
11641 vl_api_ipsec_sad_add_del_entry_t *mp;
11643 u32 sad_id = 0, spi = 0;
11644 u8 *ck = 0, *ik = 0;
11647 u8 protocol = IPSEC_PROTOCOL_AH;
11648 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
11649 u32 crypto_alg = 0, integ_alg = 0;
11650 ip4_address_t tun_src4;
11651 ip4_address_t tun_dst4;
11652 ip6_address_t tun_src6;
11653 ip6_address_t tun_dst6;
11655 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11657 if (unformat (i, "del"))
11659 else if (unformat (i, "sad_id %d", &sad_id))
11661 else if (unformat (i, "spi %d", &spi))
11663 else if (unformat (i, "esp"))
11664 protocol = IPSEC_PROTOCOL_ESP;
11665 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
11668 is_tunnel_ipv6 = 0;
11670 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
11673 is_tunnel_ipv6 = 0;
11675 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
11678 is_tunnel_ipv6 = 1;
11680 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
11683 is_tunnel_ipv6 = 1;
11687 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
11689 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
11690 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256)
11692 clib_warning ("unsupported crypto-alg: '%U'",
11693 format_ipsec_crypto_alg, crypto_alg);
11697 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11701 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
11703 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
11704 integ_alg > IPSEC_INTEG_ALG_SHA_512_256)
11706 clib_warning ("unsupported integ-alg: '%U'",
11707 format_ipsec_integ_alg, integ_alg);
11711 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11715 clib_warning ("parse error '%U'", format_unformat_error, i);
11721 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
11723 mp->sad_id = ntohl (sad_id);
11724 mp->is_add = is_add;
11725 mp->protocol = protocol;
11726 mp->spi = ntohl (spi);
11727 mp->is_tunnel = is_tunnel;
11728 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
11729 mp->crypto_algorithm = crypto_alg;
11730 mp->integrity_algorithm = integ_alg;
11731 mp->crypto_key_length = vec_len (ck);
11732 mp->integrity_key_length = vec_len (ik);
11734 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11735 mp->crypto_key_length = sizeof (mp->crypto_key);
11737 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11738 mp->integrity_key_length = sizeof (mp->integrity_key);
11741 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11743 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11747 if (is_tunnel_ipv6)
11749 clib_memcpy (mp->tunnel_src_address, &tun_src6,
11750 sizeof (ip6_address_t));
11751 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
11752 sizeof (ip6_address_t));
11756 clib_memcpy (mp->tunnel_src_address, &tun_src4,
11757 sizeof (ip4_address_t));
11758 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
11759 sizeof (ip4_address_t));
11768 clib_warning ("unsupported (no dpdk)");
11774 api_ipsec_sa_set_key (vat_main_t * vam)
11777 unformat_input_t *i = vam->input;
11778 vl_api_ipsec_sa_set_key_t *mp;
11781 u8 *ck = 0, *ik = 0;
11783 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11785 if (unformat (i, "sa_id %d", &sa_id))
11787 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11789 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11793 clib_warning ("parse error '%U'", format_unformat_error, i);
11798 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
11800 mp->sa_id = ntohl (sa_id);
11801 mp->crypto_key_length = vec_len (ck);
11802 mp->integrity_key_length = vec_len (ik);
11804 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11805 mp->crypto_key_length = sizeof (mp->crypto_key);
11807 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11808 mp->integrity_key_length = sizeof (mp->integrity_key);
11811 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11813 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11820 clib_warning ("unsupported (no dpdk)");
11826 api_ikev2_profile_add_del (vat_main_t * vam)
11829 unformat_input_t *i = vam->input;
11830 vl_api_ikev2_profile_add_del_t *mp;
11835 const char *valid_chars = "a-zA-Z0-9_";
11837 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11839 if (unformat (i, "del"))
11841 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11842 vec_add1 (name, 0);
11845 errmsg ("parse error '%U'", format_unformat_error, i);
11850 if (!vec_len (name))
11852 errmsg ("profile name must be specified");
11856 if (vec_len (name) > 64)
11858 errmsg ("profile name too long");
11862 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
11864 clib_memcpy (mp->name, name, vec_len (name));
11865 mp->is_add = is_add;
11873 clib_warning ("unsupported (no dpdk)");
11879 api_ikev2_profile_set_auth (vat_main_t * vam)
11882 unformat_input_t *i = vam->input;
11883 vl_api_ikev2_profile_set_auth_t *mp;
11887 u32 auth_method = 0;
11890 const char *valid_chars = "a-zA-Z0-9_";
11892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11894 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11895 vec_add1 (name, 0);
11896 else if (unformat (i, "auth_method %U",
11897 unformat_ikev2_auth_method, &auth_method))
11899 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
11901 else if (unformat (i, "auth_data %v", &data))
11905 errmsg ("parse error '%U'", format_unformat_error, i);
11910 if (!vec_len (name))
11912 errmsg ("profile name must be specified");
11916 if (vec_len (name) > 64)
11918 errmsg ("profile name too long");
11922 if (!vec_len (data))
11924 errmsg ("auth_data must be specified");
11930 errmsg ("auth_method must be specified");
11934 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
11936 mp->is_hex = is_hex;
11937 mp->auth_method = (u8) auth_method;
11938 mp->data_len = vec_len (data);
11939 clib_memcpy (mp->name, name, vec_len (name));
11940 clib_memcpy (mp->data, data, vec_len (data));
11949 clib_warning ("unsupported (no dpdk)");
11955 api_ikev2_profile_set_id (vat_main_t * vam)
11958 unformat_input_t *i = vam->input;
11959 vl_api_ikev2_profile_set_id_t *mp;
11967 const char *valid_chars = "a-zA-Z0-9_";
11969 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11971 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
11972 vec_add1 (name, 0);
11973 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
11975 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
11977 data = vec_new (u8, 4);
11978 clib_memcpy (data, ip4.as_u8, 4);
11980 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
11982 else if (unformat (i, "id_data %v", &data))
11984 else if (unformat (i, "local"))
11986 else if (unformat (i, "remote"))
11990 errmsg ("parse error '%U'", format_unformat_error, i);
11995 if (!vec_len (name))
11997 errmsg ("profile name must be specified");
12001 if (vec_len (name) > 64)
12003 errmsg ("profile name too long");
12007 if (!vec_len (data))
12009 errmsg ("id_data must be specified");
12015 errmsg ("id_type must be specified");
12019 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
12021 mp->is_local = is_local;
12022 mp->id_type = (u8) id_type;
12023 mp->data_len = vec_len (data);
12024 clib_memcpy (mp->name, name, vec_len (name));
12025 clib_memcpy (mp->data, data, vec_len (data));
12034 clib_warning ("unsupported (no dpdk)");
12040 api_ikev2_profile_set_ts (vat_main_t * vam)
12043 unformat_input_t *i = vam->input;
12044 vl_api_ikev2_profile_set_ts_t *mp;
12048 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12049 ip4_address_t start_addr, end_addr;
12051 const char *valid_chars = "a-zA-Z0-9_";
12053 start_addr.as_u32 = 0;
12054 end_addr.as_u32 = (u32) ~ 0;
12056 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12058 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12059 vec_add1 (name, 0);
12060 else if (unformat (i, "protocol %d", &proto))
12062 else if (unformat (i, "start_port %d", &start_port))
12064 else if (unformat (i, "end_port %d", &end_port))
12067 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12069 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12071 else if (unformat (i, "local"))
12073 else if (unformat (i, "remote"))
12077 errmsg ("parse error '%U'", format_unformat_error, i);
12082 if (!vec_len (name))
12084 errmsg ("profile name must be specified");
12088 if (vec_len (name) > 64)
12090 errmsg ("profile name too long");
12094 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12096 mp->is_local = is_local;
12097 mp->proto = (u8) proto;
12098 mp->start_port = (u16) start_port;
12099 mp->end_port = (u16) end_port;
12100 mp->start_addr = start_addr.as_u32;
12101 mp->end_addr = end_addr.as_u32;
12102 clib_memcpy (mp->name, name, vec_len (name));
12110 clib_warning ("unsupported (no dpdk)");
12116 api_ikev2_set_local_key (vat_main_t * vam)
12119 unformat_input_t *i = vam->input;
12120 vl_api_ikev2_set_local_key_t *mp;
12124 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12126 if (unformat (i, "file %v", &file))
12127 vec_add1 (file, 0);
12130 errmsg ("parse error '%U'", format_unformat_error, i);
12135 if (!vec_len (file))
12137 errmsg ("RSA key file must be specified");
12141 if (vec_len (file) > 256)
12143 errmsg ("file name too long");
12147 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12149 clib_memcpy (mp->key_file, file, vec_len (file));
12157 clib_warning ("unsupported (no dpdk)");
12166 api_map_add_domain (vat_main_t * vam)
12168 unformat_input_t *i = vam->input;
12169 vl_api_map_add_domain_t *mp;
12172 ip4_address_t ip4_prefix;
12173 ip6_address_t ip6_prefix;
12174 ip6_address_t ip6_src;
12175 u32 num_m_args = 0;
12176 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12177 0, psid_length = 0;
12178 u8 is_translation = 0;
12180 u32 ip6_src_len = 128;
12182 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12184 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12185 &ip4_prefix, &ip4_prefix_len))
12187 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12188 &ip6_prefix, &ip6_prefix_len))
12192 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12195 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12197 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12199 else if (unformat (i, "psid-offset %d", &psid_offset))
12201 else if (unformat (i, "psid-len %d", &psid_length))
12203 else if (unformat (i, "mtu %d", &mtu))
12205 else if (unformat (i, "map-t"))
12206 is_translation = 1;
12209 clib_warning ("parse error '%U'", format_unformat_error, i);
12214 if (num_m_args < 3)
12216 errmsg ("mandatory argument(s) missing\n");
12220 /* Construct the API message */
12221 M (MAP_ADD_DOMAIN, map_add_domain);
12223 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12224 mp->ip4_prefix_len = ip4_prefix_len;
12226 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12227 mp->ip6_prefix_len = ip6_prefix_len;
12229 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12230 mp->ip6_src_prefix_len = ip6_src_len;
12232 mp->ea_bits_len = ea_bits_len;
12233 mp->psid_offset = psid_offset;
12234 mp->psid_length = psid_length;
12235 mp->is_translation = is_translation;
12236 mp->mtu = htons (mtu);
12241 /* Wait for a reply, return good/bad news */
12246 api_map_del_domain (vat_main_t * vam)
12248 unformat_input_t *i = vam->input;
12249 vl_api_map_del_domain_t *mp;
12252 u32 num_m_args = 0;
12255 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12257 if (unformat (i, "index %d", &index))
12261 clib_warning ("parse error '%U'", format_unformat_error, i);
12266 if (num_m_args != 1)
12268 errmsg ("mandatory argument(s) missing\n");
12272 /* Construct the API message */
12273 M (MAP_DEL_DOMAIN, map_del_domain);
12275 mp->index = ntohl (index);
12280 /* Wait for a reply, return good/bad news */
12285 api_map_add_del_rule (vat_main_t * vam)
12287 unformat_input_t *i = vam->input;
12288 vl_api_map_add_del_rule_t *mp;
12291 ip6_address_t ip6_dst;
12292 u32 num_m_args = 0, index, psid = 0;
12294 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12296 if (unformat (i, "index %d", &index))
12298 else if (unformat (i, "psid %d", &psid))
12300 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12302 else if (unformat (i, "del"))
12308 clib_warning ("parse error '%U'", format_unformat_error, i);
12313 /* Construct the API message */
12314 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12316 mp->index = ntohl (index);
12317 mp->is_add = is_add;
12318 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12319 mp->psid = ntohs (psid);
12324 /* Wait for a reply, return good/bad news */
12329 api_map_domain_dump (vat_main_t * vam)
12331 vl_api_map_domain_dump_t *mp;
12334 /* Construct the API message */
12335 M (MAP_DOMAIN_DUMP, map_domain_dump);
12340 /* Use a control ping for synchronization */
12342 vl_api_control_ping_t *mp;
12343 M (CONTROL_PING, control_ping);
12350 api_map_rule_dump (vat_main_t * vam)
12352 unformat_input_t *i = vam->input;
12353 vl_api_map_rule_dump_t *mp;
12355 u32 domain_index = ~0;
12357 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12359 if (unformat (i, "index %u", &domain_index))
12365 if (domain_index == ~0)
12367 clib_warning ("parse error: domain index expected");
12371 /* Construct the API message */
12372 M (MAP_RULE_DUMP, map_rule_dump);
12374 mp->domain_index = htonl (domain_index);
12379 /* Use a control ping for synchronization */
12381 vl_api_control_ping_t *mp;
12382 M (CONTROL_PING, control_ping);
12388 static void vl_api_map_add_domain_reply_t_handler
12389 (vl_api_map_add_domain_reply_t * mp)
12391 vat_main_t *vam = &vat_main;
12392 i32 retval = ntohl (mp->retval);
12394 if (vam->async_mode)
12396 vam->async_errors += (retval < 0);
12400 vam->retval = retval;
12401 vam->result_ready = 1;
12405 static void vl_api_map_add_domain_reply_t_handler_json
12406 (vl_api_map_add_domain_reply_t * mp)
12408 vat_main_t *vam = &vat_main;
12409 vat_json_node_t node;
12411 vat_json_init_object (&node);
12412 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12413 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12415 vat_json_print (vam->ofp, &node);
12416 vat_json_free (&node);
12418 vam->retval = ntohl (mp->retval);
12419 vam->result_ready = 1;
12423 api_get_first_msg_id (vat_main_t * vam)
12425 vl_api_get_first_msg_id_t *mp;
12427 unformat_input_t *i = vam->input;
12431 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12433 if (unformat (i, "client %s", &name))
12441 errmsg ("missing client name\n");
12444 vec_add1 (name, 0);
12446 if (vec_len (name) > 63)
12448 errmsg ("client name too long\n");
12452 M (GET_FIRST_MSG_ID, get_first_msg_id);
12453 clib_memcpy (mp->name, name, vec_len (name));
12461 api_cop_interface_enable_disable (vat_main_t * vam)
12463 unformat_input_t *line_input = vam->input;
12464 vl_api_cop_interface_enable_disable_t *mp;
12466 u32 sw_if_index = ~0;
12467 u8 enable_disable = 1;
12469 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12471 if (unformat (line_input, "disable"))
12472 enable_disable = 0;
12473 if (unformat (line_input, "enable"))
12474 enable_disable = 1;
12475 else if (unformat (line_input, "%U", unformat_sw_if_index,
12476 vam, &sw_if_index))
12478 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12484 if (sw_if_index == ~0)
12486 errmsg ("missing interface name or sw_if_index\n");
12490 /* Construct the API message */
12491 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
12492 mp->sw_if_index = ntohl (sw_if_index);
12493 mp->enable_disable = enable_disable;
12497 /* Wait for the reply */
12502 api_cop_whitelist_enable_disable (vat_main_t * vam)
12504 unformat_input_t *line_input = vam->input;
12505 vl_api_cop_whitelist_enable_disable_t *mp;
12507 u32 sw_if_index = ~0;
12508 u8 ip4 = 0, ip6 = 0, default_cop = 0;
12511 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12513 if (unformat (line_input, "ip4"))
12515 else if (unformat (line_input, "ip6"))
12517 else if (unformat (line_input, "default"))
12519 else if (unformat (line_input, "%U", unformat_sw_if_index,
12520 vam, &sw_if_index))
12522 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12524 else if (unformat (line_input, "fib-id %d", &fib_id))
12530 if (sw_if_index == ~0)
12532 errmsg ("missing interface name or sw_if_index\n");
12536 /* Construct the API message */
12537 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
12538 mp->sw_if_index = ntohl (sw_if_index);
12539 mp->fib_id = ntohl (fib_id);
12542 mp->default_cop = default_cop;
12546 /* Wait for the reply */
12551 api_get_node_graph (vat_main_t * vam)
12553 vl_api_get_node_graph_t *mp;
12556 M (GET_NODE_GRAPH, get_node_graph);
12560 /* Wait for the reply */
12565 /** Used for parsing LISP eids */
12566 typedef CLIB_PACKED(struct{
12567 u8 addr[16]; /**< eid address */
12568 u32 len; /**< prefix length if IP */
12569 u8 type; /**< type of eid */
12574 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
12576 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
12578 memset (a, 0, sizeof (a[0]));
12580 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
12582 a->type = 0; /* ipv4 type */
12584 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
12586 a->type = 1; /* ipv6 type */
12588 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
12590 a->type = 2; /* mac type */
12597 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
12606 lisp_eid_size_vat (u8 type)
12621 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
12623 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
12627 /** Used for transferring locators via VPP API */
12628 typedef CLIB_PACKED(struct
12630 u32 sw_if_index; /**< locator sw_if_index */
12631 u8 priority; /**< locator priority */
12632 u8 weight; /**< locator weight */
12637 api_lisp_add_del_locator_set (vat_main_t * vam)
12639 unformat_input_t *input = vam->input;
12640 vl_api_lisp_add_del_locator_set_t *mp;
12643 u8 *locator_set_name = NULL;
12644 u8 locator_set_name_set = 0;
12645 ls_locator_t locator, *locators = 0;
12646 u32 sw_if_index, priority, weight;
12649 /* Parse args required to build the message */
12650 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12652 if (unformat (input, "del"))
12656 else if (unformat (input, "locator-set %s", &locator_set_name))
12658 locator_set_name_set = 1;
12660 else if (unformat (input, "sw_if_index %u p %u w %u",
12661 &sw_if_index, &priority, &weight))
12663 locator.sw_if_index = htonl (sw_if_index);
12664 locator.priority = priority;
12665 locator.weight = weight;
12666 vec_add1 (locators, locator);
12668 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
12669 vam, &sw_if_index, &priority, &weight))
12671 locator.sw_if_index = htonl (sw_if_index);
12672 locator.priority = priority;
12673 locator.weight = weight;
12674 vec_add1 (locators, locator);
12680 if (locator_set_name_set == 0)
12682 errmsg ("missing locator-set name");
12683 vec_free (locators);
12687 if (vec_len (locator_set_name) > 64)
12689 errmsg ("locator-set name too long\n");
12690 vec_free (locator_set_name);
12691 vec_free (locators);
12694 vec_add1 (locator_set_name, 0);
12696 data_len = sizeof (ls_locator_t) * vec_len (locators);
12698 /* Construct the API message */
12699 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
12701 mp->is_add = is_add;
12702 clib_memcpy (mp->locator_set_name, locator_set_name,
12703 vec_len (locator_set_name));
12704 vec_free (locator_set_name);
12706 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
12708 clib_memcpy (mp->locators, locators, data_len);
12709 vec_free (locators);
12714 /* Wait for a reply... */
12722 api_lisp_add_del_locator (vat_main_t * vam)
12724 unformat_input_t *input = vam->input;
12725 vl_api_lisp_add_del_locator_t *mp;
12727 u32 tmp_if_index = ~0;
12728 u32 sw_if_index = ~0;
12729 u8 sw_if_index_set = 0;
12730 u8 sw_if_index_if_name_set = 0;
12732 u8 priority_set = 0;
12736 u8 *locator_set_name = NULL;
12737 u8 locator_set_name_set = 0;
12739 /* Parse args required to build the message */
12740 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12742 if (unformat (input, "del"))
12746 else if (unformat (input, "locator-set %s", &locator_set_name))
12748 locator_set_name_set = 1;
12750 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
12753 sw_if_index_if_name_set = 1;
12754 sw_if_index = tmp_if_index;
12756 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
12758 sw_if_index_set = 1;
12759 sw_if_index = tmp_if_index;
12761 else if (unformat (input, "p %d", &priority))
12765 else if (unformat (input, "w %d", &weight))
12773 if (locator_set_name_set == 0)
12775 errmsg ("missing locator-set name");
12779 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12781 errmsg ("missing sw_if_index");
12782 vec_free (locator_set_name);
12786 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
12788 errmsg ("cannot use both params interface name and sw_if_index");
12789 vec_free (locator_set_name);
12793 if (priority_set == 0)
12795 errmsg ("missing locator-set priority\n");
12796 vec_free (locator_set_name);
12800 if (weight_set == 0)
12802 errmsg ("missing locator-set weight\n");
12803 vec_free (locator_set_name);
12807 if (vec_len (locator_set_name) > 64)
12809 errmsg ("locator-set name too long\n");
12810 vec_free (locator_set_name);
12813 vec_add1 (locator_set_name, 0);
12815 /* Construct the API message */
12816 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
12818 mp->is_add = is_add;
12819 mp->sw_if_index = ntohl (sw_if_index);
12820 mp->priority = priority;
12821 mp->weight = weight;
12822 clib_memcpy (mp->locator_set_name, locator_set_name,
12823 vec_len (locator_set_name));
12824 vec_free (locator_set_name);
12829 /* Wait for a reply... */
12837 api_lisp_add_del_local_eid (vat_main_t * vam)
12839 unformat_input_t *input = vam->input;
12840 vl_api_lisp_add_del_local_eid_t *mp;
12844 lisp_eid_vat_t _eid, *eid = &_eid;
12845 u8 *locator_set_name = 0;
12846 u8 locator_set_name_set = 0;
12849 /* Parse args required to build the message */
12850 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12852 if (unformat (input, "del"))
12856 else if (unformat (input, "vni %d", &vni))
12860 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
12864 else if (unformat (input, "locator-set %s", &locator_set_name))
12866 locator_set_name_set = 1;
12872 if (locator_set_name_set == 0)
12874 errmsg ("missing locator-set name\n");
12880 errmsg ("EID address not set!");
12881 vec_free (locator_set_name);
12885 if (vec_len (locator_set_name) > 64)
12887 errmsg ("locator-set name too long\n");
12888 vec_free (locator_set_name);
12891 vec_add1 (locator_set_name, 0);
12893 /* Construct the API message */
12894 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
12896 mp->is_add = is_add;
12897 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
12898 mp->eid_type = eid->type;
12899 mp->prefix_len = eid->len;
12900 mp->vni = clib_host_to_net_u32 (vni);
12901 clib_memcpy (mp->locator_set_name, locator_set_name,
12902 vec_len (locator_set_name));
12904 vec_free (locator_set_name);
12909 /* Wait for a reply... */
12917 /** Used for transferring locators via VPP API */
12918 typedef CLIB_PACKED(struct
12920 u8 is_ip4; /**< is locator an IPv4 address? */
12921 u8 priority; /**< locator priority */
12922 u8 weight; /**< locator weight */
12923 u8 addr[16]; /**< IPv4/IPv6 address */
12928 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
12930 unformat_input_t *input = vam->input;
12931 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
12934 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
12935 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
12936 u8 rmt_eid_set = 0, lcl_eid_set = 0;
12937 u32 action = ~0, p, w;
12938 ip4_address_t rmt_rloc4, lcl_rloc4;
12939 ip6_address_t rmt_rloc6, lcl_rloc6;
12940 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
12942 memset (&rloc, 0, sizeof (rloc));
12944 /* Parse args required to build the message */
12945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12947 if (unformat (input, "del"))
12951 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
12955 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
12959 else if (unformat (input, "p %d w %d", &p, &w))
12963 errmsg ("No RLOC configured for setting priority/weight!");
12966 curr_rloc->priority = p;
12967 curr_rloc->weight = w;
12969 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
12970 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
12974 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
12975 rloc.priority = rloc.weight = 0;
12976 vec_add1 (lcl_locs, rloc);
12978 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
12979 vec_add1 (rmt_locs, rloc);
12980 /* priority and weight saved in rmt loc */
12981 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12983 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
12984 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
12987 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
12988 rloc.priority = rloc.weight = 0;
12989 vec_add1 (lcl_locs, rloc);
12991 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
12992 vec_add1 (rmt_locs, rloc);
12993 /* priority and weight saved in rmt loc */
12994 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
12996 else if (unformat (input, "action %d", &action))
13002 clib_warning ("parse error '%U'", format_unformat_error, input);
13009 errmsg ("remote eid addresses not set\n");
13013 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13015 errmsg ("eid types don't match\n");
13019 if (0 == rmt_locs && (u32) ~ 0 == action)
13021 errmsg ("action not set for negative mapping\n");
13025 /* Construct the API message */
13026 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
13028 mp->is_add = is_add;
13029 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13030 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13031 mp->eid_type = rmt_eid->type;
13032 mp->rmt_len = rmt_eid->len;
13033 mp->lcl_len = lcl_eid->len;
13034 mp->action = action;
13036 if (0 != rmt_locs && 0 != lcl_locs)
13038 mp->loc_num = vec_len (rmt_locs);
13039 clib_memcpy (mp->lcl_locs, lcl_locs,
13040 (sizeof (rloc_t) * vec_len (lcl_locs)));
13041 clib_memcpy (mp->rmt_locs, rmt_locs,
13042 (sizeof (rloc_t) * vec_len (rmt_locs)));
13044 vec_free (lcl_locs);
13045 vec_free (rmt_locs);
13050 /* Wait for a reply... */
13058 api_lisp_add_del_map_resolver (vat_main_t * vam)
13060 unformat_input_t *input = vam->input;
13061 vl_api_lisp_add_del_map_resolver_t *mp;
13066 ip4_address_t ipv4;
13067 ip6_address_t ipv6;
13069 /* Parse args required to build the message */
13070 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13072 if (unformat (input, "del"))
13076 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13080 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13088 if (ipv4_set && ipv6_set)
13090 errmsg ("both eid v4 and v6 addresses set\n");
13094 if (!ipv4_set && !ipv6_set)
13096 errmsg ("eid addresses not set\n");
13100 /* Construct the API message */
13101 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13103 mp->is_add = is_add;
13107 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13112 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13118 /* Wait for a reply... */
13126 api_lisp_gpe_enable_disable (vat_main_t * vam)
13128 unformat_input_t *input = vam->input;
13129 vl_api_lisp_gpe_enable_disable_t *mp;
13134 /* Parse args required to build the message */
13135 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13137 if (unformat (input, "enable"))
13142 else if (unformat (input, "disable"))
13153 errmsg ("Value not set\n");
13157 /* Construct the API message */
13158 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13165 /* Wait for a reply... */
13173 api_lisp_enable_disable (vat_main_t * vam)
13175 unformat_input_t *input = vam->input;
13176 vl_api_lisp_enable_disable_t *mp;
13181 /* Parse args required to build the message */
13182 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13184 if (unformat (input, "enable"))
13189 else if (unformat (input, "disable"))
13199 errmsg ("Value not set\n");
13203 /* Construct the API message */
13204 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
13211 /* Wait for a reply... */
13219 api_show_lisp_map_request_mode (vat_main_t * vam)
13222 vl_api_show_lisp_map_request_mode_t *mp;
13224 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
13229 /* wait for reply */
13236 api_lisp_map_request_mode (vat_main_t * vam)
13239 unformat_input_t *input = vam->input;
13240 vl_api_lisp_map_request_mode_t *mp;
13243 /* Parse args required to build the message */
13244 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13246 if (unformat (input, "dst-only"))
13248 else if (unformat (input, "src-dst"))
13252 errmsg ("parse error '%U'", format_unformat_error, input);
13257 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
13264 /* wait for reply */
13272 * Enable/disable LISP proxy ITR.
13274 * @param vam vpp API test context
13275 * @return return code
13278 api_lisp_pitr_set_locator_set (vat_main_t * vam)
13281 u8 ls_name_set = 0;
13282 unformat_input_t *input = vam->input;
13283 vl_api_lisp_pitr_set_locator_set_t *mp;
13287 /* Parse args required to build the message */
13288 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13290 if (unformat (input, "del"))
13292 else if (unformat (input, "locator-set %s", &ls_name))
13296 errmsg ("parse error '%U'", format_unformat_error, input);
13303 errmsg ("locator-set name not set!");
13307 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
13309 mp->is_add = is_add;
13310 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
13311 vec_free (ls_name);
13316 /* wait for reply */
13324 api_show_lisp_pitr (vat_main_t * vam)
13326 vl_api_show_lisp_pitr_t *mp;
13329 if (!vam->json_output)
13331 fformat (vam->ofp, "%=20s\n", "lisp status:");
13334 M (SHOW_LISP_PITR, show_lisp_pitr);
13338 /* Wait for a reply... */
13346 * Add/delete mapping between vni and vrf
13349 api_lisp_eid_table_add_del_map (vat_main_t * vam)
13352 unformat_input_t *input = vam->input;
13353 vl_api_lisp_eid_table_add_del_map_t *mp;
13354 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
13355 u32 vni, vrf, bd_index;
13357 /* Parse args required to build the message */
13358 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13360 if (unformat (input, "del"))
13362 else if (unformat (input, "vrf %d", &vrf))
13364 else if (unformat (input, "bd_index %d", &bd_index))
13366 else if (unformat (input, "vni %d", &vni))
13372 if (!vni_set || (!vrf_set && !bd_index_set))
13374 errmsg ("missing arguments!");
13378 if (vrf_set && bd_index_set)
13380 errmsg ("error: both vrf and bd entered!");
13384 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
13386 mp->is_add = is_add;
13387 mp->vni = htonl (vni);
13388 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
13389 mp->is_l2 = bd_index_set;
13394 /* wait for reply */
13402 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
13404 u32 *action = va_arg (*args, u32 *);
13407 if (unformat (input, "%s", &s))
13409 if (!strcmp ((char *) s, "no-action"))
13411 else if (!strcmp ((char *) s, "natively-forward"))
13413 else if (!strcmp ((char *) s, "send-map-request"))
13415 else if (!strcmp ((char *) s, "drop"))
13419 clib_warning ("invalid action: '%s'", s);
13431 * Add/del remote mapping to/from LISP control plane
13433 * @param vam vpp API test context
13434 * @return return code
13437 api_lisp_add_del_remote_mapping (vat_main_t * vam)
13439 unformat_input_t *input = vam->input;
13440 vl_api_lisp_add_del_remote_mapping_t *mp;
13443 lisp_eid_vat_t _eid, *eid = &_eid;
13444 lisp_eid_vat_t _seid, *seid = &_seid;
13445 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
13446 u32 action = ~0, p, w, data_len;
13447 ip4_address_t rloc4;
13448 ip6_address_t rloc6;
13449 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
13451 memset (&rloc, 0, sizeof (rloc));
13453 /* Parse args required to build the message */
13454 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13456 if (unformat (input, "del-all"))
13460 else if (unformat (input, "del"))
13464 else if (unformat (input, "add"))
13468 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13472 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
13476 else if (unformat (input, "vni %d", &vni))
13480 else if (unformat (input, "p %d w %d", &p, &w))
13484 errmsg ("No RLOC configured for setting priority/weight!");
13487 curr_rloc->priority = p;
13488 curr_rloc->weight = w;
13490 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
13493 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
13494 vec_add1 (rlocs, rloc);
13495 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13497 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
13500 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
13501 vec_add1 (rlocs, rloc);
13502 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13504 else if (unformat (input, "action %U",
13505 unformat_negative_mapping_action, &action))
13511 clib_warning ("parse error '%U'", format_unformat_error, input);
13518 errmsg ("missing params!");
13522 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
13524 errmsg ("no action set for negative map-reply!");
13528 data_len = vec_len (rlocs) * sizeof (rloc_t);
13530 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
13531 mp->is_add = is_add;
13532 mp->vni = htonl (vni);
13533 mp->action = (u8) action;
13534 mp->is_src_dst = seid_set;
13535 mp->eid_len = eid->len;
13536 mp->seid_len = seid->len;
13537 mp->del_all = del_all;
13538 mp->eid_type = eid->type;
13539 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13540 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
13542 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
13543 clib_memcpy (mp->rlocs, rlocs, data_len);
13549 /* Wait for a reply... */
13557 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
13558 * forwarding entries in data-plane accordingly.
13560 * @param vam vpp API test context
13561 * @return return code
13564 api_lisp_add_del_adjacency (vat_main_t * vam)
13566 unformat_input_t *input = vam->input;
13567 vl_api_lisp_add_del_adjacency_t *mp;
13570 ip4_address_t leid4, reid4;
13571 ip6_address_t leid6, reid6;
13572 u8 reid_mac[6] = { 0 };
13573 u8 leid_mac[6] = { 0 };
13574 u8 reid_type, leid_type;
13575 u32 leid_len = 0, reid_len = 0, len;
13578 leid_type = reid_type = (u8) ~ 0;
13580 /* Parse args required to build the message */
13581 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13583 if (unformat (input, "del"))
13587 else if (unformat (input, "add"))
13591 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
13594 reid_type = 0; /* ipv4 */
13597 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
13600 reid_type = 1; /* ipv6 */
13603 else if (unformat (input, "reid %U", unformat_ethernet_address,
13606 reid_type = 2; /* mac */
13608 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
13611 leid_type = 0; /* ipv4 */
13614 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
13617 leid_type = 1; /* ipv6 */
13620 else if (unformat (input, "leid %U", unformat_ethernet_address,
13623 leid_type = 2; /* mac */
13625 else if (unformat (input, "vni %d", &vni))
13631 errmsg ("parse error '%U'", format_unformat_error, input);
13636 if ((u8) ~ 0 == reid_type)
13638 errmsg ("missing params!");
13642 if (leid_type != reid_type)
13644 errmsg ("remote and local EIDs are of different types!");
13648 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
13649 mp->is_add = is_add;
13650 mp->vni = htonl (vni);
13651 mp->leid_len = leid_len;
13652 mp->reid_len = reid_len;
13653 mp->eid_type = reid_type;
13655 switch (mp->eid_type)
13658 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
13659 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
13662 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
13663 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
13666 clib_memcpy (mp->leid, leid_mac, 6);
13667 clib_memcpy (mp->reid, reid_mac, 6);
13670 errmsg ("unknown EID type %d!", mp->eid_type);
13677 /* Wait for a reply... */
13685 api_lisp_gpe_add_del_iface (vat_main_t * vam)
13687 unformat_input_t *input = vam->input;
13688 vl_api_lisp_gpe_add_del_iface_t *mp;
13690 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
13691 u32 dp_table = 0, vni = 0;
13693 /* Parse args required to build the message */
13694 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13696 if (unformat (input, "up"))
13701 else if (unformat (input, "down"))
13706 else if (unformat (input, "table_id %d", &dp_table))
13710 else if (unformat (input, "bd_id %d", &dp_table))
13715 else if (unformat (input, "vni %d", &vni))
13723 if (action_set == 0)
13725 errmsg ("Action not set\n");
13728 if (dp_table_set == 0 || vni_set == 0)
13730 errmsg ("vni and dp_table must be set\n");
13734 /* Construct the API message */
13735 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
13737 mp->is_add = is_add;
13738 mp->dp_table = dp_table;
13745 /* Wait for a reply... */
13753 * Add/del map request itr rlocs from LISP control plane and updates
13755 * @param vam vpp API test context
13756 * @return return code
13759 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
13761 unformat_input_t *input = vam->input;
13762 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
13764 u8 *locator_set_name = 0;
13765 u8 locator_set_name_set = 0;
13768 /* Parse args required to build the message */
13769 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13771 if (unformat (input, "del"))
13775 else if (unformat (input, "%_%v%_", &locator_set_name))
13777 locator_set_name_set = 1;
13781 clib_warning ("parse error '%U'", format_unformat_error, input);
13786 if (is_add && !locator_set_name_set)
13788 errmsg ("itr-rloc is not set!");
13792 if (is_add && vec_len (locator_set_name) > 64)
13794 errmsg ("itr-rloc locator-set name too long\n");
13795 vec_free (locator_set_name);
13799 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
13800 mp->is_add = is_add;
13803 clib_memcpy (mp->locator_set_name, locator_set_name,
13804 vec_len (locator_set_name));
13808 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
13810 vec_free (locator_set_name);
13815 /* Wait for a reply... */
13823 api_lisp_locator_dump (vat_main_t * vam)
13825 unformat_input_t *input = vam->input;
13826 vl_api_lisp_locator_dump_t *mp;
13828 u8 is_index_set = 0, is_name_set = 0;
13832 /* Parse args required to build the message */
13833 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13835 if (unformat (input, "ls_name %_%v%_", &ls_name))
13839 else if (unformat (input, "ls_index %d", &ls_index))
13845 errmsg ("parse error '%U'", format_unformat_error, input);
13850 if (!is_index_set && !is_name_set)
13852 errmsg ("error: expected one of index or name!\n");
13856 if (is_index_set && is_name_set)
13858 errmsg ("error: only one param expected!\n");
13862 if (vec_len (ls_name) > 62)
13864 errmsg ("error: locator set name too long!");
13868 if (!vam->json_output)
13870 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
13874 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
13875 mp->is_index_set = is_index_set;
13878 mp->ls_index = clib_host_to_net_u32 (ls_index);
13881 vec_add1 (ls_name, 0);
13882 strncpy ((char *) mp->ls_name, (char *) ls_name,
13883 sizeof (mp->ls_name) - 1);
13889 /* Use a control ping for synchronization */
13891 vl_api_control_ping_t *mp;
13892 M (CONTROL_PING, control_ping);
13895 /* Wait for a reply... */
13903 api_lisp_locator_set_dump (vat_main_t * vam)
13905 vl_api_lisp_locator_set_dump_t *mp;
13906 unformat_input_t *input = vam->input;
13910 /* Parse args required to build the message */
13911 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13913 if (unformat (input, "local"))
13917 else if (unformat (input, "remote"))
13923 errmsg ("parse error '%U'", format_unformat_error, input);
13928 if (!vam->json_output)
13930 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
13933 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
13935 mp->filter = filter;
13940 /* Use a control ping for synchronization */
13942 vl_api_control_ping_t *mp;
13943 M (CONTROL_PING, control_ping);
13946 /* Wait for a reply... */
13954 api_lisp_eid_table_map_dump (vat_main_t * vam)
13958 unformat_input_t *input = vam->input;
13959 vl_api_lisp_eid_table_map_dump_t *mp;
13962 /* Parse args required to build the message */
13963 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13965 if (unformat (input, "l2"))
13970 else if (unformat (input, "l3"))
13977 errmsg ("parse error '%U'", format_unformat_error, input);
13984 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
13988 if (!vam->json_output)
13990 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
13993 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
13999 /* Use a control ping for synchronization */
14001 vl_api_control_ping_t *mp;
14002 M (CONTROL_PING, control_ping);
14005 /* Wait for a reply... */
14013 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14015 vl_api_lisp_eid_table_vni_dump_t *mp;
14018 if (!vam->json_output)
14020 fformat (vam->ofp, "VNI\n");
14023 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
14028 /* Use a control ping for synchronization */
14030 vl_api_control_ping_t *mp;
14031 M (CONTROL_PING, control_ping);
14034 /* Wait for a reply... */
14042 api_lisp_eid_table_dump (vat_main_t * vam)
14044 unformat_input_t *i = vam->input;
14045 vl_api_lisp_eid_table_dump_t *mp;
14047 struct in_addr ip4;
14048 struct in6_addr ip6;
14050 u8 eid_type = ~0, eid_set = 0;
14051 u32 prefix_length = ~0, t, vni = 0;
14054 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14056 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14062 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14068 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14073 else if (unformat (i, "vni %d", &t))
14077 else if (unformat (i, "local"))
14081 else if (unformat (i, "remote"))
14087 errmsg ("parse error '%U'", format_unformat_error, i);
14092 if (!vam->json_output)
14094 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-s\n", "EID", "type",
14095 "ls_index", "ttl", "authoritative");
14098 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14100 mp->filter = filter;
14104 mp->vni = htonl (vni);
14105 mp->eid_type = eid_type;
14109 mp->prefix_length = prefix_length;
14110 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14113 mp->prefix_length = prefix_length;
14114 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14117 clib_memcpy (mp->eid, mac, sizeof (mac));
14120 errmsg ("unknown EID type %d!", eid_type);
14128 /* Use a control ping for synchronization */
14130 vl_api_control_ping_t *mp;
14131 M (CONTROL_PING, control_ping);
14135 /* Wait for a reply... */
14143 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
14145 vl_api_lisp_gpe_tunnel_dump_t *mp;
14148 if (!vam->json_output)
14150 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
14151 "%=16s%=16s%=16s%=16s%=16s\n",
14152 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
14153 "Decap next", "Lisp version", "Flags", "Next protocol",
14154 "ver_res", "res", "iid");
14157 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
14161 /* Use a control ping for synchronization */
14163 vl_api_control_ping_t *mp;
14164 M (CONTROL_PING, control_ping);
14167 /* Wait for a reply... */
14175 api_lisp_adjacencies_get (vat_main_t * vam)
14177 unformat_input_t *i = vam->input;
14178 vl_api_lisp_adjacencies_get_t *mp;
14183 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14185 if (unformat (i, "vni %d", &vni))
14191 errmsg ("parse error '%U'\n", format_unformat_error, i);
14198 errmsg ("vni not set!\n");
14202 if (!vam->json_output)
14204 fformat (vam->ofp, "%s %40s\n", "leid", "reid");
14207 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
14208 mp->vni = clib_host_to_net_u32 (vni);
14213 /* Wait for a reply... */
14221 api_lisp_map_resolver_dump (vat_main_t * vam)
14223 vl_api_lisp_map_resolver_dump_t *mp;
14226 if (!vam->json_output)
14228 fformat (vam->ofp, "%=20s\n", "Map resolver");
14231 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
14235 /* Use a control ping for synchronization */
14237 vl_api_control_ping_t *mp;
14238 M (CONTROL_PING, control_ping);
14241 /* Wait for a reply... */
14249 api_show_lisp_status (vat_main_t * vam)
14251 vl_api_show_lisp_status_t *mp;
14254 if (!vam->json_output)
14256 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
14259 M (SHOW_LISP_STATUS, show_lisp_status);
14262 /* Wait for a reply... */
14270 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
14272 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
14275 if (!vam->json_output)
14277 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
14280 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
14283 /* Wait for a reply... */
14291 api_af_packet_create (vat_main_t * vam)
14293 unformat_input_t *i = vam->input;
14294 vl_api_af_packet_create_t *mp;
14296 u8 *host_if_name = 0;
14298 u8 random_hw_addr = 1;
14300 memset (hw_addr, 0, sizeof (hw_addr));
14302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14304 if (unformat (i, "name %s", &host_if_name))
14305 vec_add1 (host_if_name, 0);
14306 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14307 random_hw_addr = 0;
14312 if (!vec_len (host_if_name))
14314 errmsg ("host-interface name must be specified");
14318 if (vec_len (host_if_name) > 64)
14320 errmsg ("host-interface name too long");
14324 M (AF_PACKET_CREATE, af_packet_create);
14326 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14327 clib_memcpy (mp->hw_addr, hw_addr, 6);
14328 mp->use_random_hw_addr = random_hw_addr;
14329 vec_free (host_if_name);
14332 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
14338 api_af_packet_delete (vat_main_t * vam)
14340 unformat_input_t *i = vam->input;
14341 vl_api_af_packet_delete_t *mp;
14343 u8 *host_if_name = 0;
14345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14347 if (unformat (i, "name %s", &host_if_name))
14348 vec_add1 (host_if_name, 0);
14353 if (!vec_len (host_if_name))
14355 errmsg ("host-interface name must be specified");
14359 if (vec_len (host_if_name) > 64)
14361 errmsg ("host-interface name too long");
14365 M (AF_PACKET_DELETE, af_packet_delete);
14367 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14368 vec_free (host_if_name);
14377 api_policer_add_del (vat_main_t * vam)
14379 unformat_input_t *i = vam->input;
14380 vl_api_policer_add_del_t *mp;
14391 u8 color_aware = 0;
14392 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
14394 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
14395 conform_action.dscp = 0;
14396 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
14397 exceed_action.dscp = 0;
14398 violate_action.action_type = SSE2_QOS_ACTION_DROP;
14399 violate_action.dscp = 0;
14401 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14403 if (unformat (i, "del"))
14405 else if (unformat (i, "name %s", &name))
14406 vec_add1 (name, 0);
14407 else if (unformat (i, "cir %u", &cir))
14409 else if (unformat (i, "eir %u", &eir))
14411 else if (unformat (i, "cb %u", &cb))
14413 else if (unformat (i, "eb %u", &eb))
14415 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
14418 else if (unformat (i, "round_type %U", unformat_policer_round_type,
14421 else if (unformat (i, "type %U", unformat_policer_type, &type))
14423 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
14426 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
14429 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
14432 else if (unformat (i, "color-aware"))
14438 if (!vec_len (name))
14440 errmsg ("policer name must be specified");
14444 if (vec_len (name) > 64)
14446 errmsg ("policer name too long");
14450 M (POLICER_ADD_DEL, policer_add_del);
14452 clib_memcpy (mp->name, name, vec_len (name));
14454 mp->is_add = is_add;
14459 mp->rate_type = rate_type;
14460 mp->round_type = round_type;
14462 mp->conform_action_type = conform_action.action_type;
14463 mp->conform_dscp = conform_action.dscp;
14464 mp->exceed_action_type = exceed_action.action_type;
14465 mp->exceed_dscp = exceed_action.dscp;
14466 mp->violate_action_type = violate_action.action_type;
14467 mp->violate_dscp = violate_action.dscp;
14468 mp->color_aware = color_aware;
14477 api_policer_dump (vat_main_t * vam)
14479 unformat_input_t *i = vam->input;
14480 vl_api_policer_dump_t *mp;
14482 u8 *match_name = 0;
14483 u8 match_name_valid = 0;
14485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14487 if (unformat (i, "name %s", &match_name))
14489 vec_add1 (match_name, 0);
14490 match_name_valid = 1;
14496 M (POLICER_DUMP, policer_dump);
14497 mp->match_name_valid = match_name_valid;
14498 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
14499 vec_free (match_name);
14503 /* Use a control ping for synchronization */
14505 vl_api_control_ping_t *mp;
14506 M (CONTROL_PING, control_ping);
14509 /* Wait for a reply... */
14517 api_policer_classify_set_interface (vat_main_t * vam)
14519 unformat_input_t *i = vam->input;
14520 vl_api_policer_classify_set_interface_t *mp;
14523 int sw_if_index_set;
14524 u32 ip4_table_index = ~0;
14525 u32 ip6_table_index = ~0;
14526 u32 l2_table_index = ~0;
14529 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14531 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
14532 sw_if_index_set = 1;
14533 else if (unformat (i, "sw_if_index %d", &sw_if_index))
14534 sw_if_index_set = 1;
14535 else if (unformat (i, "del"))
14537 else if (unformat (i, "ip4-table %d", &ip4_table_index))
14539 else if (unformat (i, "ip6-table %d", &ip6_table_index))
14541 else if (unformat (i, "l2-table %d", &l2_table_index))
14545 clib_warning ("parse error '%U'", format_unformat_error, i);
14550 if (sw_if_index_set == 0)
14552 errmsg ("missing interface name or sw_if_index\n");
14556 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
14558 mp->sw_if_index = ntohl (sw_if_index);
14559 mp->ip4_table_index = ntohl (ip4_table_index);
14560 mp->ip6_table_index = ntohl (ip6_table_index);
14561 mp->l2_table_index = ntohl (l2_table_index);
14562 mp->is_add = is_add;
14571 api_policer_classify_dump (vat_main_t * vam)
14573 unformat_input_t *i = vam->input;
14574 vl_api_policer_classify_dump_t *mp;
14576 u8 type = POLICER_CLASSIFY_N_TABLES;
14578 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
14582 errmsg ("classify table type must be specified\n");
14586 if (!vam->json_output)
14588 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
14591 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
14596 /* Use a control ping for synchronization */
14598 vl_api_control_ping_t *mp;
14599 M (CONTROL_PING, control_ping);
14602 /* Wait for a reply... */
14610 api_netmap_create (vat_main_t * vam)
14612 unformat_input_t *i = vam->input;
14613 vl_api_netmap_create_t *mp;
14617 u8 random_hw_addr = 1;
14621 memset (hw_addr, 0, sizeof (hw_addr));
14623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14625 if (unformat (i, "name %s", &if_name))
14626 vec_add1 (if_name, 0);
14627 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14628 random_hw_addr = 0;
14629 else if (unformat (i, "pipe"))
14631 else if (unformat (i, "master"))
14633 else if (unformat (i, "slave"))
14639 if (!vec_len (if_name))
14641 errmsg ("interface name must be specified");
14645 if (vec_len (if_name) > 64)
14647 errmsg ("interface name too long");
14651 M (NETMAP_CREATE, netmap_create);
14653 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14654 clib_memcpy (mp->hw_addr, hw_addr, 6);
14655 mp->use_random_hw_addr = random_hw_addr;
14656 mp->is_pipe = is_pipe;
14657 mp->is_master = is_master;
14658 vec_free (if_name);
14667 api_netmap_delete (vat_main_t * vam)
14669 unformat_input_t *i = vam->input;
14670 vl_api_netmap_delete_t *mp;
14674 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14676 if (unformat (i, "name %s", &if_name))
14677 vec_add1 (if_name, 0);
14682 if (!vec_len (if_name))
14684 errmsg ("interface name must be specified");
14688 if (vec_len (if_name) > 64)
14690 errmsg ("interface name too long");
14694 M (NETMAP_DELETE, netmap_delete);
14696 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
14697 vec_free (if_name);
14705 static void vl_api_mpls_eth_tunnel_details_t_handler
14706 (vl_api_mpls_eth_tunnel_details_t * mp)
14708 vat_main_t *vam = &vat_main;
14710 i32 len = ntohl (mp->nlabels);
14712 fformat (vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
14713 ntohl (mp->tunnel_index),
14714 format_ethernet_address, &mp->tunnel_dst_mac,
14715 format_ip4_address, &mp->intfc_address, ntohl (mp->mask_width));
14716 for (i = 0; i < len; i++)
14718 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14720 fformat (vam->ofp, "\n");
14721 fformat (vam->ofp, " tx on %d, rx fib index %d\n",
14722 ntohl (mp->tx_sw_if_index), ntohl (mp->inner_fib_index));
14725 static void vl_api_mpls_eth_tunnel_details_t_handler_json
14726 (vl_api_mpls_eth_tunnel_details_t * mp)
14728 vat_main_t *vam = &vat_main;
14729 vat_json_node_t *node = NULL;
14730 struct in_addr ip4;
14732 i32 len = ntohl (mp->nlabels);
14734 if (VAT_JSON_ARRAY != vam->json_tree.type)
14736 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14737 vat_json_init_array (&vam->json_tree);
14739 node = vat_json_array_add (&vam->json_tree);
14741 vat_json_init_object (node);
14742 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
14743 clib_memcpy (&ip4, &(mp->intfc_address), sizeof (ip4));
14744 vat_json_object_add_ip4 (node, "intfc_address", ip4);
14745 vat_json_object_add_uint (node, "inner_fib_index",
14746 ntohl (mp->inner_fib_index));
14747 vat_json_object_add_uint (node, "mask_width", ntohl (mp->mask_width));
14748 vat_json_object_add_uint (node, "encap_index", ntohl (mp->encap_index));
14749 vat_json_object_add_uint (node, "hw_if_index", ntohl (mp->hw_if_index));
14750 vat_json_object_add_uint (node, "l2_only", ntohl (mp->l2_only));
14751 vat_json_object_add_string_copy (node, "tunnel_dst_mac",
14752 format (0, "%U", format_ethernet_address,
14753 &mp->tunnel_dst_mac));
14754 vat_json_object_add_uint (node, "tx_sw_if_index",
14755 ntohl (mp->tx_sw_if_index));
14756 vat_json_object_add_uint (node, "label_count", len);
14757 for (i = 0; i < len; i++)
14759 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14764 api_mpls_eth_tunnel_dump (vat_main_t * vam)
14766 vl_api_mpls_eth_tunnel_dump_t *mp;
14770 /* Parse args required to build the message */
14771 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
14773 if (!unformat (vam->input, "tunnel_index %d", &index))
14780 fformat (vam->ofp, " tunnel_index %d\n", index);
14782 M (MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
14783 mp->tunnel_index = htonl (index);
14786 /* Use a control ping for synchronization */
14788 vl_api_control_ping_t *mp;
14789 M (CONTROL_PING, control_ping);
14795 static void vl_api_mpls_fib_encap_details_t_handler
14796 (vl_api_mpls_fib_encap_details_t * mp)
14798 vat_main_t *vam = &vat_main;
14800 i32 len = ntohl (mp->nlabels);
14802 fformat (vam->ofp, "table %d, dest %U, label ",
14803 ntohl (mp->fib_index), format_ip4_address, &mp->dest, len);
14804 for (i = 0; i < len; i++)
14806 fformat (vam->ofp, "%u ", ntohl (mp->labels[i]));
14808 fformat (vam->ofp, "\n");
14811 static void vl_api_mpls_fib_encap_details_t_handler_json
14812 (vl_api_mpls_fib_encap_details_t * mp)
14814 vat_main_t *vam = &vat_main;
14815 vat_json_node_t *node = NULL;
14817 i32 len = ntohl (mp->nlabels);
14818 struct in_addr ip4;
14820 if (VAT_JSON_ARRAY != vam->json_tree.type)
14822 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14823 vat_json_init_array (&vam->json_tree);
14825 node = vat_json_array_add (&vam->json_tree);
14827 vat_json_init_object (node);
14828 vat_json_object_add_uint (node, "table", ntohl (mp->fib_index));
14829 vat_json_object_add_uint (node, "entry_index", ntohl (mp->entry_index));
14830 clib_memcpy (&ip4, &(mp->dest), sizeof (ip4));
14831 vat_json_object_add_ip4 (node, "dest", ip4);
14832 vat_json_object_add_uint (node, "s_bit", ntohl (mp->s_bit));
14833 vat_json_object_add_uint (node, "label_count", len);
14834 for (i = 0; i < len; i++)
14836 vat_json_object_add_uint (node, "label", ntohl (mp->labels[i]));
14841 api_mpls_fib_encap_dump (vat_main_t * vam)
14843 vl_api_mpls_fib_encap_dump_t *mp;
14846 M (MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
14849 /* Use a control ping for synchronization */
14851 vl_api_control_ping_t *mp;
14852 M (CONTROL_PING, control_ping);
14858 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
14859 #define vl_api_mpls_fib_details_t_print vl_noop_handler
14862 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
14864 vat_main_t *vam = &vat_main;
14865 int count = ntohl (mp->count);
14866 vl_api_fib_path_t *fp;
14870 "table-id %d, label %u, ess_bit %u\n",
14871 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
14873 for (i = 0; i < count; i++)
14876 " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, "
14877 "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight),
14878 ntohl (fp->sw_if_index), fp->is_local, fp->is_drop,
14879 fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address,
14880 fp->next_hop, fp->afi);
14885 static void vl_api_mpls_fib_details_t_handler_json
14886 (vl_api_mpls_fib_details_t * mp)
14888 vat_main_t *vam = &vat_main;
14889 int count = ntohl (mp->count);
14890 vat_json_node_t *node = NULL;
14891 struct in_addr ip4;
14892 struct in6_addr ip6;
14893 vl_api_fib_path_t *fp;
14896 if (VAT_JSON_ARRAY != vam->json_tree.type)
14898 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14899 vat_json_init_array (&vam->json_tree);
14901 node = vat_json_array_add (&vam->json_tree);
14903 vat_json_init_object (node);
14904 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
14905 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
14906 vat_json_object_add_uint (node, "label", ntohl (mp->label));
14907 vat_json_object_add_uint (node, "path_count", count);
14909 for (i = 0; i < count; i++)
14911 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
14912 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
14913 vat_json_object_add_uint (node, "is_local", fp->is_local);
14914 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
14915 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
14916 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
14917 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
14918 if (fp->afi == IP46_TYPE_IP4)
14920 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
14921 vat_json_object_add_ip4 (node, "next_hop", ip4);
14923 else if (fp->afi == IP46_TYPE_IP6)
14925 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
14926 vat_json_object_add_ip6 (node, "next_hop", ip6);
14932 api_mpls_fib_dump (vat_main_t * vam)
14934 vl_api_mpls_fib_dump_t *mp;
14937 M (MPLS_FIB_DUMP, mpls_fib_dump);
14940 /* Use a control ping for synchronization */
14942 vl_api_control_ping_t *mp;
14943 M (CONTROL_PING, control_ping);
14949 #define vl_api_ip_fib_details_t_endian vl_noop_handler
14950 #define vl_api_ip_fib_details_t_print vl_noop_handler
14953 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
14955 vat_main_t *vam = &vat_main;
14956 int count = ntohl (mp->count);
14957 vl_api_fib_path_t *fp;
14961 "table-id %d, prefix %U/%d\n",
14962 ntohl (mp->table_id), format_ip4_address, mp->address,
14963 mp->address_length);
14965 for (i = 0; i < count; i++)
14968 " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, "
14969 "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight),
14970 ntohl (fp->sw_if_index), fp->is_local, fp->is_drop,
14971 fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address,
14972 fp->next_hop, fp->afi);
14977 static void vl_api_ip_fib_details_t_handler_json
14978 (vl_api_ip_fib_details_t * mp)
14980 vat_main_t *vam = &vat_main;
14981 int count = ntohl (mp->count);
14982 vat_json_node_t *node = NULL;
14983 struct in_addr ip4;
14984 struct in6_addr ip6;
14985 vl_api_fib_path_t *fp;
14988 if (VAT_JSON_ARRAY != vam->json_tree.type)
14990 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
14991 vat_json_init_array (&vam->json_tree);
14993 node = vat_json_array_add (&vam->json_tree);
14995 vat_json_init_object (node);
14996 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
14997 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
14998 vat_json_object_add_ip4 (node, "prefix", ip4);
14999 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15000 vat_json_object_add_uint (node, "path_count", count);
15002 for (i = 0; i < count; i++)
15004 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15005 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15006 vat_json_object_add_uint (node, "is_local", fp->is_local);
15007 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15008 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15009 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15010 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15011 if (fp->afi == IP46_TYPE_IP4)
15013 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15014 vat_json_object_add_ip4 (node, "next_hop", ip4);
15016 else if (fp->afi == IP46_TYPE_IP6)
15018 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15019 vat_json_object_add_ip6 (node, "next_hop", ip6);
15025 api_ip_fib_dump (vat_main_t * vam)
15027 vl_api_ip_fib_dump_t *mp;
15030 M (IP_FIB_DUMP, ip_fib_dump);
15033 /* Use a control ping for synchronization */
15035 vl_api_control_ping_t *mp;
15036 M (CONTROL_PING, control_ping);
15042 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15043 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15046 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15048 vat_main_t *vam = &vat_main;
15049 int count = ntohl (mp->count);
15050 vl_api_fib_path_t *fp;
15054 "table-id %d, prefix %U/%d\n",
15055 ntohl (mp->table_id), format_ip6_address, mp->address,
15056 mp->address_length);
15058 for (i = 0; i < count; i++)
15061 " weight %d, sw_if_index %d, is_local %d, is_drop %d, is_unreach %d, "
15062 "is_prohitbit %d, afi %d, next_hop %U\n", ntohl (fp->weight),
15063 ntohl (fp->sw_if_index), fp->is_local, fp->is_drop,
15064 fp->is_unreach, fp->is_prohibit, fp->afi, format_ip46_address,
15065 fp->next_hop, fp->afi);
15070 static void vl_api_ip6_fib_details_t_handler_json
15071 (vl_api_ip6_fib_details_t * mp)
15073 vat_main_t *vam = &vat_main;
15074 int count = ntohl (mp->count);
15075 vat_json_node_t *node = NULL;
15076 struct in_addr ip4;
15077 struct in6_addr ip6;
15078 vl_api_fib_path_t *fp;
15081 if (VAT_JSON_ARRAY != vam->json_tree.type)
15083 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15084 vat_json_init_array (&vam->json_tree);
15086 node = vat_json_array_add (&vam->json_tree);
15088 vat_json_init_object (node);
15089 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15090 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15091 vat_json_object_add_ip6 (node, "prefix", ip6);
15092 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15093 vat_json_object_add_uint (node, "path_count", count);
15095 for (i = 0; i < count; i++)
15097 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15098 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15099 vat_json_object_add_uint (node, "is_local", fp->is_local);
15100 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15101 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15102 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15103 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15104 if (fp->afi == IP46_TYPE_IP4)
15106 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15107 vat_json_object_add_ip4 (node, "next_hop", ip4);
15109 else if (fp->afi == IP46_TYPE_IP6)
15111 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15112 vat_json_object_add_ip6 (node, "next_hop", ip6);
15118 api_ip6_fib_dump (vat_main_t * vam)
15120 vl_api_ip6_fib_dump_t *mp;
15123 M (IP6_FIB_DUMP, ip6_fib_dump);
15126 /* Use a control ping for synchronization */
15128 vl_api_control_ping_t *mp;
15129 M (CONTROL_PING, control_ping);
15136 api_classify_table_ids (vat_main_t * vam)
15138 vl_api_classify_table_ids_t *mp;
15141 /* Construct the API message */
15142 M (CLASSIFY_TABLE_IDS, classify_table_ids);
15152 api_classify_table_by_interface (vat_main_t * vam)
15154 unformat_input_t *input = vam->input;
15155 vl_api_classify_table_by_interface_t *mp;
15158 u32 sw_if_index = ~0;
15159 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15161 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15163 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15168 if (sw_if_index == ~0)
15170 errmsg ("missing interface name or sw_if_index\n");
15174 /* Construct the API message */
15175 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
15177 mp->sw_if_index = ntohl (sw_if_index);
15186 api_classify_table_info (vat_main_t * vam)
15188 unformat_input_t *input = vam->input;
15189 vl_api_classify_table_info_t *mp;
15193 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15195 if (unformat (input, "table_id %d", &table_id))
15200 if (table_id == ~0)
15202 errmsg ("missing table id\n");
15206 /* Construct the API message */
15207 M (CLASSIFY_TABLE_INFO, classify_table_info);
15209 mp->table_id = ntohl (table_id);
15218 api_classify_session_dump (vat_main_t * vam)
15220 unformat_input_t *input = vam->input;
15221 vl_api_classify_session_dump_t *mp;
15225 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15227 if (unformat (input, "table_id %d", &table_id))
15232 if (table_id == ~0)
15234 errmsg ("missing table id\n");
15238 /* Construct the API message */
15239 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
15241 mp->table_id = ntohl (table_id);
15244 /* Use a control ping for synchronization */
15246 vl_api_control_ping_t *mp;
15247 M (CONTROL_PING, control_ping);
15256 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
15258 vat_main_t *vam = &vat_main;
15260 fformat (vam->ofp, "collector_address %U, collector_port %d, "
15261 "src_address %U, vrf_id %d, path_mtu %u, "
15262 "template_interval %u, udp_checksum %d\n",
15263 format_ip4_address, mp->collector_address,
15264 ntohs (mp->collector_port),
15265 format_ip4_address, mp->src_address,
15266 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
15267 ntohl (mp->template_interval), mp->udp_checksum);
15270 vam->result_ready = 1;
15274 vl_api_ipfix_exporter_details_t_handler_json
15275 (vl_api_ipfix_exporter_details_t * mp)
15277 vat_main_t *vam = &vat_main;
15278 vat_json_node_t node;
15279 struct in_addr collector_address;
15280 struct in_addr src_address;
15282 vat_json_init_object (&node);
15283 clib_memcpy (&collector_address, &mp->collector_address,
15284 sizeof (collector_address));
15285 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
15286 vat_json_object_add_uint (&node, "collector_port",
15287 ntohs (mp->collector_port));
15288 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
15289 vat_json_object_add_ip4 (&node, "src_address", src_address);
15290 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
15291 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
15292 vat_json_object_add_uint (&node, "template_interval",
15293 ntohl (mp->template_interval));
15294 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
15296 vat_json_print (vam->ofp, &node);
15297 vat_json_free (&node);
15299 vam->result_ready = 1;
15303 api_ipfix_exporter_dump (vat_main_t * vam)
15305 vl_api_ipfix_exporter_dump_t *mp;
15308 /* Construct the API message */
15309 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
15319 api_ipfix_classify_stream_dump (vat_main_t * vam)
15321 vl_api_ipfix_classify_stream_dump_t *mp;
15324 /* Construct the API message */
15325 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
15335 vl_api_ipfix_classify_stream_details_t_handler
15336 (vl_api_ipfix_classify_stream_details_t * mp)
15338 vat_main_t *vam = &vat_main;
15339 fformat (vam->ofp, "domain_id %d, src_port %d\n",
15340 ntohl (mp->domain_id), ntohs (mp->src_port));
15342 vam->result_ready = 1;
15346 vl_api_ipfix_classify_stream_details_t_handler_json
15347 (vl_api_ipfix_classify_stream_details_t * mp)
15349 vat_main_t *vam = &vat_main;
15350 vat_json_node_t node;
15352 vat_json_init_object (&node);
15353 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
15354 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
15356 vat_json_print (vam->ofp, &node);
15357 vat_json_free (&node);
15359 vam->result_ready = 1;
15363 api_ipfix_classify_table_dump (vat_main_t * vam)
15365 vl_api_ipfix_classify_table_dump_t *mp;
15368 if (!vam->json_output)
15370 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
15371 "transport_protocol");
15374 /* Construct the API message */
15375 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
15380 /* Use a control ping for synchronization */
15382 vl_api_control_ping_t *mp;
15383 M (CONTROL_PING, control_ping);
15390 vl_api_ipfix_classify_table_details_t_handler
15391 (vl_api_ipfix_classify_table_details_t * mp)
15393 vat_main_t *vam = &vat_main;
15394 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
15395 mp->transport_protocol);
15399 vl_api_ipfix_classify_table_details_t_handler_json
15400 (vl_api_ipfix_classify_table_details_t * mp)
15402 vat_json_node_t *node = NULL;
15403 vat_main_t *vam = &vat_main;
15405 if (VAT_JSON_ARRAY != vam->json_tree.type)
15407 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15408 vat_json_init_array (&vam->json_tree);
15411 node = vat_json_array_add (&vam->json_tree);
15412 vat_json_init_object (node);
15414 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
15415 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
15416 vat_json_object_add_uint (node, "transport_protocol",
15417 mp->transport_protocol);
15421 api_pg_create_interface (vat_main_t * vam)
15423 unformat_input_t *input = vam->input;
15424 vl_api_pg_create_interface_t *mp;
15428 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15430 if (unformat (input, "if_id %d", &if_id))
15437 errmsg ("missing pg interface index\n");
15441 /* Construct the API message */
15442 M (PG_CREATE_INTERFACE, pg_create_interface);
15444 mp->interface_id = ntohl (if_id);
15453 api_pg_capture (vat_main_t * vam)
15455 unformat_input_t *input = vam->input;
15456 vl_api_pg_capture_t *mp;
15462 u8 pcap_file_set = 0;
15464 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15466 if (unformat (input, "if_id %d", &if_id))
15468 else if (unformat (input, "pcap %s", &pcap_file))
15470 else if (unformat (input, "count %d", &count))
15472 else if (unformat (input, "disable"))
15479 errmsg ("missing pg interface index\n");
15482 if (pcap_file_set > 0)
15484 if (vec_len (pcap_file) > 255)
15486 errmsg ("pcap file name is too long\n");
15491 u32 name_len = vec_len (pcap_file);
15492 /* Construct the API message */
15493 M (PG_CAPTURE, pg_capture);
15495 mp->interface_id = ntohl (if_id);
15496 mp->is_enabled = enable;
15497 mp->count = ntohl (count);
15498 mp->pcap_name_length = ntohl (name_len);
15499 if (pcap_file_set != 0)
15501 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
15503 vec_free (pcap_file);
15512 api_pg_enable_disable (vat_main_t * vam)
15514 unformat_input_t *input = vam->input;
15515 vl_api_pg_enable_disable_t *mp;
15519 u8 stream_name_set = 0;
15520 u8 *stream_name = 0;
15521 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15523 if (unformat (input, "stream %s", &stream_name))
15524 stream_name_set = 1;
15525 else if (unformat (input, "disable"))
15531 if (stream_name_set > 0)
15533 if (vec_len (stream_name) > 255)
15535 errmsg ("stream name too long\n");
15540 u32 name_len = vec_len (stream_name);
15541 /* Construct the API message */
15542 M (PG_ENABLE_DISABLE, pg_enable_disable);
15544 mp->is_enabled = enable;
15545 if (stream_name_set != 0)
15547 mp->stream_name_length = ntohl (name_len);
15548 clib_memcpy (mp->stream_name, stream_name, name_len);
15550 vec_free (stream_name);
15559 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
15561 unformat_input_t *input = vam->input;
15562 vl_api_ip_source_and_port_range_check_add_del_t *mp;
15565 u16 *low_ports = 0;
15566 u16 *high_ports = 0;
15569 ip4_address_t ip4_addr;
15570 ip6_address_t ip6_addr;
15578 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15580 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
15586 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
15591 else if (unformat (input, "vrf %d", &vrf_id))
15593 else if (unformat (input, "del"))
15595 else if (unformat (input, "port %d", &tmp))
15597 if (tmp == 0 || tmp > 65535)
15599 errmsg ("port %d out of range", tmp);
15603 this_hi = this_low + 1;
15604 vec_add1 (low_ports, this_low);
15605 vec_add1 (high_ports, this_hi);
15607 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
15609 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
15611 errmsg ("incorrect range parameters\n");
15615 /* Note: in debug CLI +1 is added to high before
15616 passing to real fn that does "the work"
15617 (ip_source_and_port_range_check_add_del).
15618 This fn is a wrapper around the binary API fn a
15619 control plane will call, which expects this increment
15620 to have occurred. Hence letting the binary API control
15621 plane fn do the increment for consistency between VAT
15622 and other control planes.
15625 vec_add1 (low_ports, this_low);
15626 vec_add1 (high_ports, this_hi);
15632 if (prefix_set == 0)
15634 errmsg ("<address>/<mask> not specified\n");
15640 errmsg ("VRF ID required, not specified\n");
15647 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15651 if (vec_len (low_ports) == 0)
15653 errmsg ("At least one port or port range required\n");
15657 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
15658 ip_source_and_port_range_check_add_del);
15660 mp->is_add = is_add;
15665 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
15670 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
15673 mp->mask_length = length;
15674 mp->number_of_ranges = vec_len (low_ports);
15676 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
15677 vec_free (low_ports);
15679 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
15680 vec_free (high_ports);
15682 mp->vrf_id = ntohl (vrf_id);
15691 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
15693 unformat_input_t *input = vam->input;
15694 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
15696 u32 sw_if_index = ~0;
15698 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
15699 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
15702 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15704 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15706 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15708 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
15710 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
15712 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
15714 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
15716 else if (unformat (input, "del"))
15722 if (sw_if_index == ~0)
15724 errmsg ("Interface required but not specified\n");
15730 errmsg ("VRF ID required but not specified\n");
15734 if (tcp_out_vrf_id == 0
15735 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
15738 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
15742 /* Construct the API message */
15743 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
15744 ip_source_and_port_range_check_interface_add_del);
15746 mp->sw_if_index = ntohl (sw_if_index);
15747 mp->is_add = is_add;
15748 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
15749 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
15750 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
15751 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
15756 /* Wait for a reply... */
15761 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
15763 unformat_input_t *i = vam->input;
15764 vl_api_ipsec_gre_add_del_tunnel_t *mp;
15766 u32 local_sa_id = 0;
15767 u32 remote_sa_id = 0;
15768 ip4_address_t src_address;
15769 ip4_address_t dst_address;
15772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15774 if (unformat (i, "local_sa %d", &local_sa_id))
15776 else if (unformat (i, "remote_sa %d", &remote_sa_id))
15778 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
15780 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
15782 else if (unformat (i, "del"))
15786 clib_warning ("parse error '%U'", format_unformat_error, i);
15791 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
15793 mp->local_sa_id = ntohl (local_sa_id);
15794 mp->remote_sa_id = ntohl (remote_sa_id);
15795 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
15796 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
15797 mp->is_add = is_add;
15806 api_punt (vat_main_t * vam)
15808 unformat_input_t *i = vam->input;
15816 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15818 if (unformat (i, "ip %d", &ipv))
15820 else if (unformat (i, "protocol %d", &protocol))
15822 else if (unformat (i, "port %d", &port))
15824 else if (unformat (i, "del"))
15828 clib_warning ("parse error '%U'", format_unformat_error, i);
15835 mp->is_add = (u8) is_add;
15836 mp->ipv = (u8) ipv;
15837 mp->l4_protocol = (u8) protocol;
15838 mp->l4_port = htons ((u16) port);
15846 static void vl_api_ipsec_gre_tunnel_details_t_handler
15847 (vl_api_ipsec_gre_tunnel_details_t * mp)
15849 vat_main_t *vam = &vat_main;
15851 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
15852 ntohl (mp->sw_if_index),
15853 format_ip4_address, &mp->src_address,
15854 format_ip4_address, &mp->dst_address,
15855 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
15858 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
15859 (vl_api_ipsec_gre_tunnel_details_t * mp)
15861 vat_main_t *vam = &vat_main;
15862 vat_json_node_t *node = NULL;
15863 struct in_addr ip4;
15865 if (VAT_JSON_ARRAY != vam->json_tree.type)
15867 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15868 vat_json_init_array (&vam->json_tree);
15870 node = vat_json_array_add (&vam->json_tree);
15872 vat_json_init_object (node);
15873 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
15874 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
15875 vat_json_object_add_ip4 (node, "src_address", ip4);
15876 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
15877 vat_json_object_add_ip4 (node, "dst_address", ip4);
15878 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
15879 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
15883 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
15885 unformat_input_t *i = vam->input;
15886 vl_api_ipsec_gre_tunnel_dump_t *mp;
15889 u8 sw_if_index_set = 0;
15891 /* Parse args required to build the message */
15892 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15894 if (unformat (i, "sw_if_index %d", &sw_if_index))
15895 sw_if_index_set = 1;
15900 if (sw_if_index_set == 0)
15905 if (!vam->json_output)
15907 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
15908 "sw_if_index", "src_address", "dst_address",
15909 "local_sa_id", "remote_sa_id");
15912 /* Get list of gre-tunnel interfaces */
15913 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
15915 mp->sw_if_index = htonl (sw_if_index);
15919 /* Use a control ping for synchronization */
15921 vl_api_control_ping_t *mp;
15922 M (CONTROL_PING, control_ping);
15929 api_delete_subif (vat_main_t * vam)
15931 unformat_input_t *i = vam->input;
15932 vl_api_delete_subif_t *mp;
15934 u32 sw_if_index = ~0;
15936 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15938 if (unformat (i, "sw_if_index %d", &sw_if_index))
15944 if (sw_if_index == ~0)
15946 errmsg ("missing sw_if_index\n");
15950 /* Construct the API message */
15951 M (DELETE_SUBIF, delete_subif);
15952 mp->sw_if_index = ntohl (sw_if_index);
15958 #define foreach_pbb_vtr_op \
15959 _("disable", L2_VTR_DISABLED) \
15960 _("pop", L2_VTR_POP_2) \
15961 _("push", L2_VTR_PUSH_2)
15964 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
15966 unformat_input_t *i = vam->input;
15967 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
15969 u32 sw_if_index = ~0, vtr_op = ~0;
15970 u16 outer_tag = ~0;
15971 u8 dmac[6], smac[6];
15972 u8 dmac_set = 0, smac_set = 0;
15977 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15979 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
15981 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15983 else if (unformat (i, "vtr_op %d", &vtr_op))
15985 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
15988 else if (unformat (i, "translate_pbb_stag"))
15990 if (unformat (i, "%d", &tmp))
15992 vtr_op = L2_VTR_TRANSLATE_2_1;
15998 ("translate_pbb_stag operation requires outer tag definition\n");
16002 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
16004 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
16006 else if (unformat (i, "sid %d", &sid))
16008 else if (unformat (i, "vlanid %d", &tmp))
16012 clib_warning ("parse error '%U'", format_unformat_error, i);
16017 if ((sw_if_index == ~0) || (vtr_op == ~0))
16019 errmsg ("missing sw_if_index or vtr operation\n");
16022 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
16023 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
16026 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid\n");
16030 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
16031 mp->sw_if_index = ntohl (sw_if_index);
16032 mp->vtr_op = ntohl (vtr_op);
16033 mp->outer_tag = ntohs (outer_tag);
16034 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
16035 clib_memcpy (mp->b_smac, smac, sizeof (smac));
16036 mp->b_vlanid = ntohs (vlanid);
16037 mp->i_sid = ntohl (sid);
16046 api_flow_classify_set_interface (vat_main_t * vam)
16048 unformat_input_t *i = vam->input;
16049 vl_api_flow_classify_set_interface_t *mp;
16052 int sw_if_index_set;
16053 u32 ip4_table_index = ~0;
16054 u32 ip6_table_index = ~0;
16057 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16059 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16060 sw_if_index_set = 1;
16061 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16062 sw_if_index_set = 1;
16063 else if (unformat (i, "del"))
16065 else if (unformat (i, "ip4-table %d", &ip4_table_index))
16067 else if (unformat (i, "ip6-table %d", &ip6_table_index))
16071 clib_warning ("parse error '%U'", format_unformat_error, i);
16076 if (sw_if_index_set == 0)
16078 errmsg ("missing interface name or sw_if_index\n");
16082 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
16084 mp->sw_if_index = ntohl (sw_if_index);
16085 mp->ip4_table_index = ntohl (ip4_table_index);
16086 mp->ip6_table_index = ntohl (ip6_table_index);
16087 mp->is_add = is_add;
16096 api_flow_classify_dump (vat_main_t * vam)
16098 unformat_input_t *i = vam->input;
16099 vl_api_flow_classify_dump_t *mp;
16101 u8 type = FLOW_CLASSIFY_N_TABLES;
16103 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
16107 errmsg ("classify table type must be specified\n");
16111 if (!vam->json_output)
16113 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
16116 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
16121 /* Use a control ping for synchronization */
16123 vl_api_control_ping_t *mp;
16124 M (CONTROL_PING, control_ping);
16127 /* Wait for a reply... */
16135 q_or_quit (vat_main_t * vam)
16137 longjmp (vam->jump_buf, 1);
16138 return 0; /* not so much */
16142 q (vat_main_t * vam)
16144 return q_or_quit (vam);
16148 quit (vat_main_t * vam)
16150 return q_or_quit (vam);
16154 comment (vat_main_t * vam)
16160 cmd_cmp (void *a1, void *a2)
16165 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
16169 help (vat_main_t * vam)
16174 unformat_input_t *i = vam->input;
16177 if (unformat (i, "%s", &name))
16181 vec_add1 (name, 0);
16183 hs = hash_get_mem (vam->help_by_name, name);
16185 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
16187 fformat (vam->ofp, "No such msg / command '%s'\n", name);
16192 fformat (vam->ofp, "Help is available for the following:\n");
16195 hash_foreach_pair (p, vam->function_by_name,
16197 vec_add1 (cmds, (u8 *)(p->key));
16201 vec_sort_with_function (cmds, cmd_cmp);
16203 for (j = 0; j < vec_len (cmds); j++)
16204 fformat (vam->ofp, "%s\n", cmds[j]);
16211 set (vat_main_t * vam)
16213 u8 *name = 0, *value = 0;
16214 unformat_input_t *i = vam->input;
16216 if (unformat (i, "%s", &name))
16218 /* The input buffer is a vector, not a string. */
16219 value = vec_dup (i->buffer);
16220 vec_delete (value, i->index, 0);
16221 /* Almost certainly has a trailing newline */
16222 if (value[vec_len (value) - 1] == '\n')
16223 value[vec_len (value) - 1] = 0;
16224 /* Make sure it's a proper string, one way or the other */
16225 vec_add1 (value, 0);
16226 (void) clib_macro_set_value (&vam->macro_main,
16227 (char *) name, (char *) value);
16230 errmsg ("usage: set <name> <value>\n");
16238 unset (vat_main_t * vam)
16242 if (unformat (vam->input, "%s", &name))
16243 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
16244 errmsg ("unset: %s wasn't set\n", name);
16257 macro_sort_cmp (void *a1, void *a2)
16259 macro_sort_t *s1 = a1;
16260 macro_sort_t *s2 = a2;
16262 return strcmp ((char *) (s1->name), (char *) (s2->name));
16266 dump_macro_table (vat_main_t * vam)
16268 macro_sort_t *sort_me = 0, *sm;
16273 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
16275 vec_add2 (sort_me, sm, 1);
16276 sm->name = (u8 *)(p->key);
16277 sm->value = (u8 *) (p->value[0]);
16281 vec_sort_with_function (sort_me, macro_sort_cmp);
16283 if (vec_len (sort_me))
16284 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
16286 fformat (vam->ofp, "The macro table is empty...\n");
16288 for (i = 0; i < vec_len (sort_me); i++)
16289 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
16294 dump_node_table (vat_main_t * vam)
16297 vlib_node_t *node, *next_node;
16299 if (vec_len (vam->graph_nodes) == 0)
16301 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16305 for (i = 0; i < vec_len (vam->graph_nodes); i++)
16307 node = vam->graph_nodes[i];
16308 fformat (vam->ofp, "[%d] %s\n", i, node->name);
16309 for (j = 0; j < vec_len (node->next_nodes); j++)
16311 if (node->next_nodes[j] != ~0)
16313 next_node = vam->graph_nodes[node->next_nodes[j]];
16314 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16322 search_node_table (vat_main_t * vam)
16324 unformat_input_t *line_input = vam->input;
16327 vlib_node_t *node, *next_node;
16330 if (vam->graph_node_index_by_name == 0)
16332 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
16336 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
16338 if (unformat (line_input, "%s", &node_to_find))
16340 vec_add1 (node_to_find, 0);
16341 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
16344 fformat (vam->ofp, "%s not found...\n", node_to_find);
16347 node = vam->graph_nodes[p[0]];
16348 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
16349 for (j = 0; j < vec_len (node->next_nodes); j++)
16351 if (node->next_nodes[j] != ~0)
16353 next_node = vam->graph_nodes[node->next_nodes[j]];
16354 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
16361 clib_warning ("parse error '%U'", format_unformat_error,
16367 vec_free (node_to_find);
16376 script (vat_main_t * vam)
16379 char *save_current_file;
16380 unformat_input_t save_input;
16381 jmp_buf save_jump_buf;
16382 u32 save_line_number;
16384 FILE *new_fp, *save_ifp;
16386 if (unformat (vam->input, "%s", &s))
16388 new_fp = fopen ((char *) s, "r");
16391 errmsg ("Couldn't open script file %s\n", s);
16398 errmsg ("Missing script name\n");
16402 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
16403 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
16404 save_ifp = vam->ifp;
16405 save_line_number = vam->input_line_number;
16406 save_current_file = (char *) vam->current_file;
16408 vam->input_line_number = 0;
16410 vam->current_file = s;
16413 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
16414 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
16415 vam->ifp = save_ifp;
16416 vam->input_line_number = save_line_number;
16417 vam->current_file = (u8 *) save_current_file;
16424 echo (vat_main_t * vam)
16426 fformat (vam->ofp, "%v", vam->input->buffer);
16430 /* List of API message constructors, CLI names map to api_xxx */
16431 #define foreach_vpe_api_msg \
16432 _(create_loopback,"[mac <mac-addr>]") \
16433 _(sw_interface_dump,"") \
16434 _(sw_interface_set_flags, \
16435 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
16436 _(sw_interface_add_del_address, \
16437 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
16438 _(sw_interface_set_table, \
16439 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
16440 _(sw_interface_set_mpls_enable, \
16441 "<intfc> | sw_if_index [disable | dis]") \
16442 _(sw_interface_set_vpath, \
16443 "<intfc> | sw_if_index <id> enable | disable") \
16444 _(sw_interface_set_l2_xconnect, \
16445 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16446 "enable | disable") \
16447 _(sw_interface_set_l2_bridge, \
16448 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
16449 "[shg <split-horizon-group>] [bvi]\n" \
16450 "enable | disable") \
16451 _(sw_interface_set_dpdk_hqos_pipe, \
16452 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
16453 "profile <profile-id>\n") \
16454 _(sw_interface_set_dpdk_hqos_subport, \
16455 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
16456 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
16457 _(sw_interface_set_dpdk_hqos_tctbl, \
16458 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
16459 _(bridge_domain_add_del, \
16460 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
16461 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
16463 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
16465 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
16467 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
16469 "tapname <name> mac <mac-addr> | random-mac") \
16471 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
16473 "<vpp-if-name> | sw_if_index <id>") \
16474 _(sw_interface_tap_dump, "") \
16475 _(ip_add_del_route, \
16476 "<addr>/<mask> via <addr> [table-id <n>]\n" \
16477 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16478 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16479 "[multipath] [count <n>]") \
16480 _(mpls_route_add_del, \
16481 "<label> <eos> via <addr> [table-id <n>]\n" \
16482 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
16483 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
16484 "[multipath] [count <n>]") \
16485 _(mpls_ip_bind_unbind, \
16486 "<label> <addr/len>") \
16487 _(proxy_arp_add_del, \
16488 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
16489 _(proxy_arp_intfc_enable_disable, \
16490 "<intfc> | sw_if_index <id> enable | disable") \
16491 _(mpls_add_del_encap, \
16492 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
16493 _(sw_interface_set_unnumbered, \
16494 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
16495 _(ip_neighbor_add_del, \
16496 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
16497 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
16498 _(reset_vrf, "vrf <id> [ipv6]") \
16499 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
16500 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
16501 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
16502 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
16503 "[outer_vlan_id_any][inner_vlan_id_any]") \
16504 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
16505 _(reset_fib, "vrf <n> [ipv6]") \
16506 _(dhcp_proxy_config, \
16507 "svr <v46-address> src <v46-address>\n" \
16508 "insert-cid <n> [del]") \
16509 _(dhcp_proxy_config_2, \
16510 "svr <v46-address> src <v46-address>\n" \
16511 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
16512 _(dhcp_proxy_set_vss, \
16513 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
16514 _(dhcp_client_config, \
16515 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
16516 _(set_ip_flow_hash, \
16517 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
16518 _(sw_interface_ip6_enable_disable, \
16519 "<intfc> | sw_if_index <id> enable | disable") \
16520 _(sw_interface_ip6_set_link_local_address, \
16521 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
16522 _(sw_interface_ip6nd_ra_prefix, \
16523 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
16524 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
16525 "[nolink] [isno]") \
16526 _(sw_interface_ip6nd_ra_config, \
16527 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
16528 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
16529 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
16530 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
16531 _(l2_patch_add_del, \
16532 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
16533 "enable | disable") \
16534 _(mpls_ethernet_add_del_tunnel, \
16535 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
16536 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
16537 _(mpls_ethernet_add_del_tunnel_2, \
16538 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
16539 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
16540 _(sr_tunnel_add_del, \
16541 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
16542 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
16543 "[policy <policy_name>]") \
16544 _(sr_policy_add_del, \
16545 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
16546 _(sr_multicast_map_add_del, \
16547 "address [ip6 multicast address] sr-policy [policy name] [del]") \
16548 _(classify_add_del_table, \
16549 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
16550 "[del] mask <mask-value>\n" \
16551 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
16552 _(classify_add_del_session, \
16553 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
16554 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
16555 " [l3 [ip4|ip6]]") \
16556 _(classify_set_interface_ip_table, \
16557 "<intfc> | sw_if_index <nn> table <nn>") \
16558 _(classify_set_interface_l2_tables, \
16559 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16560 " [other-table <nn>]") \
16561 _(get_node_index, "node <node-name") \
16562 _(add_node_next, "node <node-name> next <next-node-name>") \
16563 _(l2tpv3_create_tunnel, \
16564 "client_address <ip6-addr> our_address <ip6-addr>\n" \
16565 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
16566 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
16567 _(l2tpv3_set_tunnel_cookies, \
16568 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
16569 "[new_remote_cookie <nn>]\n") \
16570 _(l2tpv3_interface_enable_disable, \
16571 "<intfc> | sw_if_index <nn> enable | disable") \
16572 _(l2tpv3_set_lookup_key, \
16573 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
16574 _(sw_if_l2tpv3_tunnel_dump, "") \
16575 _(vxlan_add_del_tunnel, \
16576 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
16577 " [decap-next l2|ip4|ip6] [del]") \
16578 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16579 _(gre_add_del_tunnel, \
16580 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
16581 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16582 _(l2_fib_clear_table, "") \
16583 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
16584 _(l2_interface_vlan_tag_rewrite, \
16585 "<intfc> | sw_if_index <nn> \n" \
16586 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
16587 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
16588 _(create_vhost_user_if, \
16589 "socket <filename> [server] [renumber <dev_instance>] " \
16590 "[mac <mac_address>]") \
16591 _(modify_vhost_user_if, \
16592 "<intfc> | sw_if_index <nn> socket <filename>\n" \
16593 "[server] [renumber <dev_instance>]") \
16594 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
16595 _(sw_interface_vhost_user_dump, "") \
16596 _(show_version, "") \
16597 _(vxlan_gpe_add_del_tunnel, \
16598 "local <addr> remote <addr> vni <nn>\n" \
16599 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
16600 "[next-ethernet] [next-nsh]\n") \
16601 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
16602 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
16603 _(interface_name_renumber, \
16604 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
16605 _(input_acl_set_interface, \
16606 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16607 " [l2-table <nn>] [del]") \
16608 _(want_ip4_arp_events, "address <ip4-address> [del]") \
16609 _(want_ip6_nd_events, "address <ip6-address> [del]") \
16610 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
16611 _(ip_dump, "ipv4 | ipv6") \
16612 _(ipsec_spd_add_del, "spd_id <n> [del]") \
16613 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
16615 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
16616 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
16617 " integ_alg <alg> integ_key <hex>") \
16618 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
16619 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
16620 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
16621 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
16622 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
16623 _(ikev2_profile_add_del, "name <profile_name> [del]") \
16624 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
16625 "(auth_data 0x<data> | auth_data <data>)") \
16626 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
16627 "(id_data 0x<data> | id_data <data>) (local|remote)") \
16628 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
16629 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
16630 "(local|remote)") \
16631 _(ikev2_set_local_key, "file <absolute_file_path>") \
16632 _(delete_loopback,"sw_if_index <nn>") \
16633 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
16634 _(map_add_domain, \
16635 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
16636 "ip6-src <ip6addr> " \
16637 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
16638 _(map_del_domain, "index <n>") \
16639 _(map_add_del_rule, \
16640 "index <n> psid <n> dst <ip6addr> [del]") \
16641 _(map_domain_dump, "") \
16642 _(map_rule_dump, "index <map-domain>") \
16643 _(want_interface_events, "enable|disable") \
16644 _(want_stats,"enable|disable") \
16645 _(get_first_msg_id, "client <name>") \
16646 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
16647 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
16648 "fib-id <nn> [ip4][ip6][default]") \
16649 _(get_node_graph, " ") \
16650 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
16651 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
16652 _(ioam_disable, "") \
16653 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
16654 " sw_if_index <sw_if_index> p <priority> " \
16655 "w <weight>] [del]") \
16656 _(lisp_add_del_locator, "locator-set <locator_name> " \
16657 "iface <intf> | sw_if_index <sw_if_index> " \
16658 "p <priority> w <weight> [del]") \
16659 _(lisp_add_del_local_eid,"vni <vni> eid " \
16660 "<ipv4|ipv6>/<prefix> | <L2 address> " \
16661 "locator-set <locator_name> [del]") \
16662 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
16663 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
16664 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
16665 _(lisp_gpe_enable_disable, "enable|disable") \
16666 _(lisp_enable_disable, "enable|disable") \
16667 _(lisp_gpe_add_del_iface, "up|down") \
16668 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
16670 "rloc <locator> p <prio> " \
16671 "w <weight> [rloc <loc> ... ] " \
16672 "action <action> [del-all]") \
16673 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
16675 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
16676 _(lisp_map_request_mode, "src-dst|dst-only") \
16677 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
16678 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
16679 _(lisp_locator_set_dump, "[local | remote]") \
16680 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
16681 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
16682 "[local] | [remote]") \
16683 _(lisp_eid_table_vni_dump, "") \
16684 _(lisp_eid_table_map_dump, "l2|l3") \
16685 _(lisp_gpe_tunnel_dump, "") \
16686 _(lisp_map_resolver_dump, "") \
16687 _(lisp_adjacencies_get, "vni <vni>") \
16688 _(show_lisp_status, "") \
16689 _(lisp_get_map_request_itr_rlocs, "") \
16690 _(show_lisp_pitr, "") \
16691 _(show_lisp_map_request_mode, "") \
16692 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
16693 _(af_packet_delete, "name <host interface name>") \
16694 _(policer_add_del, "name <policer name> <params> [del]") \
16695 _(policer_dump, "[name <policer name>]") \
16696 _(policer_classify_set_interface, \
16697 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
16698 " [l2-table <nn>] [del]") \
16699 _(policer_classify_dump, "type [ip4|ip6|l2]") \
16700 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
16701 "[master|slave]") \
16702 _(netmap_delete, "name <interface name>") \
16703 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
16704 _(mpls_fib_encap_dump, "") \
16705 _(mpls_fib_dump, "") \
16706 _(classify_table_ids, "") \
16707 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
16708 _(classify_table_info, "table_id <nn>") \
16709 _(classify_session_dump, "table_id <nn>") \
16710 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
16711 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
16712 "[template_interval <nn>] [udp_checksum]") \
16713 _(ipfix_exporter_dump, "") \
16714 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
16715 _(ipfix_classify_stream_dump, "") \
16716 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
16717 _(ipfix_classify_table_dump, "") \
16718 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
16719 _(pg_create_interface, "if_id <nn>") \
16720 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
16721 _(pg_enable_disable, "[stream <id>] disable") \
16722 _(ip_source_and_port_range_check_add_del, \
16723 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
16724 _(ip_source_and_port_range_check_interface_add_del, \
16725 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
16726 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
16727 _(ipsec_gre_add_del_tunnel, \
16728 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
16729 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
16730 _(delete_subif,"sub_sw_if_index <nn> sub_if_id <nn>") \
16731 _(l2_interface_pbb_tag_rewrite, \
16732 "<intfc> | sw_if_index <nn> \n" \
16733 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
16734 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
16735 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
16736 _(flow_classify_set_interface, \
16737 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
16738 _(flow_classify_dump, "type [ip4|ip6]") \
16739 _(ip_fib_dump, "") \
16740 _(ip6_fib_dump, "")
16742 /* List of command functions, CLI names map directly to functions */
16743 #define foreach_cli_function \
16744 _(comment, "usage: comment <ignore-rest-of-line>") \
16745 _(dump_interface_table, "usage: dump_interface_table") \
16746 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
16747 _(dump_ipv4_table, "usage: dump_ipv4_table") \
16748 _(dump_ipv6_table, "usage: dump_ipv6_table") \
16749 _(dump_stats_table, "usage: dump_stats_table") \
16750 _(dump_macro_table, "usage: dump_macro_table ") \
16751 _(dump_node_table, "usage: dump_node_table") \
16752 _(echo, "usage: echo <message>") \
16753 _(exec, "usage: exec <vpe-debug-CLI-command>") \
16754 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
16755 _(help, "usage: help") \
16756 _(q, "usage: quit") \
16757 _(quit, "usage: quit") \
16758 _(search_node_table, "usage: search_node_table <name>...") \
16759 _(set, "usage: set <variable-name> <value>") \
16760 _(script, "usage: script <file-name>") \
16761 _(unset, "usage: unset <variable-name>")
16764 static void vl_api_##n##_t_handler_uni \
16765 (vl_api_##n##_t * mp) \
16767 vat_main_t * vam = &vat_main; \
16768 if (vam->json_output) { \
16769 vl_api_##n##_t_handler_json(mp); \
16771 vl_api_##n##_t_handler(mp); \
16774 foreach_vpe_api_reply_msg;
16778 vat_api_hookup (vat_main_t * vam)
16781 vl_msg_api_set_handlers(VL_API_##N, #n, \
16782 vl_api_##n##_t_handler_uni, \
16784 vl_api_##n##_t_endian, \
16785 vl_api_##n##_t_print, \
16786 sizeof(vl_api_##n##_t), 1);
16787 foreach_vpe_api_reply_msg;
16790 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
16792 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
16794 vam->function_by_name = hash_create_string (0, sizeof (uword));
16796 vam->help_by_name = hash_create_string (0, sizeof (uword));
16798 /* API messages we can send */
16799 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
16800 foreach_vpe_api_msg;
16804 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16805 foreach_vpe_api_msg;
16808 /* CLI functions */
16809 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
16810 foreach_cli_function;
16814 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
16815 foreach_cli_function;
16819 #undef vl_api_version
16820 #define vl_api_version(n,v) static u32 vpe_api_version = v;
16821 #include <vpp-api/vpe.api.h>
16822 #undef vl_api_version
16825 vl_client_add_api_signatures (vl_api_memclnt_create_t * mp)
16828 * Send the main API signature in slot 0. This bit of code must
16829 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
16831 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
16835 * fd.io coding-style-patch-verification: ON
16838 * eval: (c-set-style "gnu")