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>
40 #include <vnet/ipsec/ipsec.h>
41 #include <vnet/ipsec/ikev2.h>
43 #include <vnet/map/map.h>
44 #include <vnet/cop/cop.h>
45 #include <vnet/ip/ip6_hop_by_hop.h>
46 #include <vnet/ip/ip_source_and_port_range_check.h>
47 #include <vnet/policer/xlate.h>
48 #include <vnet/span/span.h>
49 #include <vnet/policer/policer.h>
50 #include <vnet/policer/police.h>
52 #include "vat/json_format.h"
57 #define vl_typedefs /* define message structures */
58 #include <vpp-api/vpe_all_api_h.h>
61 /* declare message handlers for each api */
63 #define vl_endianfun /* define message structures */
64 #include <vpp-api/vpe_all_api_h.h>
67 /* instantiate all the print functions we know about */
68 #define vl_print(handle, ...)
70 #include <vpp-api/vpe_all_api_h.h>
74 unformat_sw_if_index (unformat_input_t * input, va_list * args)
76 vat_main_t *vam = va_arg (*args, vat_main_t *);
77 u32 *result = va_arg (*args, u32 *);
81 if (!unformat (input, "%s", &if_name))
84 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
91 /* Parse an IP4 address %d.%d.%d.%d. */
93 unformat_ip4_address (unformat_input_t * input, va_list * args)
95 u8 *result = va_arg (*args, u8 *);
98 if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
101 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
114 unformat_ethernet_address (unformat_input_t * input, va_list * args)
116 u8 *result = va_arg (*args, u8 *);
119 if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
120 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
124 for (i = 0; i < 6; i++)
125 if (a[i] >= (1 << 8))
128 for (i = 0; i < 6; i++)
134 /* Returns ethernet type as an int in host byte order. */
136 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
139 u16 *result = va_arg (*args, u16 *);
143 if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
145 if (type >= (1 << 16))
153 /* Parse an IP6 address. */
155 unformat_ip6_address (unformat_input_t * input, va_list * args)
157 ip6_address_t *result = va_arg (*args, ip6_address_t *);
159 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
160 uword c, n_colon, double_colon_index;
162 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
163 double_colon_index = ARRAY_LEN (hex_quads);
164 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
167 if (c >= '0' && c <= '9')
169 else if (c >= 'a' && c <= 'f')
170 hex_digit = c + 10 - 'a';
171 else if (c >= 'A' && c <= 'F')
172 hex_digit = c + 10 - 'A';
173 else if (c == ':' && n_colon < 2)
177 unformat_put_input (input);
181 /* Too many hex quads. */
182 if (n_hex_quads >= ARRAY_LEN (hex_quads))
187 hex_quad = (hex_quad << 4) | hex_digit;
189 /* Hex quad must fit in 16 bits. */
190 if (n_hex_digits >= 4)
197 /* Save position of :: */
200 /* More than one :: ? */
201 if (double_colon_index < ARRAY_LEN (hex_quads))
203 double_colon_index = n_hex_quads;
206 if (n_colon > 0 && n_hex_digits > 0)
208 hex_quads[n_hex_quads++] = hex_quad;
214 if (n_hex_digits > 0)
215 hex_quads[n_hex_quads++] = hex_quad;
220 /* Expand :: to appropriate number of zero hex quads. */
221 if (double_colon_index < ARRAY_LEN (hex_quads))
223 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
225 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
226 hex_quads[n_zero + i] = hex_quads[i];
228 for (i = 0; i < n_zero; i++)
229 hex_quads[double_colon_index + i] = 0;
231 n_hex_quads = ARRAY_LEN (hex_quads);
234 /* Too few hex quads given. */
235 if (n_hex_quads < ARRAY_LEN (hex_quads))
238 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
239 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
246 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
248 u32 *r = va_arg (*args, u32 *);
251 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
252 foreach_ipsec_policy_action
260 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
262 u32 *r = va_arg (*args, u32 *);
265 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
266 foreach_ipsec_crypto_alg
274 format_ipsec_crypto_alg (u8 * s, va_list * args)
276 u32 i = va_arg (*args, u32);
281 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
282 foreach_ipsec_crypto_alg
285 return format (s, "unknown");
287 return format (s, "%s", t);
291 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
293 u32 *r = va_arg (*args, u32 *);
296 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
297 foreach_ipsec_integ_alg
305 format_ipsec_integ_alg (u8 * s, va_list * args)
307 u32 i = va_arg (*args, u32);
312 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
313 foreach_ipsec_integ_alg
316 return format (s, "unknown");
318 return format (s, "%s", t);
322 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
324 u32 *r = va_arg (*args, u32 *);
327 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
328 foreach_ikev2_auth_method
336 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
338 u32 *r = va_arg (*args, u32 *);
341 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
342 foreach_ikev2_id_type
350 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
352 u8 *r = va_arg (*args, u8 *);
354 if (unformat (input, "kbps"))
355 *r = SSE2_QOS_RATE_KBPS;
356 else if (unformat (input, "pps"))
357 *r = SSE2_QOS_RATE_PPS;
364 unformat_policer_round_type (unformat_input_t * input, va_list * args)
366 u8 *r = va_arg (*args, u8 *);
368 if (unformat (input, "closest"))
369 *r = SSE2_QOS_ROUND_TO_CLOSEST;
370 else if (unformat (input, "up"))
371 *r = SSE2_QOS_ROUND_TO_UP;
372 else if (unformat (input, "down"))
373 *r = SSE2_QOS_ROUND_TO_DOWN;
380 unformat_policer_type (unformat_input_t * input, va_list * args)
382 u8 *r = va_arg (*args, u8 *);
384 if (unformat (input, "1r2c"))
385 *r = SSE2_QOS_POLICER_TYPE_1R2C;
386 else if (unformat (input, "1r3c"))
387 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
388 else if (unformat (input, "2r3c-2698"))
389 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
390 else if (unformat (input, "2r3c-4115"))
391 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
392 else if (unformat (input, "2r3c-mef5cf1"))
393 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
400 unformat_dscp (unformat_input_t * input, va_list * va)
402 u8 *r = va_arg (*va, u8 *);
405 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
414 unformat_policer_action_type (unformat_input_t * input, va_list * va)
416 sse2_qos_pol_action_params_st *a
417 = va_arg (*va, sse2_qos_pol_action_params_st *);
419 if (unformat (input, "drop"))
420 a->action_type = SSE2_QOS_ACTION_DROP;
421 else if (unformat (input, "transmit"))
422 a->action_type = SSE2_QOS_ACTION_TRANSMIT;
423 else if (unformat (input, "mark-and-transmit %U", unformat_dscp, &a->dscp))
424 a->action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
431 unformat_policer_classify_table_type (unformat_input_t * input, va_list * va)
433 u32 *r = va_arg (*va, u32 *);
436 if (unformat (input, "ip4"))
437 tid = POLICER_CLASSIFY_TABLE_IP4;
438 else if (unformat (input, "ip6"))
439 tid = POLICER_CLASSIFY_TABLE_IP6;
440 else if (unformat (input, "l2"))
441 tid = POLICER_CLASSIFY_TABLE_L2;
450 unformat_flow_classify_table_type (unformat_input_t * input, va_list * va)
452 u32 *r = va_arg (*va, u32 *);
455 if (unformat (input, "ip4"))
456 tid = FLOW_CLASSIFY_TABLE_IP4;
457 else if (unformat (input, "ip6"))
458 tid = FLOW_CLASSIFY_TABLE_IP6;
467 format_ip4_address (u8 * s, va_list * args)
469 u8 *a = va_arg (*args, u8 *);
470 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
474 format_ip6_address (u8 * s, va_list * args)
476 ip6_address_t *a = va_arg (*args, ip6_address_t *);
477 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
479 i_max_n_zero = ARRAY_LEN (a->as_u16);
481 i_first_zero = i_max_n_zero;
483 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
485 u32 is_zero = a->as_u16[i] == 0;
486 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
492 if ((!is_zero && n_zeros > max_n_zeros)
493 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
495 i_max_n_zero = i_first_zero;
496 max_n_zeros = n_zeros;
497 i_first_zero = ARRAY_LEN (a->as_u16);
502 last_double_colon = 0;
503 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
505 if (i == i_max_n_zero && max_n_zeros > 1)
507 s = format (s, "::");
508 i += max_n_zeros - 1;
509 last_double_colon = 1;
513 s = format (s, "%s%x",
514 (last_double_colon || i == 0) ? "" : ":",
515 clib_net_to_host_u16 (a->as_u16[i]));
516 last_double_colon = 0;
523 /* Format an IP46 address. */
525 format_ip46_address (u8 * s, va_list * args)
527 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
528 ip46_type_t type = va_arg (*args, ip46_type_t);
534 is_ip4 = ip46_address_is_ip4 (ip46);
545 format (s, "%U", format_ip4_address, &ip46->ip4) :
546 format (s, "%U", format_ip6_address, &ip46->ip6);
550 format_ethernet_address (u8 * s, va_list * args)
552 u8 *a = va_arg (*args, u8 *);
554 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
555 a[0], a[1], a[2], a[3], a[4], a[5]);
559 increment_v4_address (ip4_address_t * a)
563 v = ntohl (a->as_u32) + 1;
564 a->as_u32 = ntohl (v);
568 increment_v6_address (ip6_address_t * a)
572 v0 = clib_net_to_host_u64 (a->as_u64[0]);
573 v1 = clib_net_to_host_u64 (a->as_u64[1]);
578 a->as_u64[0] = clib_net_to_host_u64 (v0);
579 a->as_u64[1] = clib_net_to_host_u64 (v1);
583 increment_mac_address (u64 * mac)
587 tmp = clib_net_to_host_u64 (tmp);
588 tmp += 1 << 16; /* skip unused (least significant) octets */
589 tmp = clib_host_to_net_u64 (tmp);
593 static void vl_api_create_loopback_reply_t_handler
594 (vl_api_create_loopback_reply_t * mp)
596 vat_main_t *vam = &vat_main;
597 i32 retval = ntohl (mp->retval);
599 vam->retval = retval;
600 vam->regenerate_interface_table = 1;
601 vam->sw_if_index = ntohl (mp->sw_if_index);
602 vam->result_ready = 1;
605 static void vl_api_create_loopback_reply_t_handler_json
606 (vl_api_create_loopback_reply_t * mp)
608 vat_main_t *vam = &vat_main;
609 vat_json_node_t node;
611 vat_json_init_object (&node);
612 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
613 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
615 vat_json_print (vam->ofp, &node);
616 vat_json_free (&node);
617 vam->retval = ntohl (mp->retval);
618 vam->result_ready = 1;
621 static void vl_api_af_packet_create_reply_t_handler
622 (vl_api_af_packet_create_reply_t * mp)
624 vat_main_t *vam = &vat_main;
625 i32 retval = ntohl (mp->retval);
627 vam->retval = retval;
628 vam->regenerate_interface_table = 1;
629 vam->sw_if_index = ntohl (mp->sw_if_index);
630 vam->result_ready = 1;
633 static void vl_api_af_packet_create_reply_t_handler_json
634 (vl_api_af_packet_create_reply_t * mp)
636 vat_main_t *vam = &vat_main;
637 vat_json_node_t node;
639 vat_json_init_object (&node);
640 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
641 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
643 vat_json_print (vam->ofp, &node);
644 vat_json_free (&node);
646 vam->retval = ntohl (mp->retval);
647 vam->result_ready = 1;
650 static void vl_api_create_vlan_subif_reply_t_handler
651 (vl_api_create_vlan_subif_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_create_vlan_subif_reply_t_handler_json
663 (vl_api_create_vlan_subif_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_subif_reply_t_handler
680 (vl_api_create_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_subif_reply_t_handler_json
692 (vl_api_create_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_interface_name_renumber_reply_t_handler
709 (vl_api_interface_name_renumber_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->result_ready = 1;
719 static void vl_api_interface_name_renumber_reply_t_handler_json
720 (vl_api_interface_name_renumber_reply_t * mp)
722 vat_main_t *vam = &vat_main;
723 vat_json_node_t node;
725 vat_json_init_object (&node);
726 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
728 vat_json_print (vam->ofp, &node);
729 vat_json_free (&node);
731 vam->retval = ntohl (mp->retval);
732 vam->result_ready = 1;
736 * Special-case: build the interface table, maintain
737 * the next loopback sw_if_index vbl.
739 static void vl_api_sw_interface_details_t_handler
740 (vl_api_sw_interface_details_t * mp)
742 vat_main_t *vam = &vat_main;
743 u8 *s = format (0, "%s%c", mp->interface_name, 0);
745 hash_set_mem (vam->sw_if_index_by_interface_name, s,
746 ntohl (mp->sw_if_index));
748 /* In sub interface case, fill the sub interface table entry */
749 if (mp->sw_if_index != mp->sup_sw_if_index)
751 sw_interface_subif_t *sub = NULL;
753 vec_add2 (vam->sw_if_subif_table, sub, 1);
755 vec_validate (sub->interface_name, strlen ((char *) s) + 1);
756 strncpy ((char *) sub->interface_name, (char *) s,
757 vec_len (sub->interface_name));
758 sub->sw_if_index = ntohl (mp->sw_if_index);
759 sub->sub_id = ntohl (mp->sub_id);
761 sub->sub_dot1ad = mp->sub_dot1ad;
762 sub->sub_number_of_tags = mp->sub_number_of_tags;
763 sub->sub_outer_vlan_id = ntohs (mp->sub_outer_vlan_id);
764 sub->sub_inner_vlan_id = ntohs (mp->sub_inner_vlan_id);
765 sub->sub_exact_match = mp->sub_exact_match;
766 sub->sub_default = mp->sub_default;
767 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
768 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
770 /* vlan tag rewrite */
771 sub->vtr_op = ntohl (mp->vtr_op);
772 sub->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q);
773 sub->vtr_tag1 = ntohl (mp->vtr_tag1);
774 sub->vtr_tag2 = ntohl (mp->vtr_tag2);
778 static void vl_api_sw_interface_details_t_handler_json
779 (vl_api_sw_interface_details_t * mp)
781 vat_main_t *vam = &vat_main;
782 vat_json_node_t *node = NULL;
784 if (VAT_JSON_ARRAY != vam->json_tree.type)
786 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
787 vat_json_init_array (&vam->json_tree);
789 node = vat_json_array_add (&vam->json_tree);
791 vat_json_init_object (node);
792 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
793 vat_json_object_add_uint (node, "sup_sw_if_index",
794 ntohl (mp->sup_sw_if_index));
795 vat_json_object_add_uint (node, "l2_address_length",
796 ntohl (mp->l2_address_length));
797 vat_json_object_add_bytes (node, "l2_address", mp->l2_address,
798 sizeof (mp->l2_address));
799 vat_json_object_add_string_copy (node, "interface_name",
801 vat_json_object_add_uint (node, "admin_up_down", mp->admin_up_down);
802 vat_json_object_add_uint (node, "link_up_down", mp->link_up_down);
803 vat_json_object_add_uint (node, "link_duplex", mp->link_duplex);
804 vat_json_object_add_uint (node, "link_speed", mp->link_speed);
805 vat_json_object_add_uint (node, "mtu", ntohs (mp->link_mtu));
806 vat_json_object_add_uint (node, "sub_id", ntohl (mp->sub_id));
807 vat_json_object_add_uint (node, "sub_dot1ad", mp->sub_dot1ad);
808 vat_json_object_add_uint (node, "sub_number_of_tags",
809 mp->sub_number_of_tags);
810 vat_json_object_add_uint (node, "sub_outer_vlan_id",
811 ntohs (mp->sub_outer_vlan_id));
812 vat_json_object_add_uint (node, "sub_inner_vlan_id",
813 ntohs (mp->sub_inner_vlan_id));
814 vat_json_object_add_uint (node, "sub_exact_match", mp->sub_exact_match);
815 vat_json_object_add_uint (node, "sub_default", mp->sub_default);
816 vat_json_object_add_uint (node, "sub_outer_vlan_id_any",
817 mp->sub_outer_vlan_id_any);
818 vat_json_object_add_uint (node, "sub_inner_vlan_id_any",
819 mp->sub_inner_vlan_id_any);
820 vat_json_object_add_uint (node, "vtr_op", ntohl (mp->vtr_op));
821 vat_json_object_add_uint (node, "vtr_push_dot1q",
822 ntohl (mp->vtr_push_dot1q));
823 vat_json_object_add_uint (node, "vtr_tag1", ntohl (mp->vtr_tag1));
824 vat_json_object_add_uint (node, "vtr_tag2", ntohl (mp->vtr_tag2));
827 static void vl_api_sw_interface_set_flags_t_handler
828 (vl_api_sw_interface_set_flags_t * mp)
830 vat_main_t *vam = &vat_main;
831 if (vam->interface_event_display)
832 errmsg ("interface flags: sw_if_index %d %s %s\n",
833 ntohl (mp->sw_if_index),
834 mp->admin_up_down ? "admin-up" : "admin-down",
835 mp->link_up_down ? "link-up" : "link-down");
838 static void vl_api_sw_interface_set_flags_t_handler_json
839 (vl_api_sw_interface_set_flags_t * mp)
841 /* JSON output not supported */
845 vl_api_cli_reply_t_handler (vl_api_cli_reply_t * mp)
847 vat_main_t *vam = &vat_main;
848 i32 retval = ntohl (mp->retval);
850 vam->retval = retval;
851 vam->shmem_result = (u8 *) mp->reply_in_shmem;
852 vam->result_ready = 1;
856 vl_api_cli_reply_t_handler_json (vl_api_cli_reply_t * mp)
858 vat_main_t *vam = &vat_main;
859 vat_json_node_t node;
860 api_main_t *am = &api_main;
864 vat_json_init_object (&node);
865 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
866 vat_json_object_add_uint (&node, "reply_in_shmem",
867 ntohl (mp->reply_in_shmem));
868 /* Toss the shared-memory original... */
869 pthread_mutex_lock (&am->vlib_rp->mutex);
870 oldheap = svm_push_data_heap (am->vlib_rp);
872 reply = (u8 *) (mp->reply_in_shmem);
875 svm_pop_heap (oldheap);
876 pthread_mutex_unlock (&am->vlib_rp->mutex);
878 vat_json_print (vam->ofp, &node);
879 vat_json_free (&node);
881 vam->retval = ntohl (mp->retval);
882 vam->result_ready = 1;
886 vl_api_cli_inband_reply_t_handler (vl_api_cli_inband_reply_t * mp)
888 vat_main_t *vam = &vat_main;
889 i32 retval = ntohl (mp->retval);
891 vam->retval = retval;
892 vam->cmd_reply = mp->reply;
893 vam->result_ready = 1;
897 vl_api_cli_inband_reply_t_handler_json (vl_api_cli_inband_reply_t * mp)
899 vat_main_t *vam = &vat_main;
900 vat_json_node_t node;
902 vat_json_init_object (&node);
903 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
904 vat_json_object_add_string_copy (&node, "reply", mp->reply);
906 vat_json_print (vam->ofp, &node);
907 vat_json_free (&node);
909 vam->retval = ntohl (mp->retval);
910 vam->result_ready = 1;
913 static void vl_api_classify_add_del_table_reply_t_handler
914 (vl_api_classify_add_del_table_reply_t * mp)
916 vat_main_t *vam = &vat_main;
917 i32 retval = ntohl (mp->retval);
920 vam->async_errors += (retval < 0);
924 vam->retval = retval;
926 ((mp->new_table_index != 0xFFFFFFFF) ||
927 (mp->skip_n_vectors != 0xFFFFFFFF) ||
928 (mp->match_n_vectors != 0xFFFFFFFF)))
930 * Note: this is just barely thread-safe, depends on
931 * the main thread spinning waiting for an answer...
933 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
934 ntohl (mp->new_table_index),
935 ntohl (mp->skip_n_vectors), ntohl (mp->match_n_vectors));
936 vam->result_ready = 1;
940 static void vl_api_classify_add_del_table_reply_t_handler_json
941 (vl_api_classify_add_del_table_reply_t * mp)
943 vat_main_t *vam = &vat_main;
944 vat_json_node_t node;
946 vat_json_init_object (&node);
947 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
948 vat_json_object_add_uint (&node, "new_table_index",
949 ntohl (mp->new_table_index));
950 vat_json_object_add_uint (&node, "skip_n_vectors",
951 ntohl (mp->skip_n_vectors));
952 vat_json_object_add_uint (&node, "match_n_vectors",
953 ntohl (mp->match_n_vectors));
955 vat_json_print (vam->ofp, &node);
956 vat_json_free (&node);
958 vam->retval = ntohl (mp->retval);
959 vam->result_ready = 1;
962 static void vl_api_get_node_index_reply_t_handler
963 (vl_api_get_node_index_reply_t * mp)
965 vat_main_t *vam = &vat_main;
966 i32 retval = ntohl (mp->retval);
969 vam->async_errors += (retval < 0);
973 vam->retval = retval;
975 errmsg ("node index %d\n", ntohl (mp->node_index));
976 vam->result_ready = 1;
980 static void vl_api_get_node_index_reply_t_handler_json
981 (vl_api_get_node_index_reply_t * mp)
983 vat_main_t *vam = &vat_main;
984 vat_json_node_t node;
986 vat_json_init_object (&node);
987 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
988 vat_json_object_add_uint (&node, "node_index", ntohl (mp->node_index));
990 vat_json_print (vam->ofp, &node);
991 vat_json_free (&node);
993 vam->retval = ntohl (mp->retval);
994 vam->result_ready = 1;
997 static void vl_api_get_next_index_reply_t_handler
998 (vl_api_get_next_index_reply_t * mp)
1000 vat_main_t *vam = &vat_main;
1001 i32 retval = ntohl (mp->retval);
1002 if (vam->async_mode)
1004 vam->async_errors += (retval < 0);
1008 vam->retval = retval;
1010 errmsg ("next node index %d\n", ntohl (mp->next_index));
1011 vam->result_ready = 1;
1015 static void vl_api_get_next_index_reply_t_handler_json
1016 (vl_api_get_next_index_reply_t * mp)
1018 vat_main_t *vam = &vat_main;
1019 vat_json_node_t node;
1021 vat_json_init_object (&node);
1022 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1023 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1025 vat_json_print (vam->ofp, &node);
1026 vat_json_free (&node);
1028 vam->retval = ntohl (mp->retval);
1029 vam->result_ready = 1;
1032 static void vl_api_add_node_next_reply_t_handler
1033 (vl_api_add_node_next_reply_t * mp)
1035 vat_main_t *vam = &vat_main;
1036 i32 retval = ntohl (mp->retval);
1037 if (vam->async_mode)
1039 vam->async_errors += (retval < 0);
1043 vam->retval = retval;
1045 errmsg ("next index %d\n", ntohl (mp->next_index));
1046 vam->result_ready = 1;
1050 static void vl_api_add_node_next_reply_t_handler_json
1051 (vl_api_add_node_next_reply_t * mp)
1053 vat_main_t *vam = &vat_main;
1054 vat_json_node_t node;
1056 vat_json_init_object (&node);
1057 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1058 vat_json_object_add_uint (&node, "next_index", ntohl (mp->next_index));
1060 vat_json_print (vam->ofp, &node);
1061 vat_json_free (&node);
1063 vam->retval = ntohl (mp->retval);
1064 vam->result_ready = 1;
1067 static void vl_api_show_version_reply_t_handler
1068 (vl_api_show_version_reply_t * mp)
1070 vat_main_t *vam = &vat_main;
1071 i32 retval = ntohl (mp->retval);
1075 errmsg (" program: %s\n", mp->program);
1076 errmsg (" version: %s\n", mp->version);
1077 errmsg (" build date: %s\n", mp->build_date);
1078 errmsg ("build directory: %s\n", mp->build_directory);
1080 vam->retval = retval;
1081 vam->result_ready = 1;
1084 static void vl_api_show_version_reply_t_handler_json
1085 (vl_api_show_version_reply_t * mp)
1087 vat_main_t *vam = &vat_main;
1088 vat_json_node_t node;
1090 vat_json_init_object (&node);
1091 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1092 vat_json_object_add_string_copy (&node, "program", mp->program);
1093 vat_json_object_add_string_copy (&node, "version", mp->version);
1094 vat_json_object_add_string_copy (&node, "build_date", mp->build_date);
1095 vat_json_object_add_string_copy (&node, "build_directory",
1096 mp->build_directory);
1098 vat_json_print (vam->ofp, &node);
1099 vat_json_free (&node);
1101 vam->retval = ntohl (mp->retval);
1102 vam->result_ready = 1;
1106 vl_api_ip4_arp_event_t_handler (vl_api_ip4_arp_event_t * mp)
1108 vat_main_t *vam = &vat_main;
1109 errmsg ("arp %s event: address %U new mac %U sw_if_index %d\n",
1110 mp->mac_ip ? "mac/ip binding" : "address resolution",
1111 format_ip4_address, &mp->address,
1112 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1116 vl_api_ip4_arp_event_t_handler_json (vl_api_ip4_arp_event_t * mp)
1118 /* JSON output not supported */
1122 vl_api_ip6_nd_event_t_handler (vl_api_ip6_nd_event_t * mp)
1124 vat_main_t *vam = &vat_main;
1125 errmsg ("ip6 nd %s event: address %U new mac %U sw_if_index %d\n",
1126 mp->mac_ip ? "mac/ip binding" : "address resolution",
1127 format_ip6_address, mp->address,
1128 format_ethernet_address, mp->new_mac, mp->sw_if_index);
1132 vl_api_ip6_nd_event_t_handler_json (vl_api_ip6_nd_event_t * mp)
1134 /* JSON output not supported */
1138 * Special-case: build the bridge domain table, maintain
1139 * the next bd id vbl.
1141 static void vl_api_bridge_domain_details_t_handler
1142 (vl_api_bridge_domain_details_t * mp)
1144 vat_main_t *vam = &vat_main;
1145 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1147 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1148 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1150 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1151 ntohl (mp->bd_id), mp->learn, mp->forward,
1152 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1155 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1159 static void vl_api_bridge_domain_details_t_handler_json
1160 (vl_api_bridge_domain_details_t * mp)
1162 vat_main_t *vam = &vat_main;
1163 vat_json_node_t *node, *array = NULL;
1165 if (VAT_JSON_ARRAY != vam->json_tree.type)
1167 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1168 vat_json_init_array (&vam->json_tree);
1170 node = vat_json_array_add (&vam->json_tree);
1172 vat_json_init_object (node);
1173 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1174 vat_json_object_add_uint (node, "flood", mp->flood);
1175 vat_json_object_add_uint (node, "forward", mp->forward);
1176 vat_json_object_add_uint (node, "learn", mp->learn);
1177 vat_json_object_add_uint (node, "bvi_sw_if_index",
1178 ntohl (mp->bvi_sw_if_index));
1179 vat_json_object_add_uint (node, "n_sw_ifs", ntohl (mp->n_sw_ifs));
1180 array = vat_json_object_add (node, "sw_if");
1181 vat_json_init_array (array);
1185 * Special-case: build the bridge domain sw if table.
1187 static void vl_api_bridge_domain_sw_if_details_t_handler
1188 (vl_api_bridge_domain_sw_if_details_t * mp)
1190 vat_main_t *vam = &vat_main;
1195 sw_if_index = ntohl (mp->sw_if_index);
1197 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1199 if ((u32) p->value[0] == sw_if_index)
1201 sw_if_name = (u8 *)(p->key);
1207 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1208 mp->shg, sw_if_name ? (char *) sw_if_name :
1209 "sw_if_index not found!");
1212 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1213 (vl_api_bridge_domain_sw_if_details_t * mp)
1215 vat_main_t *vam = &vat_main;
1216 vat_json_node_t *node = NULL;
1217 uword last_index = 0;
1219 ASSERT (VAT_JSON_ARRAY == vam->json_tree.type);
1220 ASSERT (vec_len (vam->json_tree.array) >= 1);
1221 last_index = vec_len (vam->json_tree.array) - 1;
1222 node = &vam->json_tree.array[last_index];
1223 node = vat_json_object_get_element (node, "sw_if");
1224 ASSERT (NULL != node);
1225 node = vat_json_array_add (node);
1227 vat_json_init_object (node);
1228 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
1229 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
1230 vat_json_object_add_uint (node, "shg", mp->shg);
1233 static void vl_api_control_ping_reply_t_handler
1234 (vl_api_control_ping_reply_t * mp)
1236 vat_main_t *vam = &vat_main;
1237 i32 retval = ntohl (mp->retval);
1238 if (vam->async_mode)
1240 vam->async_errors += (retval < 0);
1244 vam->retval = retval;
1245 vam->result_ready = 1;
1249 static void vl_api_control_ping_reply_t_handler_json
1250 (vl_api_control_ping_reply_t * mp)
1252 vat_main_t *vam = &vat_main;
1253 i32 retval = ntohl (mp->retval);
1255 if (VAT_JSON_NONE != vam->json_tree.type)
1257 vat_json_print (vam->ofp, &vam->json_tree);
1258 vat_json_free (&vam->json_tree);
1259 vam->json_tree.type = VAT_JSON_NONE;
1264 vat_json_init_array (&vam->json_tree);
1265 vat_json_print (vam->ofp, &vam->json_tree);
1266 vam->json_tree.type = VAT_JSON_NONE;
1269 vam->retval = retval;
1270 vam->result_ready = 1;
1274 vl_api_l2_flags_reply_t_handler (vl_api_l2_flags_reply_t * mp)
1276 vat_main_t *vam = &vat_main;
1277 i32 retval = ntohl (mp->retval);
1278 if (vam->async_mode)
1280 vam->async_errors += (retval < 0);
1284 vam->retval = retval;
1285 vam->result_ready = 1;
1289 static void vl_api_l2_flags_reply_t_handler_json
1290 (vl_api_l2_flags_reply_t * mp)
1292 vat_main_t *vam = &vat_main;
1293 vat_json_node_t node;
1295 vat_json_init_object (&node);
1296 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1297 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1298 ntohl (mp->resulting_feature_bitmap));
1300 vat_json_print (vam->ofp, &node);
1301 vat_json_free (&node);
1303 vam->retval = ntohl (mp->retval);
1304 vam->result_ready = 1;
1307 static void vl_api_bridge_flags_reply_t_handler
1308 (vl_api_bridge_flags_reply_t * mp)
1310 vat_main_t *vam = &vat_main;
1311 i32 retval = ntohl (mp->retval);
1312 if (vam->async_mode)
1314 vam->async_errors += (retval < 0);
1318 vam->retval = retval;
1319 vam->result_ready = 1;
1323 static void vl_api_bridge_flags_reply_t_handler_json
1324 (vl_api_bridge_flags_reply_t * mp)
1326 vat_main_t *vam = &vat_main;
1327 vat_json_node_t node;
1329 vat_json_init_object (&node);
1330 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1331 vat_json_object_add_uint (&node, "resulting_feature_bitmap",
1332 ntohl (mp->resulting_feature_bitmap));
1334 vat_json_print (vam->ofp, &node);
1335 vat_json_free (&node);
1337 vam->retval = ntohl (mp->retval);
1338 vam->result_ready = 1;
1341 static void vl_api_tap_connect_reply_t_handler
1342 (vl_api_tap_connect_reply_t * mp)
1344 vat_main_t *vam = &vat_main;
1345 i32 retval = ntohl (mp->retval);
1346 if (vam->async_mode)
1348 vam->async_errors += (retval < 0);
1352 vam->retval = retval;
1353 vam->sw_if_index = ntohl (mp->sw_if_index);
1354 vam->result_ready = 1;
1359 static void vl_api_tap_connect_reply_t_handler_json
1360 (vl_api_tap_connect_reply_t * mp)
1362 vat_main_t *vam = &vat_main;
1363 vat_json_node_t node;
1365 vat_json_init_object (&node);
1366 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1367 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1369 vat_json_print (vam->ofp, &node);
1370 vat_json_free (&node);
1372 vam->retval = ntohl (mp->retval);
1373 vam->result_ready = 1;
1378 vl_api_tap_modify_reply_t_handler (vl_api_tap_modify_reply_t * mp)
1380 vat_main_t *vam = &vat_main;
1381 i32 retval = ntohl (mp->retval);
1382 if (vam->async_mode)
1384 vam->async_errors += (retval < 0);
1388 vam->retval = retval;
1389 vam->sw_if_index = ntohl (mp->sw_if_index);
1390 vam->result_ready = 1;
1394 static void vl_api_tap_modify_reply_t_handler_json
1395 (vl_api_tap_modify_reply_t * mp)
1397 vat_main_t *vam = &vat_main;
1398 vat_json_node_t node;
1400 vat_json_init_object (&node);
1401 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1402 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1404 vat_json_print (vam->ofp, &node);
1405 vat_json_free (&node);
1407 vam->retval = ntohl (mp->retval);
1408 vam->result_ready = 1;
1412 vl_api_tap_delete_reply_t_handler (vl_api_tap_delete_reply_t * mp)
1414 vat_main_t *vam = &vat_main;
1415 i32 retval = ntohl (mp->retval);
1416 if (vam->async_mode)
1418 vam->async_errors += (retval < 0);
1422 vam->retval = retval;
1423 vam->result_ready = 1;
1427 static void vl_api_tap_delete_reply_t_handler_json
1428 (vl_api_tap_delete_reply_t * mp)
1430 vat_main_t *vam = &vat_main;
1431 vat_json_node_t node;
1433 vat_json_init_object (&node);
1434 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1436 vat_json_print (vam->ofp, &node);
1437 vat_json_free (&node);
1439 vam->retval = ntohl (mp->retval);
1440 vam->result_ready = 1;
1443 static void vl_api_mpls_tunnel_add_del_reply_t_handler
1444 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1446 vat_main_t *vam = &vat_main;
1447 i32 retval = ntohl (mp->retval);
1448 if (vam->async_mode)
1450 vam->async_errors += (retval < 0);
1454 vam->retval = retval;
1455 vam->result_ready = 1;
1459 static void vl_api_mpls_tunnel_add_del_reply_t_handler_json
1460 (vl_api_mpls_tunnel_add_del_reply_t * mp)
1462 vat_main_t *vam = &vat_main;
1463 vat_json_node_t node;
1465 vat_json_init_object (&node);
1466 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1467 vat_json_object_add_uint (&node, "tunnel_sw_if_index",
1468 ntohl (mp->sw_if_index));
1470 vat_json_print (vam->ofp, &node);
1471 vat_json_free (&node);
1473 vam->retval = ntohl (mp->retval);
1474 vam->result_ready = 1;
1477 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1478 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1480 vat_main_t *vam = &vat_main;
1481 i32 retval = ntohl (mp->retval);
1482 if (vam->async_mode)
1484 vam->async_errors += (retval < 0);
1488 vam->retval = retval;
1489 vam->sw_if_index = ntohl (mp->sw_if_index);
1490 vam->result_ready = 1;
1494 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1495 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1497 vat_main_t *vam = &vat_main;
1498 vat_json_node_t node;
1500 vat_json_init_object (&node);
1501 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1502 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1504 vat_json_print (vam->ofp, &node);
1505 vat_json_free (&node);
1507 vam->retval = ntohl (mp->retval);
1508 vam->result_ready = 1;
1512 static void vl_api_lisp_add_del_locator_set_reply_t_handler
1513 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1515 vat_main_t *vam = &vat_main;
1516 i32 retval = ntohl (mp->retval);
1517 if (vam->async_mode)
1519 vam->async_errors += (retval < 0);
1523 vam->retval = retval;
1524 vam->result_ready = 1;
1528 static void vl_api_lisp_add_del_locator_set_reply_t_handler_json
1529 (vl_api_lisp_add_del_locator_set_reply_t * mp)
1531 vat_main_t *vam = &vat_main;
1532 vat_json_node_t node;
1534 vat_json_init_object (&node);
1535 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1536 vat_json_object_add_uint (&node, "locator_set_index", ntohl (mp->ls_index));
1538 vat_json_print (vam->ofp, &node);
1539 vat_json_free (&node);
1541 vam->retval = ntohl (mp->retval);
1542 vam->result_ready = 1;
1545 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1546 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1548 vat_main_t *vam = &vat_main;
1549 i32 retval = ntohl (mp->retval);
1550 if (vam->async_mode)
1552 vam->async_errors += (retval < 0);
1556 vam->retval = retval;
1557 vam->sw_if_index = ntohl (mp->sw_if_index);
1558 vam->result_ready = 1;
1562 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1563 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1565 vat_main_t *vam = &vat_main;
1566 vat_json_node_t node;
1568 vat_json_init_object (&node);
1569 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1570 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1572 vat_json_print (vam->ofp, &node);
1573 vat_json_free (&node);
1575 vam->retval = ntohl (mp->retval);
1576 vam->result_ready = 1;
1579 static void vl_api_gre_add_del_tunnel_reply_t_handler
1580 (vl_api_gre_add_del_tunnel_reply_t * mp)
1582 vat_main_t *vam = &vat_main;
1583 i32 retval = ntohl (mp->retval);
1584 if (vam->async_mode)
1586 vam->async_errors += (retval < 0);
1590 vam->retval = retval;
1591 vam->sw_if_index = ntohl (mp->sw_if_index);
1592 vam->result_ready = 1;
1596 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1597 (vl_api_gre_add_del_tunnel_reply_t * mp)
1599 vat_main_t *vam = &vat_main;
1600 vat_json_node_t node;
1602 vat_json_init_object (&node);
1603 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1604 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1606 vat_json_print (vam->ofp, &node);
1607 vat_json_free (&node);
1609 vam->retval = ntohl (mp->retval);
1610 vam->result_ready = 1;
1613 static void vl_api_create_vhost_user_if_reply_t_handler
1614 (vl_api_create_vhost_user_if_reply_t * mp)
1616 vat_main_t *vam = &vat_main;
1617 i32 retval = ntohl (mp->retval);
1618 if (vam->async_mode)
1620 vam->async_errors += (retval < 0);
1624 vam->retval = retval;
1625 vam->sw_if_index = ntohl (mp->sw_if_index);
1626 vam->result_ready = 1;
1630 static void vl_api_create_vhost_user_if_reply_t_handler_json
1631 (vl_api_create_vhost_user_if_reply_t * mp)
1633 vat_main_t *vam = &vat_main;
1634 vat_json_node_t node;
1636 vat_json_init_object (&node);
1637 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
1638 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
1640 vat_json_print (vam->ofp, &node);
1641 vat_json_free (&node);
1643 vam->retval = ntohl (mp->retval);
1644 vam->result_ready = 1;
1647 static void vl_api_ip_address_details_t_handler
1648 (vl_api_ip_address_details_t * mp)
1650 vat_main_t *vam = &vat_main;
1651 static ip_address_details_t empty_ip_address_details = { {0} };
1652 ip_address_details_t *address = NULL;
1653 ip_details_t *current_ip_details = NULL;
1654 ip_details_t *details = NULL;
1656 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1658 if (!details || vam->current_sw_if_index >= vec_len (details)
1659 || !details[vam->current_sw_if_index].present)
1661 errmsg ("ip address details arrived but not stored\n");
1662 errmsg ("ip_dump should be called first\n");
1666 current_ip_details = vec_elt_at_index (details, vam->current_sw_if_index);
1668 #define addresses (current_ip_details->addr)
1670 vec_validate_init_empty (addresses, vec_len (addresses),
1671 empty_ip_address_details);
1673 address = vec_elt_at_index (addresses, vec_len (addresses) - 1);
1675 clib_memcpy (&address->ip, &mp->ip, sizeof (address->ip));
1676 address->prefix_length = mp->prefix_length;
1680 static void vl_api_ip_address_details_t_handler_json
1681 (vl_api_ip_address_details_t * mp)
1683 vat_main_t *vam = &vat_main;
1684 vat_json_node_t *node = NULL;
1685 struct in6_addr ip6;
1688 if (VAT_JSON_ARRAY != vam->json_tree.type)
1690 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1691 vat_json_init_array (&vam->json_tree);
1693 node = vat_json_array_add (&vam->json_tree);
1695 vat_json_init_object (node);
1698 clib_memcpy (&ip6, mp->ip, sizeof (ip6));
1699 vat_json_object_add_ip6 (node, "ip", ip6);
1703 clib_memcpy (&ip4, mp->ip, sizeof (ip4));
1704 vat_json_object_add_ip4 (node, "ip", ip4);
1706 vat_json_object_add_uint (node, "prefix_length", mp->prefix_length);
1710 vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1712 vat_main_t *vam = &vat_main;
1713 static ip_details_t empty_ip_details = { 0 };
1714 ip_details_t *ip = NULL;
1715 u32 sw_if_index = ~0;
1717 sw_if_index = ntohl (mp->sw_if_index);
1719 vec_validate_init_empty (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1720 sw_if_index, empty_ip_details);
1722 ip = vec_elt_at_index (vam->ip_details_by_sw_if_index[vam->is_ipv6],
1729 vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1731 vat_main_t *vam = &vat_main;
1733 if (VAT_JSON_ARRAY != vam->json_tree.type)
1735 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1736 vat_json_init_array (&vam->json_tree);
1738 vat_json_array_add_uint (&vam->json_tree,
1739 clib_net_to_host_u32 (mp->sw_if_index));
1742 static void vl_api_map_domain_details_t_handler_json
1743 (vl_api_map_domain_details_t * mp)
1745 vat_json_node_t *node = NULL;
1746 vat_main_t *vam = &vat_main;
1747 struct in6_addr ip6;
1750 if (VAT_JSON_ARRAY != vam->json_tree.type)
1752 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1753 vat_json_init_array (&vam->json_tree);
1756 node = vat_json_array_add (&vam->json_tree);
1757 vat_json_init_object (node);
1759 vat_json_object_add_uint (node, "domain_index",
1760 clib_net_to_host_u32 (mp->domain_index));
1761 clib_memcpy (&ip6, mp->ip6_prefix, sizeof (ip6));
1762 vat_json_object_add_ip6 (node, "ip6_prefix", ip6);
1763 clib_memcpy (&ip4, mp->ip4_prefix, sizeof (ip4));
1764 vat_json_object_add_ip4 (node, "ip4_prefix", ip4);
1765 clib_memcpy (&ip6, mp->ip6_src, sizeof (ip6));
1766 vat_json_object_add_ip6 (node, "ip6_src", ip6);
1767 vat_json_object_add_int (node, "ip6_prefix_len", mp->ip6_prefix_len);
1768 vat_json_object_add_int (node, "ip4_prefix_len", mp->ip4_prefix_len);
1769 vat_json_object_add_int (node, "ip6_src_len", mp->ip6_src_len);
1770 vat_json_object_add_int (node, "ea_bits_len", mp->ea_bits_len);
1771 vat_json_object_add_int (node, "psid_offset", mp->psid_offset);
1772 vat_json_object_add_int (node, "psid_length", mp->psid_length);
1773 vat_json_object_add_uint (node, "flags", mp->flags);
1774 vat_json_object_add_uint (node, "mtu", clib_net_to_host_u16 (mp->mtu));
1775 vat_json_object_add_int (node, "is_translation", mp->is_translation);
1778 static void vl_api_map_domain_details_t_handler
1779 (vl_api_map_domain_details_t * mp)
1781 vat_main_t *vam = &vat_main;
1783 if (mp->is_translation)
1786 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1787 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1788 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1789 format_ip6_address, mp->ip6_src, mp->ip6_src_len,
1790 clib_net_to_host_u32 (mp->domain_index));
1795 "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1796 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1797 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1798 format_ip6_address, mp->ip6_src,
1799 clib_net_to_host_u32 (mp->domain_index));
1801 fformat (vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1802 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu,
1803 mp->is_translation ? "map-t" : "");
1806 static void vl_api_map_rule_details_t_handler_json
1807 (vl_api_map_rule_details_t * mp)
1809 struct in6_addr ip6;
1810 vat_json_node_t *node = NULL;
1811 vat_main_t *vam = &vat_main;
1813 if (VAT_JSON_ARRAY != vam->json_tree.type)
1815 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
1816 vat_json_init_array (&vam->json_tree);
1819 node = vat_json_array_add (&vam->json_tree);
1820 vat_json_init_object (node);
1822 vat_json_object_add_uint (node, "psid", clib_net_to_host_u16 (mp->psid));
1823 clib_memcpy (&ip6, mp->ip6_dst, sizeof (ip6));
1824 vat_json_object_add_ip6 (node, "ip6_dst", ip6);
1828 vl_api_map_rule_details_t_handler (vl_api_map_rule_details_t * mp)
1830 vat_main_t *vam = &vat_main;
1831 fformat (vam->ofp, " %d (psid) %U (ip6-dst)\n",
1832 clib_net_to_host_u16 (mp->psid), format_ip6_address, mp->ip6_dst);
1836 vl_api_dhcp_compl_event_t_handler (vl_api_dhcp_compl_event_t * mp)
1838 vat_main_t *vam = &vat_main;
1839 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1840 "router_addr %U host_mac %U\n",
1841 mp->pid, mp->is_ipv6 ? "ipv6" : "ipv4", mp->hostname,
1842 format_ip4_address, &mp->host_address,
1843 format_ip4_address, &mp->router_address,
1844 format_ethernet_address, mp->host_mac);
1847 static void vl_api_dhcp_compl_event_t_handler_json
1848 (vl_api_dhcp_compl_event_t * mp)
1850 /* JSON output not supported */
1854 set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1857 vat_main_t *vam = &vat_main;
1858 static u64 default_counter = 0;
1860 vec_validate_init_empty (vam->simple_interface_counters, vnet_counter_type,
1862 vec_validate_init_empty (vam->simple_interface_counters[vnet_counter_type],
1863 sw_if_index, default_counter);
1864 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1868 set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1869 interface_counter_t counter)
1871 vat_main_t *vam = &vat_main;
1872 static interface_counter_t default_counter = { 0, };
1874 vec_validate_init_empty (vam->combined_interface_counters,
1875 vnet_counter_type, NULL);
1876 vec_validate_init_empty (vam->combined_interface_counters
1877 [vnet_counter_type], sw_if_index, default_counter);
1878 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1881 static void vl_api_vnet_interface_counters_t_handler
1882 (vl_api_vnet_interface_counters_t * mp)
1887 static void vl_api_vnet_interface_counters_t_handler_json
1888 (vl_api_vnet_interface_counters_t * mp)
1890 interface_counter_t counter;
1895 u32 first_sw_if_index;
1898 count = ntohl (mp->count);
1899 first_sw_if_index = ntohl (mp->first_sw_if_index);
1901 if (!mp->is_combined)
1903 v_packets = (u64 *) & mp->data;
1904 for (i = 0; i < count; i++)
1907 clib_net_to_host_u64 (clib_mem_unaligned (v_packets, u64));
1908 set_simple_interface_counter (mp->vnet_counter_type,
1909 first_sw_if_index + i, packets);
1915 v = (vlib_counter_t *) & mp->data;
1916 for (i = 0; i < count; i++)
1919 clib_net_to_host_u64 (clib_mem_unaligned (&v->packets, u64));
1921 clib_net_to_host_u64 (clib_mem_unaligned (&v->bytes, u64));
1922 set_combined_interface_counter (mp->vnet_counter_type,
1923 first_sw_if_index + i, counter);
1930 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1932 vat_main_t *vam = &vat_main;
1935 for (i = 0; i < vec_len (vam->ip4_fib_counters_vrf_id_by_index); i++)
1937 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id)
1946 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1948 vat_main_t *vam = &vat_main;
1951 for (i = 0; i < vec_len (vam->ip6_fib_counters_vrf_id_by_index); i++)
1953 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id)
1961 static void vl_api_vnet_ip4_fib_counters_t_handler
1962 (vl_api_vnet_ip4_fib_counters_t * mp)
1967 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1968 (vl_api_vnet_ip4_fib_counters_t * mp)
1970 vat_main_t *vam = &vat_main;
1971 vl_api_ip4_fib_counter_t *v;
1972 ip4_fib_counter_t *counter;
1979 vrf_id = ntohl (mp->vrf_id);
1980 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
1981 if (~0 == vrf_index)
1983 vrf_index = vec_len (vam->ip4_fib_counters_vrf_id_by_index);
1984 vec_validate (vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
1985 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1986 vec_validate (vam->ip4_fib_counters, vrf_index);
1987 vam->ip4_fib_counters[vrf_index] = NULL;
1990 vec_free (vam->ip4_fib_counters[vrf_index]);
1991 v = (vl_api_ip4_fib_counter_t *) & mp->c;
1992 count = ntohl (mp->count);
1993 for (i = 0; i < count; i++)
1995 vec_validate (vam->ip4_fib_counters[vrf_index], i);
1996 counter = &vam->ip4_fib_counters[vrf_index][i];
1997 clib_memcpy (&ip4, &v->address, sizeof (ip4));
1998 counter->address = ip4;
1999 counter->address_length = v->address_length;
2000 counter->packets = clib_net_to_host_u64 (v->packets);
2001 counter->bytes = clib_net_to_host_u64 (v->bytes);
2006 static void vl_api_vnet_ip6_fib_counters_t_handler
2007 (vl_api_vnet_ip6_fib_counters_t * mp)
2012 static void vl_api_vnet_ip6_fib_counters_t_handler_json
2013 (vl_api_vnet_ip6_fib_counters_t * mp)
2015 vat_main_t *vam = &vat_main;
2016 vl_api_ip6_fib_counter_t *v;
2017 ip6_fib_counter_t *counter;
2018 struct in6_addr ip6;
2024 vrf_id = ntohl (mp->vrf_id);
2025 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id (vrf_id);
2026 if (~0 == vrf_index)
2028 vrf_index = vec_len (vam->ip6_fib_counters_vrf_id_by_index);
2029 vec_validate (vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
2030 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
2031 vec_validate (vam->ip6_fib_counters, vrf_index);
2032 vam->ip6_fib_counters[vrf_index] = NULL;
2035 vec_free (vam->ip6_fib_counters[vrf_index]);
2036 v = (vl_api_ip6_fib_counter_t *) & mp->c;
2037 count = ntohl (mp->count);
2038 for (i = 0; i < count; i++)
2040 vec_validate (vam->ip6_fib_counters[vrf_index], i);
2041 counter = &vam->ip6_fib_counters[vrf_index][i];
2042 clib_memcpy (&ip6, &v->address, sizeof (ip6));
2043 counter->address = ip6;
2044 counter->address_length = v->address_length;
2045 counter->packets = clib_net_to_host_u64 (v->packets);
2046 counter->bytes = clib_net_to_host_u64 (v->bytes);
2051 static void vl_api_get_first_msg_id_reply_t_handler
2052 (vl_api_get_first_msg_id_reply_t * mp)
2054 vat_main_t *vam = &vat_main;
2055 i32 retval = ntohl (mp->retval);
2057 if (vam->async_mode)
2059 vam->async_errors += (retval < 0);
2063 vam->retval = retval;
2064 vam->result_ready = 1;
2068 errmsg ("first message id %d\n", ntohs (mp->first_msg_id));
2072 static void vl_api_get_first_msg_id_reply_t_handler_json
2073 (vl_api_get_first_msg_id_reply_t * mp)
2075 vat_main_t *vam = &vat_main;
2076 vat_json_node_t node;
2078 vat_json_init_object (&node);
2079 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2080 vat_json_object_add_uint (&node, "first_msg_id",
2081 (uint) ntohs (mp->first_msg_id));
2083 vat_json_print (vam->ofp, &node);
2084 vat_json_free (&node);
2086 vam->retval = ntohl (mp->retval);
2087 vam->result_ready = 1;
2090 static void vl_api_get_node_graph_reply_t_handler
2091 (vl_api_get_node_graph_reply_t * mp)
2093 vat_main_t *vam = &vat_main;
2094 api_main_t *am = &api_main;
2095 i32 retval = ntohl (mp->retval);
2096 u8 *pvt_copy, *reply;
2101 if (vam->async_mode)
2103 vam->async_errors += (retval < 0);
2107 vam->retval = retval;
2108 vam->result_ready = 1;
2111 /* "Should never happen..." */
2115 reply = (u8 *) (mp->reply_in_shmem);
2116 pvt_copy = vec_dup (reply);
2118 /* Toss the shared-memory original... */
2119 pthread_mutex_lock (&am->vlib_rp->mutex);
2120 oldheap = svm_push_data_heap (am->vlib_rp);
2124 svm_pop_heap (oldheap);
2125 pthread_mutex_unlock (&am->vlib_rp->mutex);
2127 if (vam->graph_nodes)
2129 hash_free (vam->graph_node_index_by_name);
2131 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2133 node = vam->graph_nodes[i];
2134 vec_free (node->name);
2135 vec_free (node->next_nodes);
2138 vec_free (vam->graph_nodes);
2141 vam->graph_node_index_by_name = hash_create_string (0, sizeof (uword));
2142 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
2143 vec_free (pvt_copy);
2145 for (i = 0; i < vec_len (vam->graph_nodes); i++)
2147 node = vam->graph_nodes[i];
2148 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
2152 static void vl_api_get_node_graph_reply_t_handler_json
2153 (vl_api_get_node_graph_reply_t * mp)
2155 vat_main_t *vam = &vat_main;
2156 api_main_t *am = &api_main;
2158 vat_json_node_t node;
2161 /* $$$$ make this real? */
2162 vat_json_init_object (&node);
2163 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
2164 vat_json_object_add_uint (&node, "reply_in_shmem", mp->reply_in_shmem);
2166 reply = (u8 *) (mp->reply_in_shmem);
2168 /* Toss the shared-memory original... */
2169 pthread_mutex_lock (&am->vlib_rp->mutex);
2170 oldheap = svm_push_data_heap (am->vlib_rp);
2174 svm_pop_heap (oldheap);
2175 pthread_mutex_unlock (&am->vlib_rp->mutex);
2177 vat_json_print (vam->ofp, &node);
2178 vat_json_free (&node);
2180 vam->retval = ntohl (mp->retval);
2181 vam->result_ready = 1;
2185 vl_api_lisp_locator_details_t_handler (vl_api_lisp_locator_details_t * mp)
2187 vat_main_t *vam = &vat_main;
2192 s = format (s, "%=16d%=16d%=16d\n",
2193 ntohl (mp->sw_if_index), mp->priority, mp->weight);
2197 s = format (s, "%=16U%=16d%=16d\n",
2198 mp->is_ipv6 ? format_ip6_address :
2200 mp->ip_address, mp->priority, mp->weight);
2203 fformat (vam->ofp, "%v", s);
2208 vl_api_lisp_locator_details_t_handler_json (vl_api_lisp_locator_details_t *
2211 vat_main_t *vam = &vat_main;
2212 vat_json_node_t *node = NULL;
2213 struct in6_addr ip6;
2216 if (VAT_JSON_ARRAY != vam->json_tree.type)
2218 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2219 vat_json_init_array (&vam->json_tree);
2221 node = vat_json_array_add (&vam->json_tree);
2222 vat_json_init_object (node);
2224 vat_json_object_add_uint (node, "local", mp->local ? 1 : 0);
2225 vat_json_object_add_uint (node, "priority", mp->priority);
2226 vat_json_object_add_uint (node, "weight", mp->weight);
2229 vat_json_object_add_uint (node, "sw_if_index",
2230 clib_net_to_host_u32 (mp->sw_if_index));
2235 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2236 vat_json_object_add_ip6 (node, "address", ip6);
2240 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2241 vat_json_object_add_ip4 (node, "address", ip4);
2247 vl_api_lisp_locator_set_details_t_handler (vl_api_lisp_locator_set_details_t *
2250 vat_main_t *vam = &vat_main;
2253 ls_name = format (0, "%s", mp->ls_name);
2255 fformat (vam->ofp, "%=10d%=15v\n", clib_net_to_host_u32 (mp->ls_index),
2261 vl_api_lisp_locator_set_details_t_handler_json
2262 (vl_api_lisp_locator_set_details_t * mp)
2264 vat_main_t *vam = &vat_main;
2265 vat_json_node_t *node = 0;
2268 ls_name = format (0, "%s", mp->ls_name);
2269 vec_add1 (ls_name, 0);
2271 if (VAT_JSON_ARRAY != vam->json_tree.type)
2273 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2274 vat_json_init_array (&vam->json_tree);
2276 node = vat_json_array_add (&vam->json_tree);
2278 vat_json_init_object (node);
2279 vat_json_object_add_string_copy (node, "ls_name", ls_name);
2280 vat_json_object_add_uint (node, "ls_index",
2281 clib_net_to_host_u32 (mp->ls_index));
2286 format_lisp_flat_eid (u8 * s, va_list * args)
2288 u32 type = va_arg (*args, u32);
2289 u8 *eid = va_arg (*args, u8 *);
2290 u32 eid_len = va_arg (*args, u32);
2295 return format (s, "%U/%d", format_ip4_address, eid, eid_len);
2297 return format (s, "%U/%d", format_ip6_address, eid, eid_len);
2299 return format (s, "%U", format_ethernet_address, eid);
2305 format_lisp_eid_vat (u8 * s, va_list * args)
2307 u32 type = va_arg (*args, u32);
2308 u8 *eid = va_arg (*args, u8 *);
2309 u32 eid_len = va_arg (*args, u32);
2310 u8 *seid = va_arg (*args, u8 *);
2311 u32 seid_len = va_arg (*args, u32);
2312 u32 is_src_dst = va_arg (*args, u32);
2315 s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
2317 s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
2323 vl_api_lisp_eid_table_details_t_handler (vl_api_lisp_eid_table_details_t * mp)
2325 vat_main_t *vam = &vat_main;
2326 u8 *s = 0, *eid = 0;
2328 if (~0 == mp->locator_set_index)
2329 s = format (0, "action: %d", mp->action);
2331 s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
2333 eid = format (0, "%U", format_lisp_eid_vat,
2337 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2340 fformat (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s\n",
2341 clib_net_to_host_u32 (mp->vni),
2343 mp->is_local ? "local" : "remote",
2344 s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
2345 clib_net_to_host_u16 (mp->key_id), mp->key);
2352 vl_api_lisp_eid_table_details_t_handler_json (vl_api_lisp_eid_table_details_t
2355 vat_main_t *vam = &vat_main;
2356 vat_json_node_t *node = 0;
2359 if (VAT_JSON_ARRAY != vam->json_tree.type)
2361 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2362 vat_json_init_array (&vam->json_tree);
2364 node = vat_json_array_add (&vam->json_tree);
2366 vat_json_init_object (node);
2367 if (~0 == mp->locator_set_index)
2368 vat_json_object_add_uint (node, "action", mp->action);
2370 vat_json_object_add_uint (node, "locator_set_index",
2371 clib_net_to_host_u32 (mp->locator_set_index));
2373 vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
2374 eid = format (0, "%U", format_lisp_eid_vat,
2378 mp->seid, mp->seid_prefix_len, mp->is_src_dst);
2380 vat_json_object_add_string_copy (node, "eid", eid);
2381 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2382 vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
2383 vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
2387 vat_json_object_add_uint (node, "key_id",
2388 clib_net_to_host_u16 (mp->key_id));
2389 vat_json_object_add_string_copy (node, "key", mp->key);
2395 vl_api_lisp_eid_table_map_details_t_handler
2396 (vl_api_lisp_eid_table_map_details_t * mp)
2398 vat_main_t *vam = &vat_main;
2400 u8 *line = format (0, "%=10d%=10d",
2401 clib_net_to_host_u32 (mp->vni),
2402 clib_net_to_host_u32 (mp->dp_table));
2403 fformat (vam->ofp, "%v\n", line);
2408 vl_api_lisp_eid_table_map_details_t_handler_json
2409 (vl_api_lisp_eid_table_map_details_t * mp)
2411 vat_main_t *vam = &vat_main;
2412 vat_json_node_t *node = NULL;
2414 if (VAT_JSON_ARRAY != vam->json_tree.type)
2416 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2417 vat_json_init_array (&vam->json_tree);
2419 node = vat_json_array_add (&vam->json_tree);
2420 vat_json_init_object (node);
2421 vat_json_object_add_uint (node, "dp_table",
2422 clib_net_to_host_u32 (mp->dp_table));
2423 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2427 vl_api_lisp_eid_table_vni_details_t_handler
2428 (vl_api_lisp_eid_table_vni_details_t * mp)
2430 vat_main_t *vam = &vat_main;
2432 u8 *line = format (0, "%d", clib_net_to_host_u32 (mp->vni));
2433 fformat (vam->ofp, "%v\n", line);
2438 vl_api_lisp_eid_table_vni_details_t_handler_json
2439 (vl_api_lisp_eid_table_vni_details_t * mp)
2441 vat_main_t *vam = &vat_main;
2442 vat_json_node_t *node = NULL;
2444 if (VAT_JSON_ARRAY != vam->json_tree.type)
2446 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2447 vat_json_init_array (&vam->json_tree);
2449 node = vat_json_array_add (&vam->json_tree);
2450 vat_json_init_object (node);
2451 vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
2455 format_decap_next (u8 * s, va_list * args)
2457 u32 next_index = va_arg (*args, u32);
2461 case LISP_GPE_INPUT_NEXT_DROP:
2462 return format (s, "drop");
2463 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2464 return format (s, "ip4");
2465 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2466 return format (s, "ip6");
2468 return format (s, "unknown %d", next_index);
2474 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *
2477 vat_main_t *vam = &vat_main;
2479 u8 *flag_str = NULL;
2481 iid_str = format (0, "%d (0x%x)", ntohl (mp->iid), ntohl (mp->iid));
2483 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2484 foreach_lisp_gpe_flag_bit;
2487 fformat (vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2488 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2490 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2492 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2494 ntohl (mp->encap_fib_id),
2495 ntohl (mp->decap_fib_id),
2496 format_decap_next, ntohl (mp->dcap_next),
2498 flag_str, mp->next_protocol, mp->ver_res, mp->res, iid_str);
2504 vl_api_lisp_gpe_tunnel_details_t_handler_json
2505 (vl_api_lisp_gpe_tunnel_details_t * mp)
2507 vat_main_t *vam = &vat_main;
2508 vat_json_node_t *node = NULL;
2509 struct in6_addr ip6;
2513 next_decap_str = format (0, "%U", format_decap_next, htonl (mp->dcap_next));
2515 if (VAT_JSON_ARRAY != vam->json_tree.type)
2517 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2518 vat_json_init_array (&vam->json_tree);
2520 node = vat_json_array_add (&vam->json_tree);
2522 vat_json_init_object (node);
2523 vat_json_object_add_uint (node, "tunel", mp->tunnels);
2526 clib_memcpy (&ip6, mp->source_ip, sizeof (ip6));
2527 vat_json_object_add_ip6 (node, "source address", ip6);
2528 clib_memcpy (&ip6, mp->destination_ip, sizeof (ip6));
2529 vat_json_object_add_ip6 (node, "destination address", ip6);
2533 clib_memcpy (&ip4, mp->source_ip, sizeof (ip4));
2534 vat_json_object_add_ip4 (node, "source address", ip4);
2535 clib_memcpy (&ip4, mp->destination_ip, sizeof (ip4));
2536 vat_json_object_add_ip4 (node, "destination address", ip4);
2538 vat_json_object_add_uint (node, "fib encap", ntohl (mp->encap_fib_id));
2539 vat_json_object_add_uint (node, "fib decap", ntohl (mp->decap_fib_id));
2540 vat_json_object_add_string_copy (node, "decap next", next_decap_str);
2541 vat_json_object_add_uint (node, "lisp version", mp->ver_res >> 6);
2542 vat_json_object_add_uint (node, "flags", mp->flags);
2543 vat_json_object_add_uint (node, "next protocol", mp->next_protocol);
2544 vat_json_object_add_uint (node, "ver_res", mp->ver_res);
2545 vat_json_object_add_uint (node, "res", mp->res);
2546 vat_json_object_add_uint (node, "iid", ntohl (mp->iid));
2548 vec_free (next_decap_str);
2552 vl_api_show_lisp_map_register_state_reply_t_handler
2553 (vl_api_show_lisp_map_register_state_reply_t * mp)
2555 vat_main_t *vam = &vat_main;
2556 int retval = clib_net_to_host_u32 (mp->retval);
2558 fformat (vam->ofp, "%s\n", mp->is_enabled ? "enabled" : "disabled");
2560 vam->retval = retval;
2561 vam->result_ready = 1;
2565 vl_api_show_lisp_map_register_state_reply_t_handler_json
2566 (vl_api_show_lisp_map_register_state_reply_t * mp)
2568 vat_main_t *vam = &vat_main;
2569 vat_json_node_t _node, *node = &_node;
2570 int retval = clib_net_to_host_u32 (mp->retval);
2572 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2574 vat_json_init_object (node);
2575 vat_json_object_add_string_copy (node, "state", s);
2577 vat_json_print (vam->ofp, node);
2578 vat_json_free (node);
2580 vam->retval = retval;
2581 vam->result_ready = 1;
2586 vl_api_show_lisp_rloc_probe_state_reply_t_handler
2587 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2589 vat_main_t *vam = &vat_main;
2590 int retval = clib_net_to_host_u32 (mp->retval);
2595 fformat (vam->ofp, "%s\n", mp->is_enabled ? "enabled" : "disabled");
2597 vam->retval = retval;
2598 vam->result_ready = 1;
2602 vl_api_show_lisp_rloc_probe_state_reply_t_handler_json
2603 (vl_api_show_lisp_rloc_probe_state_reply_t * mp)
2605 vat_main_t *vam = &vat_main;
2606 vat_json_node_t _node, *node = &_node;
2607 int retval = clib_net_to_host_u32 (mp->retval);
2609 u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
2610 vat_json_init_object (node);
2611 vat_json_object_add_string_copy (node, "state", s);
2613 vat_json_print (vam->ofp, node);
2614 vat_json_free (node);
2616 vam->retval = retval;
2617 vam->result_ready = 1;
2622 vl_api_lisp_adjacencies_get_reply_t_handler
2623 (vl_api_lisp_adjacencies_get_reply_t * mp)
2625 vat_main_t *vam = &vat_main;
2627 int retval = clib_net_to_host_u32 (mp->retval);
2628 vl_api_lisp_adjacency_t *a;
2633 n = clib_net_to_host_u32 (mp->count);
2635 for (i = 0; i < n; i++)
2637 a = &mp->adjacencies[i];
2638 fformat (vam->ofp, "%U %40U\n",
2639 format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
2640 format_lisp_flat_eid, a->eid_type, a->reid,
2641 a->reid_prefix_len);
2645 vam->retval = retval;
2646 vam->result_ready = 1;
2650 vl_api_lisp_adjacencies_get_reply_t_handler_json
2651 (vl_api_lisp_adjacencies_get_reply_t * mp)
2654 vat_main_t *vam = &vat_main;
2655 vat_json_node_t *e = 0, root;
2657 int retval = clib_net_to_host_u32 (mp->retval);
2658 vl_api_lisp_adjacency_t *a;
2663 n = clib_net_to_host_u32 (mp->count);
2664 vat_json_init_array (&root);
2666 for (i = 0; i < n; i++)
2668 e = vat_json_array_add (&root);
2669 a = &mp->adjacencies[i];
2671 vat_json_init_object (e);
2672 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
2673 a->leid_prefix_len);
2675 vat_json_object_add_string_copy (e, "leid", s);
2678 s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
2679 a->reid_prefix_len);
2681 vat_json_object_add_string_copy (e, "reid", s);
2685 vat_json_print (vam->ofp, &root);
2686 vat_json_free (&root);
2689 vam->retval = retval;
2690 vam->result_ready = 1;
2694 vl_api_lisp_map_server_details_t_handler (vl_api_lisp_map_server_details_t
2697 vat_main_t *vam = &vat_main;
2699 fformat (vam->ofp, "%=20U\n",
2700 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2705 vl_api_lisp_map_server_details_t_handler_json
2706 (vl_api_lisp_map_server_details_t * mp)
2708 vat_main_t *vam = &vat_main;
2709 vat_json_node_t *node = NULL;
2710 struct in6_addr ip6;
2713 if (VAT_JSON_ARRAY != vam->json_tree.type)
2715 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2716 vat_json_init_array (&vam->json_tree);
2718 node = vat_json_array_add (&vam->json_tree);
2720 vat_json_init_object (node);
2723 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2724 vat_json_object_add_ip6 (node, "map-server", ip6);
2728 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2729 vat_json_object_add_ip4 (node, "map-server", ip4);
2734 vl_api_lisp_map_resolver_details_t_handler (vl_api_lisp_map_resolver_details_t
2737 vat_main_t *vam = &vat_main;
2739 fformat (vam->ofp, "%=20U\n",
2740 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2745 vl_api_lisp_map_resolver_details_t_handler_json
2746 (vl_api_lisp_map_resolver_details_t * mp)
2748 vat_main_t *vam = &vat_main;
2749 vat_json_node_t *node = NULL;
2750 struct in6_addr ip6;
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);
2763 clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
2764 vat_json_object_add_ip6 (node, "map resolver", ip6);
2768 clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
2769 vat_json_object_add_ip4 (node, "map resolver", ip4);
2774 vl_api_show_lisp_status_reply_t_handler
2775 (vl_api_show_lisp_status_reply_t * mp)
2777 vat_main_t *vam = &vat_main;
2778 i32 retval = ntohl (mp->retval);
2782 fformat (vam->ofp, "feature: %s\ngpe: %s\n",
2783 mp->feature_status ? "enabled" : "disabled",
2784 mp->gpe_status ? "enabled" : "disabled");
2787 vam->retval = retval;
2788 vam->result_ready = 1;
2792 vl_api_show_lisp_status_reply_t_handler_json
2793 (vl_api_show_lisp_status_reply_t * mp)
2795 vat_main_t *vam = &vat_main;
2796 vat_json_node_t node;
2797 u8 *gpe_status = NULL;
2798 u8 *feature_status = NULL;
2800 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2801 feature_status = format (0, "%s",
2802 mp->feature_status ? "enabled" : "disabled");
2803 vec_add1 (gpe_status, 0);
2804 vec_add1 (feature_status, 0);
2806 vat_json_init_object (&node);
2807 vat_json_object_add_string_copy (&node, "gpe_status", gpe_status);
2808 vat_json_object_add_string_copy (&node, "feature_status", feature_status);
2810 vec_free (gpe_status);
2811 vec_free (feature_status);
2813 vat_json_print (vam->ofp, &node);
2814 vat_json_free (&node);
2816 vam->retval = ntohl (mp->retval);
2817 vam->result_ready = 1;
2821 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler
2822 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2824 vat_main_t *vam = &vat_main;
2825 i32 retval = ntohl (mp->retval);
2829 fformat (vam->ofp, "%=20s\n", mp->locator_set_name);
2832 vam->retval = retval;
2833 vam->result_ready = 1;
2837 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json
2838 (vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2840 vat_main_t *vam = &vat_main;
2841 vat_json_node_t *node = NULL;
2843 if (VAT_JSON_ARRAY != vam->json_tree.type)
2845 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
2846 vat_json_init_array (&vam->json_tree);
2848 node = vat_json_array_add (&vam->json_tree);
2850 vat_json_init_object (node);
2851 vat_json_object_add_string_copy (node, "itr-rlocs", mp->locator_set_name);
2853 vat_json_print (vam->ofp, node);
2854 vat_json_free (node);
2856 vam->retval = ntohl (mp->retval);
2857 vam->result_ready = 1;
2861 format_lisp_map_request_mode (u8 * s, va_list * args)
2863 u32 mode = va_arg (*args, u32);
2868 return format (0, "dst-only");
2870 return format (0, "src-dst");
2876 vl_api_show_lisp_map_request_mode_reply_t_handler
2877 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2879 vat_main_t *vam = &vat_main;
2880 i32 retval = ntohl (mp->retval);
2884 u32 mode = mp->mode;
2885 fformat (vam->ofp, "map_request_mode: %U\n",
2886 format_lisp_map_request_mode, mode);
2889 vam->retval = retval;
2890 vam->result_ready = 1;
2894 vl_api_show_lisp_map_request_mode_reply_t_handler_json
2895 (vl_api_show_lisp_map_request_mode_reply_t * mp)
2897 vat_main_t *vam = &vat_main;
2898 vat_json_node_t node;
2903 s = format (0, "%U", format_lisp_map_request_mode, mode);
2906 vat_json_init_object (&node);
2907 vat_json_object_add_string_copy (&node, "map_request_mode", s);
2908 vat_json_print (vam->ofp, &node);
2909 vat_json_free (&node);
2912 vam->retval = ntohl (mp->retval);
2913 vam->result_ready = 1;
2917 vl_api_show_lisp_pitr_reply_t_handler (vl_api_show_lisp_pitr_reply_t * mp)
2919 vat_main_t *vam = &vat_main;
2920 i32 retval = ntohl (mp->retval);
2924 fformat (vam->ofp, "%-20s%-16s\n",
2925 mp->status ? "enabled" : "disabled",
2926 mp->status ? (char *) mp->locator_set_name : "");
2929 vam->retval = retval;
2930 vam->result_ready = 1;
2934 vl_api_show_lisp_pitr_reply_t_handler_json (vl_api_show_lisp_pitr_reply_t *
2937 vat_main_t *vam = &vat_main;
2938 vat_json_node_t node;
2941 status = format (0, "%s", mp->status ? "enabled" : "disabled");
2942 vec_add1 (status, 0);
2944 vat_json_init_object (&node);
2945 vat_json_object_add_string_copy (&node, "status", status);
2948 vat_json_object_add_string_copy (&node, "locator_set",
2949 mp->locator_set_name);
2954 vat_json_print (vam->ofp, &node);
2955 vat_json_free (&node);
2957 vam->retval = ntohl (mp->retval);
2958 vam->result_ready = 1;
2962 format_policer_type (u8 * s, va_list * va)
2964 u32 i = va_arg (*va, u32);
2966 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2967 s = format (s, "1r2c");
2968 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2969 s = format (s, "1r3c");
2970 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2971 s = format (s, "2r3c-2698");
2972 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2973 s = format (s, "2r3c-4115");
2974 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2975 s = format (s, "2r3c-mef5cf1");
2977 s = format (s, "ILLEGAL");
2982 format_policer_rate_type (u8 * s, va_list * va)
2984 u32 i = va_arg (*va, u32);
2986 if (i == SSE2_QOS_RATE_KBPS)
2987 s = format (s, "kbps");
2988 else if (i == SSE2_QOS_RATE_PPS)
2989 s = format (s, "pps");
2991 s = format (s, "ILLEGAL");
2996 format_policer_round_type (u8 * s, va_list * va)
2998 u32 i = va_arg (*va, u32);
3000 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
3001 s = format (s, "closest");
3002 else if (i == SSE2_QOS_ROUND_TO_UP)
3003 s = format (s, "up");
3004 else if (i == SSE2_QOS_ROUND_TO_DOWN)
3005 s = format (s, "down");
3007 s = format (s, "ILLEGAL");
3012 format_policer_action_type (u8 * s, va_list * va)
3014 u32 i = va_arg (*va, u32);
3016 if (i == SSE2_QOS_ACTION_DROP)
3017 s = format (s, "drop");
3018 else if (i == SSE2_QOS_ACTION_TRANSMIT)
3019 s = format (s, "transmit");
3020 else if (i == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3021 s = format (s, "mark-and-transmit");
3023 s = format (s, "ILLEGAL");
3028 format_dscp (u8 * s, va_list * va)
3030 u32 i = va_arg (*va, u32);
3035 #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
3039 return format (s, "ILLEGAL");
3041 s = format (s, "%s", t);
3046 vl_api_policer_details_t_handler (vl_api_policer_details_t * mp)
3048 vat_main_t *vam = &vat_main;
3049 u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
3051 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3052 conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3054 conform_dscp_str = format (0, "");
3056 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3057 exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3059 exceed_dscp_str = format (0, "");
3061 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3062 violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3064 violate_dscp_str = format (0, "");
3066 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
3067 "rate type %U, round type %U, %s rate, %s color-aware, "
3068 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
3069 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu"
3070 "conform action %U%s, exceed action %U%s, violate action %U%s\n",
3072 format_policer_type, mp->type,
3075 clib_net_to_host_u64 (mp->cb),
3076 clib_net_to_host_u64 (mp->eb),
3077 format_policer_rate_type, mp->rate_type,
3078 format_policer_round_type, mp->round_type,
3079 mp->single_rate ? "single" : "dual",
3080 mp->color_aware ? "is" : "not",
3081 ntohl (mp->cir_tokens_per_period),
3082 ntohl (mp->pir_tokens_per_period),
3084 ntohl (mp->current_limit),
3085 ntohl (mp->current_bucket),
3086 ntohl (mp->extended_limit),
3087 ntohl (mp->extended_bucket),
3088 clib_net_to_host_u64 (mp->last_update_time),
3089 format_policer_action_type, mp->conform_action_type,
3091 format_policer_action_type, mp->exceed_action_type,
3093 format_policer_action_type, mp->violate_action_type,
3096 vec_free (conform_dscp_str);
3097 vec_free (exceed_dscp_str);
3098 vec_free (violate_dscp_str);
3101 static void vl_api_policer_details_t_handler_json
3102 (vl_api_policer_details_t * mp)
3104 vat_main_t *vam = &vat_main;
3105 vat_json_node_t *node;
3106 u8 *rate_type_str, *round_type_str, *type_str;
3107 u8 *conform_action_str, *exceed_action_str, *violate_action_str;
3109 rate_type_str = format (0, "%U", format_policer_rate_type, mp->rate_type);
3111 format (0, "%U", format_policer_round_type, mp->round_type);
3112 type_str = format (0, "%U", format_policer_type, mp->type);
3113 conform_action_str = format (0, "%U", format_policer_action_type,
3114 mp->conform_action_type);
3115 exceed_action_str = format (0, "%U", format_policer_action_type,
3116 mp->exceed_action_type);
3117 violate_action_str = format (0, "%U", format_policer_action_type,
3118 mp->violate_action_type);
3120 if (VAT_JSON_ARRAY != vam->json_tree.type)
3122 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3123 vat_json_init_array (&vam->json_tree);
3125 node = vat_json_array_add (&vam->json_tree);
3127 vat_json_init_object (node);
3128 vat_json_object_add_string_copy (node, "name", mp->name);
3129 vat_json_object_add_uint (node, "cir", ntohl (mp->cir));
3130 vat_json_object_add_uint (node, "eir", ntohl (mp->eir));
3131 vat_json_object_add_uint (node, "cb", ntohl (mp->cb));
3132 vat_json_object_add_uint (node, "eb", ntohl (mp->eb));
3133 vat_json_object_add_string_copy (node, "rate_type", rate_type_str);
3134 vat_json_object_add_string_copy (node, "round_type", round_type_str);
3135 vat_json_object_add_string_copy (node, "type", type_str);
3136 vat_json_object_add_uint (node, "single_rate", mp->single_rate);
3137 vat_json_object_add_uint (node, "color_aware", mp->color_aware);
3138 vat_json_object_add_uint (node, "scale", ntohl (mp->scale));
3139 vat_json_object_add_uint (node, "cir_tokens_per_period",
3140 ntohl (mp->cir_tokens_per_period));
3141 vat_json_object_add_uint (node, "eir_tokens_per_period",
3142 ntohl (mp->pir_tokens_per_period));
3143 vat_json_object_add_uint (node, "current_limit", ntohl (mp->current_limit));
3144 vat_json_object_add_uint (node, "current_bucket",
3145 ntohl (mp->current_bucket));
3146 vat_json_object_add_uint (node, "extended_limit",
3147 ntohl (mp->extended_limit));
3148 vat_json_object_add_uint (node, "extended_bucket",
3149 ntohl (mp->extended_bucket));
3150 vat_json_object_add_uint (node, "last_update_time",
3151 ntohl (mp->last_update_time));
3152 vat_json_object_add_string_copy (node, "conform_action",
3153 conform_action_str);
3154 if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3156 u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
3157 vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
3158 vec_free (dscp_str);
3160 vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
3161 if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3163 u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
3164 vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
3165 vec_free (dscp_str);
3167 vat_json_object_add_string_copy (node, "violate_action",
3168 violate_action_str);
3169 if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
3171 u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
3172 vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
3173 vec_free (dscp_str);
3176 vec_free (rate_type_str);
3177 vec_free (round_type_str);
3178 vec_free (type_str);
3179 vec_free (conform_action_str);
3180 vec_free (exceed_action_str);
3181 vec_free (violate_action_str);
3185 vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t *
3188 vat_main_t *vam = &vat_main;
3189 int i, count = ntohl (mp->count);
3192 fformat (vam->ofp, "classify table ids (%d) : ", count);
3193 for (i = 0; i < count; i++)
3195 fformat (vam->ofp, "%d", ntohl (mp->ids[i]));
3196 fformat (vam->ofp, (i < count - 1) ? "," : "\n");
3198 vam->retval = ntohl (mp->retval);
3199 vam->result_ready = 1;
3203 vl_api_classify_table_ids_reply_t_handler_json
3204 (vl_api_classify_table_ids_reply_t * mp)
3206 vat_main_t *vam = &vat_main;
3207 int i, count = ntohl (mp->count);
3211 vat_json_node_t node;
3213 vat_json_init_object (&node);
3214 for (i = 0; i < count; i++)
3216 vat_json_object_add_uint (&node, "table_id", ntohl (mp->ids[i]));
3218 vat_json_print (vam->ofp, &node);
3219 vat_json_free (&node);
3221 vam->retval = ntohl (mp->retval);
3222 vam->result_ready = 1;
3226 vl_api_classify_table_by_interface_reply_t_handler
3227 (vl_api_classify_table_by_interface_reply_t * mp)
3229 vat_main_t *vam = &vat_main;
3232 table_id = ntohl (mp->l2_table_id);
3234 fformat (vam->ofp, "l2 table id : %d\n", table_id);
3236 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
3237 table_id = ntohl (mp->ip4_table_id);
3239 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
3241 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
3242 table_id = ntohl (mp->ip6_table_id);
3244 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
3246 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
3247 vam->retval = ntohl (mp->retval);
3248 vam->result_ready = 1;
3252 vl_api_classify_table_by_interface_reply_t_handler_json
3253 (vl_api_classify_table_by_interface_reply_t * mp)
3255 vat_main_t *vam = &vat_main;
3256 vat_json_node_t node;
3258 vat_json_init_object (&node);
3260 vat_json_object_add_int (&node, "l2_table_id", ntohl (mp->l2_table_id));
3261 vat_json_object_add_int (&node, "ip4_table_id", ntohl (mp->ip4_table_id));
3262 vat_json_object_add_int (&node, "ip6_table_id", ntohl (mp->ip6_table_id));
3264 vat_json_print (vam->ofp, &node);
3265 vat_json_free (&node);
3267 vam->retval = ntohl (mp->retval);
3268 vam->result_ready = 1;
3271 static void vl_api_policer_add_del_reply_t_handler
3272 (vl_api_policer_add_del_reply_t * mp)
3274 vat_main_t *vam = &vat_main;
3275 i32 retval = ntohl (mp->retval);
3276 if (vam->async_mode)
3278 vam->async_errors += (retval < 0);
3282 vam->retval = retval;
3283 vam->result_ready = 1;
3284 if (retval == 0 && mp->policer_index != 0xFFFFFFFF)
3286 * Note: this is just barely thread-safe, depends on
3287 * the main thread spinning waiting for an answer...
3289 errmsg ("policer index %d\n", ntohl (mp->policer_index));
3293 static void vl_api_policer_add_del_reply_t_handler_json
3294 (vl_api_policer_add_del_reply_t * mp)
3296 vat_main_t *vam = &vat_main;
3297 vat_json_node_t node;
3299 vat_json_init_object (&node);
3300 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3301 vat_json_object_add_uint (&node, "policer_index",
3302 ntohl (mp->policer_index));
3304 vat_json_print (vam->ofp, &node);
3305 vat_json_free (&node);
3307 vam->retval = ntohl (mp->retval);
3308 vam->result_ready = 1;
3311 /* Format hex dump. */
3313 format_hex_bytes (u8 * s, va_list * va)
3315 u8 *bytes = va_arg (*va, u8 *);
3316 int n_bytes = va_arg (*va, int);
3319 /* Print short or long form depending on byte count. */
3320 uword short_form = n_bytes <= 32;
3321 uword indent = format_get_indent (s);
3326 for (i = 0; i < n_bytes; i++)
3328 if (!short_form && (i % 32) == 0)
3329 s = format (s, "%08x: ", i);
3330 s = format (s, "%02x", bytes[i]);
3331 if (!short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
3332 s = format (s, "\n%U", format_white_space, indent);
3339 vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t
3342 vat_main_t *vam = &vat_main;
3343 i32 retval = ntohl (mp->retval);
3346 fformat (vam->ofp, "classify table info :\n");
3347 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n",
3348 ntohl (mp->active_sessions), ntohl (mp->next_table_index),
3349 ntohl (mp->miss_next_index));
3350 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n",
3351 ntohl (mp->nbuckets), ntohl (mp->skip_n_vectors),
3352 ntohl (mp->match_n_vectors));
3353 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask,
3354 ntohl (mp->mask_length));
3356 vam->retval = retval;
3357 vam->result_ready = 1;
3361 vl_api_classify_table_info_reply_t_handler_json
3362 (vl_api_classify_table_info_reply_t * mp)
3364 vat_main_t *vam = &vat_main;
3365 vat_json_node_t node;
3367 i32 retval = ntohl (mp->retval);
3370 vat_json_init_object (&node);
3372 vat_json_object_add_int (&node, "sessions",
3373 ntohl (mp->active_sessions));
3374 vat_json_object_add_int (&node, "nexttbl",
3375 ntohl (mp->next_table_index));
3376 vat_json_object_add_int (&node, "nextnode",
3377 ntohl (mp->miss_next_index));
3378 vat_json_object_add_int (&node, "nbuckets", ntohl (mp->nbuckets));
3379 vat_json_object_add_int (&node, "skip", ntohl (mp->skip_n_vectors));
3380 vat_json_object_add_int (&node, "match", ntohl (mp->match_n_vectors));
3381 u8 *s = format (0, "%U%c", format_hex_bytes, mp->mask,
3382 ntohl (mp->mask_length), 0);
3383 vat_json_object_add_string_copy (&node, "mask", s);
3385 vat_json_print (vam->ofp, &node);
3386 vat_json_free (&node);
3388 vam->retval = ntohl (mp->retval);
3389 vam->result_ready = 1;
3393 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
3396 vat_main_t *vam = &vat_main;
3398 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ",
3399 ntohl (mp->hit_next_index), ntohl (mp->advance),
3400 ntohl (mp->opaque_index));
3401 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match,
3402 ntohl (mp->match_length));
3406 vl_api_classify_session_details_t_handler_json
3407 (vl_api_classify_session_details_t * mp)
3409 vat_main_t *vam = &vat_main;
3410 vat_json_node_t *node = NULL;
3412 if (VAT_JSON_ARRAY != vam->json_tree.type)
3414 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3415 vat_json_init_array (&vam->json_tree);
3417 node = vat_json_array_add (&vam->json_tree);
3419 vat_json_init_object (node);
3420 vat_json_object_add_int (node, "next_index", ntohl (mp->hit_next_index));
3421 vat_json_object_add_int (node, "advance", ntohl (mp->advance));
3422 vat_json_object_add_int (node, "opaque", ntohl (mp->opaque_index));
3424 format (0, "%U%c", format_hex_bytes, mp->match, ntohl (mp->match_length),
3426 vat_json_object_add_string_copy (node, "match", s);
3429 static void vl_api_pg_create_interface_reply_t_handler
3430 (vl_api_pg_create_interface_reply_t * mp)
3432 vat_main_t *vam = &vat_main;
3434 vam->retval = ntohl (mp->retval);
3435 vam->result_ready = 1;
3438 static void vl_api_pg_create_interface_reply_t_handler_json
3439 (vl_api_pg_create_interface_reply_t * mp)
3441 vat_main_t *vam = &vat_main;
3442 vat_json_node_t node;
3444 i32 retval = ntohl (mp->retval);
3447 vat_json_init_object (&node);
3449 vat_json_object_add_int (&node, "sw_if_index", ntohl (mp->sw_if_index));
3451 vat_json_print (vam->ofp, &node);
3452 vat_json_free (&node);
3454 vam->retval = ntohl (mp->retval);
3455 vam->result_ready = 1;
3458 static void vl_api_policer_classify_details_t_handler
3459 (vl_api_policer_classify_details_t * mp)
3461 vat_main_t *vam = &vat_main;
3463 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3464 ntohl (mp->table_index));
3467 static void vl_api_policer_classify_details_t_handler_json
3468 (vl_api_policer_classify_details_t * mp)
3470 vat_main_t *vam = &vat_main;
3471 vat_json_node_t *node;
3473 if (VAT_JSON_ARRAY != vam->json_tree.type)
3475 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3476 vat_json_init_array (&vam->json_tree);
3478 node = vat_json_array_add (&vam->json_tree);
3480 vat_json_init_object (node);
3481 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3482 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3485 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler
3486 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3488 vat_main_t *vam = &vat_main;
3489 i32 retval = ntohl (mp->retval);
3490 if (vam->async_mode)
3492 vam->async_errors += (retval < 0);
3496 vam->retval = retval;
3497 vam->sw_if_index = ntohl (mp->sw_if_index);
3498 vam->result_ready = 1;
3502 static void vl_api_ipsec_gre_add_del_tunnel_reply_t_handler_json
3503 (vl_api_ipsec_gre_add_del_tunnel_reply_t * mp)
3505 vat_main_t *vam = &vat_main;
3506 vat_json_node_t node;
3508 vat_json_init_object (&node);
3509 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
3510 vat_json_object_add_uint (&node, "sw_if_index", ntohl (mp->sw_if_index));
3512 vat_json_print (vam->ofp, &node);
3513 vat_json_free (&node);
3515 vam->retval = ntohl (mp->retval);
3516 vam->result_ready = 1;
3519 static void vl_api_flow_classify_details_t_handler
3520 (vl_api_flow_classify_details_t * mp)
3522 vat_main_t *vam = &vat_main;
3524 fformat (vam->ofp, "%10d%20d\n", ntohl (mp->sw_if_index),
3525 ntohl (mp->table_index));
3528 static void vl_api_flow_classify_details_t_handler_json
3529 (vl_api_flow_classify_details_t * mp)
3531 vat_main_t *vam = &vat_main;
3532 vat_json_node_t *node;
3534 if (VAT_JSON_ARRAY != vam->json_tree.type)
3536 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
3537 vat_json_init_array (&vam->json_tree);
3539 node = vat_json_array_add (&vam->json_tree);
3541 vat_json_init_object (node);
3542 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
3543 vat_json_object_add_uint (node, "table_index", ntohl (mp->table_index));
3548 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
3549 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
3550 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
3551 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
3552 #define vl_api_lisp_adjacencies_get_reply_t_endian vl_noop_handler
3553 #define vl_api_lisp_adjacencies_get_reply_t_print vl_noop_handler
3556 * Generate boilerplate reply handlers, which
3557 * dig the return value out of the xxx_reply_t API message,
3558 * stick it into vam->retval, and set vam->result_ready
3560 * Could also do this by pointing N message decode slots at
3561 * a single function, but that could break in subtle ways.
3564 #define foreach_standard_reply_retval_handler \
3565 _(sw_interface_set_flags_reply) \
3566 _(sw_interface_add_del_address_reply) \
3567 _(sw_interface_set_table_reply) \
3568 _(sw_interface_set_mpls_enable_reply) \
3569 _(sw_interface_set_vpath_reply) \
3570 _(sw_interface_set_vxlan_bypass_reply) \
3571 _(sw_interface_set_l2_bridge_reply) \
3572 _(sw_interface_set_dpdk_hqos_pipe_reply) \
3573 _(sw_interface_set_dpdk_hqos_subport_reply) \
3574 _(sw_interface_set_dpdk_hqos_tctbl_reply) \
3575 _(bridge_domain_add_del_reply) \
3576 _(sw_interface_set_l2_xconnect_reply) \
3577 _(l2fib_add_del_reply) \
3578 _(ip_add_del_route_reply) \
3579 _(mpls_route_add_del_reply) \
3580 _(mpls_ip_bind_unbind_reply) \
3581 _(proxy_arp_add_del_reply) \
3582 _(proxy_arp_intfc_enable_disable_reply) \
3583 _(sw_interface_set_unnumbered_reply) \
3584 _(ip_neighbor_add_del_reply) \
3585 _(reset_vrf_reply) \
3586 _(oam_add_del_reply) \
3587 _(reset_fib_reply) \
3588 _(dhcp_proxy_config_reply) \
3589 _(dhcp_proxy_config_2_reply) \
3590 _(dhcp_proxy_set_vss_reply) \
3591 _(dhcp_client_config_reply) \
3592 _(set_ip_flow_hash_reply) \
3593 _(sw_interface_ip6_enable_disable_reply) \
3594 _(sw_interface_ip6_set_link_local_address_reply) \
3595 _(sw_interface_ip6nd_ra_prefix_reply) \
3596 _(sw_interface_ip6nd_ra_config_reply) \
3597 _(set_arp_neighbor_limit_reply) \
3598 _(l2_patch_add_del_reply) \
3599 _(sr_tunnel_add_del_reply) \
3600 _(sr_policy_add_del_reply) \
3601 _(sr_multicast_map_add_del_reply) \
3602 _(classify_add_del_session_reply) \
3603 _(classify_set_interface_ip_table_reply) \
3604 _(classify_set_interface_l2_tables_reply) \
3605 _(l2tpv3_set_tunnel_cookies_reply) \
3606 _(l2tpv3_interface_enable_disable_reply) \
3607 _(l2tpv3_set_lookup_key_reply) \
3608 _(l2_fib_clear_table_reply) \
3609 _(l2_interface_efp_filter_reply) \
3610 _(l2_interface_vlan_tag_rewrite_reply) \
3611 _(modify_vhost_user_if_reply) \
3612 _(delete_vhost_user_if_reply) \
3613 _(want_ip4_arp_events_reply) \
3614 _(want_ip6_nd_events_reply) \
3615 _(input_acl_set_interface_reply) \
3616 _(ipsec_spd_add_del_reply) \
3617 _(ipsec_interface_add_del_spd_reply) \
3618 _(ipsec_spd_add_del_entry_reply) \
3619 _(ipsec_sad_add_del_entry_reply) \
3620 _(ipsec_sa_set_key_reply) \
3621 _(ikev2_profile_add_del_reply) \
3622 _(ikev2_profile_set_auth_reply) \
3623 _(ikev2_profile_set_id_reply) \
3624 _(ikev2_profile_set_ts_reply) \
3625 _(ikev2_set_local_key_reply) \
3626 _(delete_loopback_reply) \
3627 _(bd_ip_mac_add_del_reply) \
3628 _(map_del_domain_reply) \
3629 _(map_add_del_rule_reply) \
3630 _(want_interface_events_reply) \
3631 _(want_stats_reply) \
3632 _(cop_interface_enable_disable_reply) \
3633 _(cop_whitelist_enable_disable_reply) \
3634 _(sw_interface_clear_stats_reply) \
3635 _(ioam_enable_reply) \
3636 _(ioam_disable_reply) \
3637 _(lisp_add_del_locator_reply) \
3638 _(lisp_add_del_local_eid_reply) \
3639 _(lisp_add_del_remote_mapping_reply) \
3640 _(lisp_add_del_adjacency_reply) \
3641 _(lisp_gpe_add_del_fwd_entry_reply) \
3642 _(lisp_add_del_map_resolver_reply) \
3643 _(lisp_add_del_map_server_reply) \
3644 _(lisp_gpe_enable_disable_reply) \
3645 _(lisp_gpe_add_del_iface_reply) \
3646 _(lisp_enable_disable_reply) \
3647 _(lisp_rloc_probe_enable_disable_reply) \
3648 _(lisp_map_register_enable_disable_reply) \
3649 _(lisp_pitr_set_locator_set_reply) \
3650 _(lisp_map_request_mode_reply) \
3651 _(lisp_add_del_map_request_itr_rlocs_reply) \
3652 _(lisp_eid_table_add_del_map_reply) \
3653 _(vxlan_gpe_add_del_tunnel_reply) \
3654 _(af_packet_delete_reply) \
3655 _(policer_classify_set_interface_reply) \
3656 _(netmap_create_reply) \
3657 _(netmap_delete_reply) \
3658 _(set_ipfix_exporter_reply) \
3659 _(set_ipfix_classify_stream_reply) \
3660 _(ipfix_classify_table_add_del_reply) \
3661 _(flow_classify_set_interface_reply) \
3662 _(sw_interface_span_enable_disable_reply) \
3663 _(pg_capture_reply) \
3664 _(pg_enable_disable_reply) \
3665 _(ip_source_and_port_range_check_add_del_reply) \
3666 _(ip_source_and_port_range_check_interface_add_del_reply)\
3667 _(delete_subif_reply) \
3668 _(l2_interface_pbb_tag_rewrite_reply) \
3670 _(feature_enable_disable_reply) \
3671 _(sw_interface_tag_add_del_reply) \
3672 _(sw_interface_set_mtu_reply)
3675 static void vl_api_##n##_t_handler \
3676 (vl_api_##n##_t * mp) \
3678 vat_main_t * vam = &vat_main; \
3679 i32 retval = ntohl(mp->retval); \
3680 if (vam->async_mode) { \
3681 vam->async_errors += (retval < 0); \
3683 vam->retval = retval; \
3684 vam->result_ready = 1; \
3687 foreach_standard_reply_retval_handler;
3691 static void vl_api_##n##_t_handler_json \
3692 (vl_api_##n##_t * mp) \
3694 vat_main_t * vam = &vat_main; \
3695 vat_json_node_t node; \
3696 vat_json_init_object(&node); \
3697 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
3698 vat_json_print(vam->ofp, &node); \
3699 vam->retval = ntohl(mp->retval); \
3700 vam->result_ready = 1; \
3702 foreach_standard_reply_retval_handler;
3706 * Table of message reply handlers, must include boilerplate handlers
3710 #define foreach_vpe_api_reply_msg \
3711 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
3712 _(SW_INTERFACE_DETAILS, sw_interface_details) \
3713 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
3714 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
3715 _(CONTROL_PING_REPLY, control_ping_reply) \
3716 _(CLI_REPLY, cli_reply) \
3717 _(CLI_INBAND_REPLY, cli_inband_reply) \
3718 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
3719 sw_interface_add_del_address_reply) \
3720 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
3721 _(SW_INTERFACE_SET_MPLS_ENABLE_REPLY, sw_interface_set_mpls_enable_reply) \
3722 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
3723 _(SW_INTERFACE_SET_VXLAN_BYPASS_REPLY, sw_interface_set_vxlan_bypass_reply) \
3724 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
3725 sw_interface_set_l2_xconnect_reply) \
3726 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
3727 sw_interface_set_l2_bridge_reply) \
3728 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY, \
3729 sw_interface_set_dpdk_hqos_pipe_reply) \
3730 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY, \
3731 sw_interface_set_dpdk_hqos_subport_reply) \
3732 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY, \
3733 sw_interface_set_dpdk_hqos_tctbl_reply) \
3734 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
3735 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
3736 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
3737 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
3738 _(L2_FLAGS_REPLY, l2_flags_reply) \
3739 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
3740 _(TAP_CONNECT_REPLY, tap_connect_reply) \
3741 _(TAP_MODIFY_REPLY, tap_modify_reply) \
3742 _(TAP_DELETE_REPLY, tap_delete_reply) \
3743 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
3744 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
3745 _(MPLS_ROUTE_ADD_DEL_REPLY, mpls_route_add_del_reply) \
3746 _(MPLS_IP_BIND_UNBIND_REPLY, mpls_ip_bind_unbind_reply) \
3747 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
3748 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
3749 proxy_arp_intfc_enable_disable_reply) \
3750 _(MPLS_TUNNEL_ADD_DEL_REPLY, mpls_tunnel_add_del_reply) \
3751 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
3752 sw_interface_set_unnumbered_reply) \
3753 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
3754 _(RESET_VRF_REPLY, reset_vrf_reply) \
3755 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
3756 _(CREATE_SUBIF_REPLY, create_subif_reply) \
3757 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
3758 _(RESET_FIB_REPLY, reset_fib_reply) \
3759 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
3760 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
3761 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
3762 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
3763 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
3764 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
3765 sw_interface_ip6_enable_disable_reply) \
3766 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
3767 sw_interface_ip6_set_link_local_address_reply) \
3768 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
3769 sw_interface_ip6nd_ra_prefix_reply) \
3770 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
3771 sw_interface_ip6nd_ra_config_reply) \
3772 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
3773 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
3774 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
3775 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
3776 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
3777 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
3778 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
3779 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
3780 classify_set_interface_ip_table_reply) \
3781 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
3782 classify_set_interface_l2_tables_reply) \
3783 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
3784 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
3785 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
3786 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
3787 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
3788 l2tpv3_interface_enable_disable_reply) \
3789 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
3790 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
3791 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
3792 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
3793 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
3794 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
3795 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
3796 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
3797 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
3798 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
3799 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
3800 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
3801 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
3802 _(SHOW_VERSION_REPLY, show_version_reply) \
3803 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
3804 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
3805 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
3806 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
3807 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
3808 _(IP4_ARP_EVENT, ip4_arp_event) \
3809 _(WANT_IP6_ND_EVENTS_REPLY, want_ip6_nd_events_reply) \
3810 _(IP6_ND_EVENT, ip6_nd_event) \
3811 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
3812 _(IP_ADDRESS_DETAILS, ip_address_details) \
3813 _(IP_DETAILS, ip_details) \
3814 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
3815 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
3816 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
3817 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
3818 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
3819 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
3820 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
3821 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
3822 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
3823 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
3824 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
3825 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
3826 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
3827 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
3828 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
3829 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
3830 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
3831 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
3832 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
3833 _(MAP_DOMAIN_DETAILS, map_domain_details) \
3834 _(MAP_RULE_DETAILS, map_rule_details) \
3835 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
3836 _(WANT_STATS_REPLY, want_stats_reply) \
3837 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
3838 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
3839 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
3840 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
3841 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
3842 _(IOAM_ENABLE_REPLY, ioam_enable_reply) \
3843 _(IOAM_DISABLE_REPLY, ioam_disable_reply) \
3844 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
3845 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
3846 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
3847 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
3848 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
3849 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
3850 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
3851 _(LISP_ADD_DEL_MAP_SERVER_REPLY, lisp_add_del_map_server_reply) \
3852 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
3853 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
3854 _(LISP_MAP_REGISTER_ENABLE_DISABLE_REPLY, \
3855 lisp_map_register_enable_disable_reply) \
3856 _(LISP_RLOC_PROBE_ENABLE_DISABLE_REPLY, \
3857 lisp_rloc_probe_enable_disable_reply) \
3858 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
3859 _(LISP_MAP_REQUEST_MODE_REPLY, lisp_map_request_mode_reply) \
3860 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
3861 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
3862 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
3863 _(LISP_LOCATOR_DETAILS, lisp_locator_details) \
3864 _(LISP_EID_TABLE_DETAILS, lisp_eid_table_details) \
3865 _(LISP_EID_TABLE_MAP_DETAILS, lisp_eid_table_map_details) \
3866 _(LISP_EID_TABLE_VNI_DETAILS, lisp_eid_table_vni_details) \
3867 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
3868 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
3869 _(LISP_MAP_SERVER_DETAILS, lisp_map_server_details) \
3870 _(LISP_ADJACENCIES_GET_REPLY, lisp_adjacencies_get_reply) \
3871 _(SHOW_LISP_STATUS_REPLY, show_lisp_status_reply) \
3872 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
3873 lisp_add_del_map_request_itr_rlocs_reply) \
3874 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
3875 lisp_get_map_request_itr_rlocs_reply) \
3876 _(SHOW_LISP_PITR_REPLY, show_lisp_pitr_reply) \
3877 _(SHOW_LISP_MAP_REQUEST_MODE_REPLY, show_lisp_map_request_mode_reply) \
3878 _(SHOW_LISP_RLOC_PROBE_STATE_REPLY, show_lisp_rloc_probe_state_reply) \
3879 _(SHOW_LISP_MAP_REGISTER_STATE_REPLY, \
3880 show_lisp_map_register_state_reply) \
3881 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
3882 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
3883 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
3884 _(POLICER_DETAILS, policer_details) \
3885 _(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
3886 _(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
3887 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
3888 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
3889 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
3890 _(MPLS_FIB_DETAILS, mpls_fib_details) \
3891 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
3892 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
3893 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
3894 _(CLASSIFY_SESSION_DETAILS, classify_session_details) \
3895 _(SET_IPFIX_EXPORTER_REPLY, set_ipfix_exporter_reply) \
3896 _(IPFIX_EXPORTER_DETAILS, ipfix_exporter_details) \
3897 _(SET_IPFIX_CLASSIFY_STREAM_REPLY, set_ipfix_classify_stream_reply) \
3898 _(IPFIX_CLASSIFY_STREAM_DETAILS, ipfix_classify_stream_details) \
3899 _(IPFIX_CLASSIFY_TABLE_ADD_DEL_REPLY, ipfix_classify_table_add_del_reply) \
3900 _(IPFIX_CLASSIFY_TABLE_DETAILS, ipfix_classify_table_details) \
3901 _(FLOW_CLASSIFY_SET_INTERFACE_REPLY, flow_classify_set_interface_reply) \
3902 _(FLOW_CLASSIFY_DETAILS, flow_classify_details) \
3903 _(SW_INTERFACE_SPAN_ENABLE_DISABLE_REPLY, sw_interface_span_enable_disable_reply) \
3904 _(SW_INTERFACE_SPAN_DETAILS, sw_interface_span_details) \
3905 _(GET_NEXT_INDEX_REPLY, get_next_index_reply) \
3906 _(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
3907 _(PG_CAPTURE_REPLY, pg_capture_reply) \
3908 _(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
3909 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
3910 ip_source_and_port_range_check_add_del_reply) \
3911 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
3912 ip_source_and_port_range_check_interface_add_del_reply) \
3913 _(IPSEC_GRE_ADD_DEL_TUNNEL_REPLY, ipsec_gre_add_del_tunnel_reply) \
3914 _(IPSEC_GRE_TUNNEL_DETAILS, ipsec_gre_tunnel_details) \
3915 _(DELETE_SUBIF_REPLY, delete_subif_reply) \
3916 _(L2_INTERFACE_PBB_TAG_REWRITE_REPLY, l2_interface_pbb_tag_rewrite_reply) \
3917 _(PUNT_REPLY, punt_reply) \
3918 _(IP_FIB_DETAILS, ip_fib_details) \
3919 _(IP6_FIB_DETAILS, ip6_fib_details) \
3920 _(FEATURE_ENABLE_DISABLE_REPLY, feature_enable_disable_reply) \
3921 _(SW_INTERFACE_TAG_ADD_DEL_REPLY, sw_interface_tag_add_del_reply) \
3922 _(L2_XCONNECT_DETAILS, l2_xconnect_details) \
3923 _(SW_INTERFACE_SET_MTU_REPLY, sw_interface_set_mtu_reply) \
3924 _(IP_NEIGHBOR_DETAILS, ip_neighbor_details) \
3925 _(SW_INTERFACE_GET_TABLE_REPLY, sw_interface_get_table_reply)
3927 /* M: construct, but don't yet send a message */
3931 vam->result_ready = 0; \
3932 mp = vl_msg_api_alloc(sizeof(*mp)); \
3933 memset (mp, 0, sizeof (*mp)); \
3934 mp->_vl_msg_id = ntohs (VL_API_##T); \
3935 mp->client_index = vam->my_client_index; \
3940 vam->result_ready = 0; \
3941 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
3942 memset (mp, 0, sizeof (*mp)); \
3943 mp->_vl_msg_id = ntohs (VL_API_##T); \
3944 mp->client_index = vam->my_client_index; \
3948 /* S: send a message */
3949 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
3951 /* W: wait for results, with timeout */
3954 timeout = vat_time_now (vam) + 1.0; \
3956 while (vat_time_now (vam) < timeout) { \
3957 if (vam->result_ready == 1) { \
3958 return (vam->retval); \
3964 /* W2: wait for results, with timeout */
3967 timeout = vat_time_now (vam) + 1.0; \
3969 while (vat_time_now (vam) < timeout) { \
3970 if (vam->result_ready == 1) { \
3972 return (vam->retval); \
3985 #define STR_VTR_OP_CASE(op) \
3986 case L2_VTR_ ## op: \
3990 str_vtr_op (u32 vtr_op)
3994 STR_VTR_OP_CASE (DISABLED);
3995 STR_VTR_OP_CASE (PUSH_1);
3996 STR_VTR_OP_CASE (PUSH_2);
3997 STR_VTR_OP_CASE (POP_1);
3998 STR_VTR_OP_CASE (POP_2);
3999 STR_VTR_OP_CASE (TRANSLATE_1_1);
4000 STR_VTR_OP_CASE (TRANSLATE_1_2);
4001 STR_VTR_OP_CASE (TRANSLATE_2_1);
4002 STR_VTR_OP_CASE (TRANSLATE_2_2);
4009 dump_sub_interface_table (vat_main_t * vam)
4011 const sw_interface_subif_t *sub = NULL;
4013 if (vam->json_output)
4016 ("JSON output supported only for VPE API calls and dump_stats_table");
4021 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
4022 "Interface", "sw_if_index",
4023 "sub id", "dot1ad", "tags", "outer id",
4024 "inner id", "exact", "default", "outer any", "inner any");
4026 vec_foreach (sub, vam->sw_if_subif_table)
4029 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
4030 sub->interface_name,
4032 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
4033 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
4034 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
4035 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
4036 if (sub->vtr_op != L2_VTR_DISABLED)
4039 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
4040 "tag1: %d tag2: %d ]\n",
4041 str_vtr_op (sub->vtr_op), sub->vtr_push_dot1q,
4042 sub->vtr_tag1, sub->vtr_tag2);
4050 name_sort_cmp (void *a1, void *a2)
4052 name_sort_t *n1 = a1;
4053 name_sort_t *n2 = a2;
4055 return strcmp ((char *) n1->name, (char *) n2->name);
4059 dump_interface_table (vat_main_t * vam)
4062 name_sort_t *nses = 0, *ns;
4064 if (vam->json_output)
4067 ("JSON output supported only for VPE API calls and dump_stats_table");
4072 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4074 vec_add2 (nses, ns, 1);
4075 ns->name = (u8 *)(p->key);
4076 ns->value = (u32) p->value[0];
4080 vec_sort_with_function (nses, name_sort_cmp);
4082 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
4083 vec_foreach (ns, nses)
4085 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
4092 dump_ip_table (vat_main_t * vam, int is_ipv6)
4094 const ip_details_t *det = NULL;
4095 const ip_address_details_t *address = NULL;
4098 fformat (vam->ofp, "%-12s\n", "sw_if_index");
4100 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6])
4107 fformat (vam->ofp, "%-12d\n", i);
4109 " %-30s%-13s\n", "Address", "Prefix length");
4114 vec_foreach (address, det->addr)
4118 is_ipv6 ? format_ip6_address : format_ip4_address,
4119 address->ip, address->prefix_length);
4127 dump_ipv4_table (vat_main_t * vam)
4129 if (vam->json_output)
4132 ("JSON output supported only for VPE API calls and dump_stats_table");
4136 return dump_ip_table (vam, 0);
4140 dump_ipv6_table (vat_main_t * vam)
4142 if (vam->json_output)
4145 ("JSON output supported only for VPE API calls and dump_stats_table");
4149 return dump_ip_table (vam, 1);
4153 counter_type_to_str (u8 counter_type, u8 is_combined)
4157 switch (counter_type)
4159 case VNET_INTERFACE_COUNTER_DROP:
4161 case VNET_INTERFACE_COUNTER_PUNT:
4163 case VNET_INTERFACE_COUNTER_IP4:
4165 case VNET_INTERFACE_COUNTER_IP6:
4167 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
4169 case VNET_INTERFACE_COUNTER_RX_MISS:
4171 case VNET_INTERFACE_COUNTER_RX_ERROR:
4173 case VNET_INTERFACE_COUNTER_TX_ERROR:
4176 return "INVALID-COUNTER-TYPE";
4181 switch (counter_type)
4183 case VNET_INTERFACE_COUNTER_RX:
4185 case VNET_INTERFACE_COUNTER_TX:
4188 return "INVALID-COUNTER-TYPE";
4194 dump_stats_table (vat_main_t * vam)
4196 vat_json_node_t node;
4197 vat_json_node_t *msg_array;
4198 vat_json_node_t *msg;
4199 vat_json_node_t *counter_array;
4200 vat_json_node_t *counter;
4201 interface_counter_t c;
4203 ip4_fib_counter_t *c4;
4204 ip6_fib_counter_t *c6;
4207 if (!vam->json_output)
4209 clib_warning ("dump_stats_table supported only in JSON format");
4213 vat_json_init_object (&node);
4215 /* interface counters */
4216 msg_array = vat_json_object_add (&node, "interface_counters");
4217 vat_json_init_array (msg_array);
4218 for (i = 0; i < vec_len (vam->simple_interface_counters); i++)
4220 msg = vat_json_array_add (msg_array);
4221 vat_json_init_object (msg);
4222 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4223 (u8 *) counter_type_to_str (i, 0));
4224 vat_json_object_add_int (msg, "is_combined", 0);
4225 counter_array = vat_json_object_add (msg, "data");
4226 vat_json_init_array (counter_array);
4227 for (j = 0; j < vec_len (vam->simple_interface_counters[i]); j++)
4229 packets = vam->simple_interface_counters[i][j];
4230 vat_json_array_add_uint (counter_array, packets);
4233 for (i = 0; i < vec_len (vam->combined_interface_counters); i++)
4235 msg = vat_json_array_add (msg_array);
4236 vat_json_init_object (msg);
4237 vat_json_object_add_string_copy (msg, "vnet_counter_type",
4238 (u8 *) counter_type_to_str (i, 1));
4239 vat_json_object_add_int (msg, "is_combined", 1);
4240 counter_array = vat_json_object_add (msg, "data");
4241 vat_json_init_array (counter_array);
4242 for (j = 0; j < vec_len (vam->combined_interface_counters[i]); j++)
4244 c = vam->combined_interface_counters[i][j];
4245 counter = vat_json_array_add (counter_array);
4246 vat_json_init_object (counter);
4247 vat_json_object_add_uint (counter, "packets", c.packets);
4248 vat_json_object_add_uint (counter, "bytes", c.bytes);
4252 /* ip4 fib counters */
4253 msg_array = vat_json_object_add (&node, "ip4_fib_counters");
4254 vat_json_init_array (msg_array);
4255 for (i = 0; i < vec_len (vam->ip4_fib_counters); i++)
4257 msg = vat_json_array_add (msg_array);
4258 vat_json_init_object (msg);
4259 vat_json_object_add_uint (msg, "vrf_id",
4260 vam->ip4_fib_counters_vrf_id_by_index[i]);
4261 counter_array = vat_json_object_add (msg, "c");
4262 vat_json_init_array (counter_array);
4263 for (j = 0; j < vec_len (vam->ip4_fib_counters[i]); j++)
4265 counter = vat_json_array_add (counter_array);
4266 vat_json_init_object (counter);
4267 c4 = &vam->ip4_fib_counters[i][j];
4268 vat_json_object_add_ip4 (counter, "address", c4->address);
4269 vat_json_object_add_uint (counter, "address_length",
4270 c4->address_length);
4271 vat_json_object_add_uint (counter, "packets", c4->packets);
4272 vat_json_object_add_uint (counter, "bytes", c4->bytes);
4276 /* ip6 fib counters */
4277 msg_array = vat_json_object_add (&node, "ip6_fib_counters");
4278 vat_json_init_array (msg_array);
4279 for (i = 0; i < vec_len (vam->ip6_fib_counters); i++)
4281 msg = vat_json_array_add (msg_array);
4282 vat_json_init_object (msg);
4283 vat_json_object_add_uint (msg, "vrf_id",
4284 vam->ip6_fib_counters_vrf_id_by_index[i]);
4285 counter_array = vat_json_object_add (msg, "c");
4286 vat_json_init_array (counter_array);
4287 for (j = 0; j < vec_len (vam->ip6_fib_counters[i]); j++)
4289 counter = vat_json_array_add (counter_array);
4290 vat_json_init_object (counter);
4291 c6 = &vam->ip6_fib_counters[i][j];
4292 vat_json_object_add_ip6 (counter, "address", c6->address);
4293 vat_json_object_add_uint (counter, "address_length",
4294 c6->address_length);
4295 vat_json_object_add_uint (counter, "packets", c6->packets);
4296 vat_json_object_add_uint (counter, "bytes", c6->bytes);
4300 vat_json_print (vam->ofp, &node);
4301 vat_json_free (&node);
4307 exec (vat_main_t * vam)
4309 api_main_t *am = &api_main;
4310 vl_api_cli_request_t *mp;
4314 unformat_input_t *i = vam->input;
4316 if (vec_len (i->buffer) == 0)
4319 if (vam->exec_mode == 0 && unformat (i, "mode"))
4324 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4331 M (CLI_REQUEST, cli_request);
4334 * Copy cmd into shared memory.
4335 * In order for the CLI command to work, it
4336 * must be a vector ending in \n, not a C-string ending
4339 pthread_mutex_lock (&am->vlib_rp->mutex);
4340 oldheap = svm_push_data_heap (am->vlib_rp);
4342 vec_validate (cmd, vec_len (vam->input->buffer) - 1);
4343 clib_memcpy (cmd, vam->input->buffer, vec_len (vam->input->buffer));
4345 svm_pop_heap (oldheap);
4346 pthread_mutex_unlock (&am->vlib_rp->mutex);
4348 mp->cmd_in_shmem = (u64) cmd;
4350 timeout = vat_time_now (vam) + 10.0;
4352 while (vat_time_now (vam) < timeout)
4354 if (vam->result_ready == 1)
4357 if (vam->shmem_result != NULL)
4358 fformat (vam->ofp, "%s", vam->shmem_result);
4359 pthread_mutex_lock (&am->vlib_rp->mutex);
4360 oldheap = svm_push_data_heap (am->vlib_rp);
4362 free_me = (u8 *) vam->shmem_result;
4365 svm_pop_heap (oldheap);
4366 pthread_mutex_unlock (&am->vlib_rp->mutex);
4374 * Future replacement of exec() that passes CLI buffers directly in
4375 * the API messages instead of an additional shared memory area.
4378 exec_inband (vat_main_t * vam)
4380 vl_api_cli_inband_t *mp;
4382 unformat_input_t *i = vam->input;
4384 if (vec_len (i->buffer) == 0)
4387 if (vam->exec_mode == 0 && unformat (i, "mode"))
4392 if (vam->exec_mode == 1 && (unformat (i, "exit") || unformat (i, "quit")))
4399 * In order for the CLI command to work, it
4400 * must be a vector ending in \n, not a C-string ending
4403 u32 len = vec_len (vam->input->buffer);
4404 M2 (CLI_INBAND, cli_inband, len);
4405 clib_memcpy (mp->cmd, vam->input->buffer, len);
4406 mp->length = htonl (len);
4409 W2 (fformat (vam->ofp, "%s", vam->cmd_reply));
4413 api_create_loopback (vat_main_t * vam)
4415 unformat_input_t *i = vam->input;
4416 vl_api_create_loopback_t *mp;
4421 memset (mac_address, 0, sizeof (mac_address));
4423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4425 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
4431 /* Construct the API message */
4432 M (CREATE_LOOPBACK, create_loopback);
4434 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
4441 api_delete_loopback (vat_main_t * vam)
4443 unformat_input_t *i = vam->input;
4444 vl_api_delete_loopback_t *mp;
4446 u32 sw_if_index = ~0;
4448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4450 if (unformat (i, "sw_if_index %d", &sw_if_index))
4456 if (sw_if_index == ~0)
4458 errmsg ("missing sw_if_index\n");
4462 /* Construct the API message */
4463 M (DELETE_LOOPBACK, delete_loopback);
4464 mp->sw_if_index = ntohl (sw_if_index);
4471 api_want_stats (vat_main_t * vam)
4473 unformat_input_t *i = vam->input;
4474 vl_api_want_stats_t *mp;
4478 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4480 if (unformat (i, "enable"))
4482 else if (unformat (i, "disable"))
4490 errmsg ("missing enable|disable\n");
4494 M (WANT_STATS, want_stats);
4495 mp->enable_disable = enable;
4502 api_want_interface_events (vat_main_t * vam)
4504 unformat_input_t *i = vam->input;
4505 vl_api_want_interface_events_t *mp;
4509 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4511 if (unformat (i, "enable"))
4513 else if (unformat (i, "disable"))
4521 errmsg ("missing enable|disable\n");
4525 M (WANT_INTERFACE_EVENTS, want_interface_events);
4526 mp->enable_disable = enable;
4528 vam->interface_event_display = enable;
4535 /* Note: non-static, called once to set up the initial intfc table */
4537 api_sw_interface_dump (vat_main_t * vam)
4539 vl_api_sw_interface_dump_t *mp;
4542 name_sort_t *nses = 0, *ns;
4543 sw_interface_subif_t *sub = NULL;
4545 /* Toss the old name table */
4547 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
4549 vec_add2 (nses, ns, 1);
4550 ns->name = (u8 *)(p->key);
4551 ns->value = (u32) p->value[0];
4555 hash_free (vam->sw_if_index_by_interface_name);
4557 vec_foreach (ns, nses) vec_free (ns->name);
4561 vec_foreach (sub, vam->sw_if_subif_table)
4563 vec_free (sub->interface_name);
4565 vec_free (vam->sw_if_subif_table);
4567 /* recreate the interface name hash table */
4568 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
4570 /* Get list of ethernets */
4571 M (SW_INTERFACE_DUMP, sw_interface_dump);
4572 mp->name_filter_valid = 1;
4573 strncpy ((char *) mp->name_filter, "Ether", sizeof (mp->name_filter) - 1);
4576 /* and local / loopback interfaces */
4577 M (SW_INTERFACE_DUMP, sw_interface_dump);
4578 mp->name_filter_valid = 1;
4579 strncpy ((char *) mp->name_filter, "lo", sizeof (mp->name_filter) - 1);
4582 /* and packet-generator interfaces */
4583 M (SW_INTERFACE_DUMP, sw_interface_dump);
4584 mp->name_filter_valid = 1;
4585 strncpy ((char *) mp->name_filter, "pg", sizeof (mp->name_filter) - 1);
4588 /* and vxlan-gpe tunnel interfaces */
4589 M (SW_INTERFACE_DUMP, sw_interface_dump);
4590 mp->name_filter_valid = 1;
4591 strncpy ((char *) mp->name_filter, "vxlan_gpe",
4592 sizeof (mp->name_filter) - 1);
4595 /* and vxlan tunnel interfaces */
4596 M (SW_INTERFACE_DUMP, sw_interface_dump);
4597 mp->name_filter_valid = 1;
4598 strncpy ((char *) mp->name_filter, "vxlan", sizeof (mp->name_filter) - 1);
4601 /* and host (af_packet) interfaces */
4602 M (SW_INTERFACE_DUMP, sw_interface_dump);
4603 mp->name_filter_valid = 1;
4604 strncpy ((char *) mp->name_filter, "host", sizeof (mp->name_filter) - 1);
4607 /* and l2tpv3 tunnel interfaces */
4608 M (SW_INTERFACE_DUMP, sw_interface_dump);
4609 mp->name_filter_valid = 1;
4610 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel",
4611 sizeof (mp->name_filter) - 1);
4614 /* and GRE tunnel interfaces */
4615 M (SW_INTERFACE_DUMP, sw_interface_dump);
4616 mp->name_filter_valid = 1;
4617 strncpy ((char *) mp->name_filter, "gre", sizeof (mp->name_filter) - 1);
4620 /* and LISP-GPE interfaces */
4621 M (SW_INTERFACE_DUMP, sw_interface_dump);
4622 mp->name_filter_valid = 1;
4623 strncpy ((char *) mp->name_filter, "lisp_gpe",
4624 sizeof (mp->name_filter) - 1);
4627 /* and IPSEC tunnel interfaces */
4628 M (SW_INTERFACE_DUMP, sw_interface_dump);
4629 mp->name_filter_valid = 1;
4630 strncpy ((char *) mp->name_filter, "ipsec", sizeof (mp->name_filter) - 1);
4633 /* Use a control ping for synchronization */
4635 vl_api_control_ping_t *mp;
4636 M (CONTROL_PING, control_ping);
4643 api_sw_interface_set_flags (vat_main_t * vam)
4645 unformat_input_t *i = vam->input;
4646 vl_api_sw_interface_set_flags_t *mp;
4649 u8 sw_if_index_set = 0;
4650 u8 admin_up = 0, link_up = 0;
4652 /* Parse args required to build the message */
4653 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4655 if (unformat (i, "admin-up"))
4657 else if (unformat (i, "admin-down"))
4659 else if (unformat (i, "link-up"))
4661 else if (unformat (i, "link-down"))
4663 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4664 sw_if_index_set = 1;
4665 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4666 sw_if_index_set = 1;
4671 if (sw_if_index_set == 0)
4673 errmsg ("missing interface name or sw_if_index\n");
4677 /* Construct the API message */
4678 M (SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
4679 mp->sw_if_index = ntohl (sw_if_index);
4680 mp->admin_up_down = admin_up;
4681 mp->link_up_down = link_up;
4686 /* Wait for a reply, return the good/bad news... */
4691 api_sw_interface_clear_stats (vat_main_t * vam)
4693 unformat_input_t *i = vam->input;
4694 vl_api_sw_interface_clear_stats_t *mp;
4697 u8 sw_if_index_set = 0;
4699 /* Parse args required to build the message */
4700 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4702 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4703 sw_if_index_set = 1;
4704 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4705 sw_if_index_set = 1;
4710 /* Construct the API message */
4711 M (SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
4713 if (sw_if_index_set == 1)
4714 mp->sw_if_index = ntohl (sw_if_index);
4716 mp->sw_if_index = ~0;
4721 /* Wait for a reply, return the good/bad news... */
4726 api_sw_interface_set_dpdk_hqos_pipe (vat_main_t * vam)
4728 unformat_input_t *i = vam->input;
4729 vl_api_sw_interface_set_dpdk_hqos_pipe_t *mp;
4732 u8 sw_if_index_set = 0;
4740 /* Parse args required to build the message */
4741 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4743 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4744 sw_if_index_set = 1;
4745 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4746 sw_if_index_set = 1;
4747 else if (unformat (i, "subport %u", &subport))
4749 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4750 sw_if_index_set = 1;
4751 else if (unformat (i, "pipe %u", &pipe))
4753 else if (unformat (i, "profile %u", &profile))
4759 if (sw_if_index_set == 0)
4761 errmsg ("missing interface name or sw_if_index\n");
4765 if (subport_set == 0)
4767 errmsg ("missing subport \n");
4773 errmsg ("missing pipe\n");
4777 if (profile_set == 0)
4779 errmsg ("missing profile\n");
4783 M (SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe);
4785 mp->sw_if_index = ntohl (sw_if_index);
4786 mp->subport = ntohl (subport);
4787 mp->pipe = ntohl (pipe);
4788 mp->profile = ntohl (profile);
4798 api_sw_interface_set_dpdk_hqos_subport (vat_main_t * vam)
4800 unformat_input_t *i = vam->input;
4801 vl_api_sw_interface_set_dpdk_hqos_subport_t *mp;
4804 u8 sw_if_index_set = 0;
4807 u32 tb_rate = 1250000000; /* 10GbE */
4808 u32 tb_size = 1000000;
4809 u32 tc_rate[] = { 1250000000, 1250000000, 1250000000, 1250000000 };
4812 /* Parse args required to build the message */
4813 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4815 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4816 sw_if_index_set = 1;
4817 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4818 sw_if_index_set = 1;
4819 else if (unformat (i, "subport %u", &subport))
4821 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4822 sw_if_index_set = 1;
4823 else if (unformat (i, "rate %u", &tb_rate))
4827 for (tc_id = 0; tc_id < (sizeof (tc_rate) / sizeof (tc_rate[0]));
4829 tc_rate[tc_id] = tb_rate;
4831 else if (unformat (i, "bktsize %u", &tb_size))
4833 else if (unformat (i, "tc0 %u", &tc_rate[0]))
4835 else if (unformat (i, "tc1 %u", &tc_rate[1]))
4837 else if (unformat (i, "tc2 %u", &tc_rate[2]))
4839 else if (unformat (i, "tc3 %u", &tc_rate[3]))
4841 else if (unformat (i, "period %u", &tc_period))
4847 if (sw_if_index_set == 0)
4849 errmsg ("missing interface name or sw_if_index\n");
4853 if (subport_set == 0)
4855 errmsg ("missing subport \n");
4859 M (SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport);
4861 mp->sw_if_index = ntohl (sw_if_index);
4862 mp->subport = ntohl (subport);
4863 mp->tb_rate = ntohl (tb_rate);
4864 mp->tb_size = ntohl (tb_size);
4865 mp->tc_rate[0] = ntohl (tc_rate[0]);
4866 mp->tc_rate[1] = ntohl (tc_rate[1]);
4867 mp->tc_rate[2] = ntohl (tc_rate[2]);
4868 mp->tc_rate[3] = ntohl (tc_rate[3]);
4869 mp->tc_period = ntohl (tc_period);
4878 api_sw_interface_set_dpdk_hqos_tctbl (vat_main_t * vam)
4880 unformat_input_t *i = vam->input;
4881 vl_api_sw_interface_set_dpdk_hqos_tctbl_t *mp;
4884 u8 sw_if_index_set = 0;
4888 u32 entry, tc, queue;
4890 /* Parse args required to build the message */
4891 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4893 if (unformat (i, "rx %U", unformat_sw_if_index, vam, &sw_if_index))
4894 sw_if_index_set = 1;
4895 else if (unformat (i, "sw_if_index %u", &sw_if_index))
4896 sw_if_index_set = 1;
4897 else if (unformat (i, "entry %d", &entry))
4899 else if (unformat (i, "tc %d", &tc))
4901 else if (unformat (i, "queue %d", &queue))
4907 if (sw_if_index_set == 0)
4909 errmsg ("missing interface name or sw_if_index\n");
4915 errmsg ("missing entry \n");
4921 errmsg ("missing traffic class \n");
4927 errmsg ("missing queue \n");
4931 M (SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl);
4933 mp->sw_if_index = ntohl (sw_if_index);
4934 mp->entry = ntohl (entry);
4935 mp->tc = ntohl (tc);
4936 mp->queue = ntohl (queue);
4945 api_sw_interface_add_del_address (vat_main_t * vam)
4947 unformat_input_t *i = vam->input;
4948 vl_api_sw_interface_add_del_address_t *mp;
4951 u8 sw_if_index_set = 0;
4952 u8 is_add = 1, del_all = 0;
4953 u32 address_length = 0;
4954 u8 v4_address_set = 0;
4955 u8 v6_address_set = 0;
4956 ip4_address_t v4address;
4957 ip6_address_t v6address;
4959 /* Parse args required to build the message */
4960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
4962 if (unformat (i, "del-all"))
4964 else if (unformat (i, "del"))
4966 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4967 sw_if_index_set = 1;
4968 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4969 sw_if_index_set = 1;
4970 else if (unformat (i, "%U/%d",
4971 unformat_ip4_address, &v4address, &address_length))
4973 else if (unformat (i, "%U/%d",
4974 unformat_ip6_address, &v6address, &address_length))
4980 if (sw_if_index_set == 0)
4982 errmsg ("missing interface name or sw_if_index\n");
4985 if (v4_address_set && v6_address_set)
4987 errmsg ("both v4 and v6 addresses set\n");
4990 if (!v4_address_set && !v6_address_set && !del_all)
4992 errmsg ("no addresses set\n");
4996 /* Construct the API message */
4997 M (SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
4999 mp->sw_if_index = ntohl (sw_if_index);
5000 mp->is_add = is_add;
5001 mp->del_all = del_all;
5005 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5009 clib_memcpy (mp->address, &v4address, sizeof (v4address));
5011 mp->address_length = address_length;
5016 /* Wait for a reply, return good/bad news */
5021 api_sw_interface_set_mpls_enable (vat_main_t * vam)
5023 unformat_input_t *i = vam->input;
5024 vl_api_sw_interface_set_mpls_enable_t *mp;
5027 u8 sw_if_index_set = 0;
5030 /* Parse args required to build the message */
5031 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5033 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5034 sw_if_index_set = 1;
5035 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5036 sw_if_index_set = 1;
5037 else if (unformat (i, "disable"))
5039 else if (unformat (i, "dis"))
5045 if (sw_if_index_set == 0)
5047 errmsg ("missing interface name or sw_if_index\n");
5051 /* Construct the API message */
5052 M (SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable);
5054 mp->sw_if_index = ntohl (sw_if_index);
5055 mp->enable = enable;
5060 /* Wait for a reply... */
5065 api_sw_interface_set_table (vat_main_t * vam)
5067 unformat_input_t *i = vam->input;
5068 vl_api_sw_interface_set_table_t *mp;
5070 u32 sw_if_index, vrf_id = 0;
5071 u8 sw_if_index_set = 0;
5074 /* Parse args required to build the message */
5075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5077 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5078 sw_if_index_set = 1;
5079 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5080 sw_if_index_set = 1;
5081 else if (unformat (i, "vrf %d", &vrf_id))
5083 else if (unformat (i, "ipv6"))
5089 if (sw_if_index_set == 0)
5091 errmsg ("missing interface name or sw_if_index\n");
5095 /* Construct the API message */
5096 M (SW_INTERFACE_SET_TABLE, sw_interface_set_table);
5098 mp->sw_if_index = ntohl (sw_if_index);
5099 mp->is_ipv6 = is_ipv6;
5100 mp->vrf_id = ntohl (vrf_id);
5105 /* Wait for a reply... */
5109 static void vl_api_sw_interface_get_table_reply_t_handler
5110 (vl_api_sw_interface_get_table_reply_t * mp)
5112 vat_main_t *vam = &vat_main;
5114 fformat (vam->ofp, "%d\n", ntohl (mp->vrf_id));
5116 vam->retval = ntohl (mp->retval);
5117 vam->result_ready = 1;
5121 static void vl_api_sw_interface_get_table_reply_t_handler_json
5122 (vl_api_sw_interface_get_table_reply_t * mp)
5124 vat_main_t *vam = &vat_main;
5125 vat_json_node_t node;
5127 vat_json_init_object (&node);
5128 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
5129 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
5131 vat_json_print (vam->ofp, &node);
5132 vat_json_free (&node);
5134 vam->retval = ntohl (mp->retval);
5135 vam->result_ready = 1;
5139 api_sw_interface_get_table (vat_main_t * vam)
5141 unformat_input_t *i = vam->input;
5142 vl_api_sw_interface_get_table_t *mp;
5144 u8 sw_if_index_set = 0;
5148 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5150 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5151 sw_if_index_set = 1;
5152 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5153 sw_if_index_set = 1;
5154 else if (unformat (i, "ipv6"))
5160 if (sw_if_index_set == 0)
5162 errmsg ("missing interface name or sw_if_index\n");
5166 M (SW_INTERFACE_GET_TABLE, sw_interface_get_table);
5167 mp->sw_if_index = htonl (sw_if_index);
5168 mp->is_ipv6 = is_ipv6;
5175 api_sw_interface_set_vpath (vat_main_t * vam)
5177 unformat_input_t *i = vam->input;
5178 vl_api_sw_interface_set_vpath_t *mp;
5180 u32 sw_if_index = 0;
5181 u8 sw_if_index_set = 0;
5184 /* Parse args required to build the message */
5185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5187 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5188 sw_if_index_set = 1;
5189 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5190 sw_if_index_set = 1;
5191 else if (unformat (i, "enable"))
5193 else if (unformat (i, "disable"))
5199 if (sw_if_index_set == 0)
5201 errmsg ("missing interface name or sw_if_index\n");
5205 /* Construct the API message */
5206 M (SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
5208 mp->sw_if_index = ntohl (sw_if_index);
5209 mp->enable = is_enable;
5214 /* Wait for a reply... */
5219 api_sw_interface_set_vxlan_bypass (vat_main_t * vam)
5221 unformat_input_t *i = vam->input;
5222 vl_api_sw_interface_set_vxlan_bypass_t *mp;
5224 u32 sw_if_index = 0;
5225 u8 sw_if_index_set = 0;
5229 /* Parse args required to build the message */
5230 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5232 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5233 sw_if_index_set = 1;
5234 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5235 sw_if_index_set = 1;
5236 else if (unformat (i, "enable"))
5238 else if (unformat (i, "disable"))
5240 else if (unformat (i, "ip4"))
5242 else if (unformat (i, "ip6"))
5248 if (sw_if_index_set == 0)
5250 errmsg ("missing interface name or sw_if_index\n");
5254 /* Construct the API message */
5255 M (SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass);
5257 mp->sw_if_index = ntohl (sw_if_index);
5258 mp->enable = is_enable;
5259 mp->is_ipv6 = is_ipv6;
5264 /* Wait for a reply... */
5269 api_sw_interface_set_l2_xconnect (vat_main_t * vam)
5271 unformat_input_t *i = vam->input;
5272 vl_api_sw_interface_set_l2_xconnect_t *mp;
5275 u8 rx_sw_if_index_set = 0;
5277 u8 tx_sw_if_index_set = 0;
5280 /* Parse args required to build the message */
5281 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5283 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5284 rx_sw_if_index_set = 1;
5285 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5286 tx_sw_if_index_set = 1;
5287 else if (unformat (i, "rx"))
5289 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5291 if (unformat (i, "%U", unformat_sw_if_index, vam,
5293 rx_sw_if_index_set = 1;
5298 else if (unformat (i, "tx"))
5300 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5302 if (unformat (i, "%U", unformat_sw_if_index, vam,
5304 tx_sw_if_index_set = 1;
5309 else if (unformat (i, "enable"))
5311 else if (unformat (i, "disable"))
5317 if (rx_sw_if_index_set == 0)
5319 errmsg ("missing rx interface name or rx_sw_if_index\n");
5323 if (enable && (tx_sw_if_index_set == 0))
5325 errmsg ("missing tx interface name or tx_sw_if_index\n");
5329 M (SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
5331 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5332 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
5333 mp->enable = enable;
5342 api_sw_interface_set_l2_bridge (vat_main_t * vam)
5344 unformat_input_t *i = vam->input;
5345 vl_api_sw_interface_set_l2_bridge_t *mp;
5348 u8 rx_sw_if_index_set = 0;
5355 /* Parse args required to build the message */
5356 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5358 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
5359 rx_sw_if_index_set = 1;
5360 else if (unformat (i, "bd_id %d", &bd_id))
5362 else if (unformat (i, "%U", unformat_sw_if_index, vam, &rx_sw_if_index))
5363 rx_sw_if_index_set = 1;
5364 else if (unformat (i, "shg %d", &shg))
5366 else if (unformat (i, "bvi"))
5368 else if (unformat (i, "enable"))
5370 else if (unformat (i, "disable"))
5376 if (rx_sw_if_index_set == 0)
5378 errmsg ("missing rx interface name or sw_if_index\n");
5382 if (enable && (bd_id_set == 0))
5384 errmsg ("missing bridge domain\n");
5388 M (SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
5390 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
5391 mp->bd_id = ntohl (bd_id);
5394 mp->enable = enable;
5403 api_bridge_domain_dump (vat_main_t * vam)
5405 unformat_input_t *i = vam->input;
5406 vl_api_bridge_domain_dump_t *mp;
5410 /* Parse args required to build the message */
5411 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5413 if (unformat (i, "bd_id %d", &bd_id))
5419 M (BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
5420 mp->bd_id = ntohl (bd_id);
5423 /* Use a control ping for synchronization */
5425 vl_api_control_ping_t *mp;
5426 M (CONTROL_PING, control_ping);
5436 api_bridge_domain_add_del (vat_main_t * vam)
5438 unformat_input_t *i = vam->input;
5439 vl_api_bridge_domain_add_del_t *mp;
5443 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
5445 /* Parse args required to build the message */
5446 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5448 if (unformat (i, "bd_id %d", &bd_id))
5450 else if (unformat (i, "flood %d", &flood))
5452 else if (unformat (i, "uu-flood %d", &uu_flood))
5454 else if (unformat (i, "forward %d", &forward))
5456 else if (unformat (i, "learn %d", &learn))
5458 else if (unformat (i, "arp-term %d", &arp_term))
5460 else if (unformat (i, "del"))
5463 flood = uu_flood = forward = learn = 0;
5471 errmsg ("missing bridge domain\n");
5475 M (BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
5477 mp->bd_id = ntohl (bd_id);
5479 mp->uu_flood = uu_flood;
5480 mp->forward = forward;
5482 mp->arp_term = arp_term;
5483 mp->is_add = is_add;
5492 api_l2fib_add_del (vat_main_t * vam)
5494 unformat_input_t *i = vam->input;
5495 vl_api_l2fib_add_del_t *mp;
5501 u32 sw_if_index = ~0;
5502 u8 sw_if_index_set = 0;
5511 /* Parse args required to build the message */
5512 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5514 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
5516 else if (unformat (i, "bd_id %d", &bd_id))
5518 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5519 sw_if_index_set = 1;
5520 else if (unformat (i, "sw_if"))
5522 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5524 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5525 sw_if_index_set = 1;
5530 else if (unformat (i, "static"))
5532 else if (unformat (i, "filter"))
5537 else if (unformat (i, "bvi"))
5542 else if (unformat (i, "del"))
5544 else if (unformat (i, "count %d", &count))
5552 errmsg ("missing mac address\n");
5558 errmsg ("missing bridge domain\n");
5562 if (is_add && sw_if_index_set == 0 && filter_mac == 0)
5564 errmsg ("missing interface name or sw_if_index\n");
5570 /* Turn on async mode */
5571 vam->async_mode = 1;
5572 vam->async_errors = 0;
5573 before = vat_time_now (vam);
5576 for (j = 0; j < count; j++)
5578 M (L2FIB_ADD_DEL, l2fib_add_del);
5581 mp->bd_id = ntohl (bd_id);
5582 mp->is_add = is_add;
5586 mp->sw_if_index = ntohl (sw_if_index);
5587 mp->static_mac = static_mac;
5588 mp->filter_mac = filter_mac;
5589 mp->bvi_mac = bvi_mac;
5591 increment_mac_address (&mac);
5598 vl_api_control_ping_t *mp;
5601 /* Shut off async mode */
5602 vam->async_mode = 0;
5604 M (CONTROL_PING, control_ping);
5607 timeout = vat_time_now (vam) + 1.0;
5608 while (vat_time_now (vam) < timeout)
5609 if (vam->result_ready == 1)
5614 if (vam->retval == -99)
5615 errmsg ("timeout\n");
5617 if (vam->async_errors > 0)
5619 errmsg ("%d asynchronous errors\n", vam->async_errors);
5622 vam->async_errors = 0;
5623 after = vat_time_now (vam);
5625 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
5626 count, after - before, count / (after - before));
5630 /* Wait for a reply... */
5633 /* Return the good/bad news */
5634 return (vam->retval);
5638 api_l2_flags (vat_main_t * vam)
5640 unformat_input_t *i = vam->input;
5641 vl_api_l2_flags_t *mp;
5644 u32 feature_bitmap = 0;
5645 u8 sw_if_index_set = 0;
5647 /* Parse args required to build the message */
5648 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5650 if (unformat (i, "sw_if_index %d", &sw_if_index))
5651 sw_if_index_set = 1;
5652 else if (unformat (i, "sw_if"))
5654 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5656 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5657 sw_if_index_set = 1;
5662 else if (unformat (i, "learn"))
5663 feature_bitmap |= L2INPUT_FEAT_LEARN;
5664 else if (unformat (i, "forward"))
5665 feature_bitmap |= L2INPUT_FEAT_FWD;
5666 else if (unformat (i, "flood"))
5667 feature_bitmap |= L2INPUT_FEAT_FLOOD;
5668 else if (unformat (i, "uu-flood"))
5669 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
5674 if (sw_if_index_set == 0)
5676 errmsg ("missing interface name or sw_if_index\n");
5680 M (L2_FLAGS, l2_flags);
5682 mp->sw_if_index = ntohl (sw_if_index);
5683 mp->feature_bitmap = ntohl (feature_bitmap);
5692 api_bridge_flags (vat_main_t * vam)
5694 unformat_input_t *i = vam->input;
5695 vl_api_bridge_flags_t *mp;
5702 /* Parse args required to build the message */
5703 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5705 if (unformat (i, "bd_id %d", &bd_id))
5707 else if (unformat (i, "learn"))
5709 else if (unformat (i, "forward"))
5711 else if (unformat (i, "flood"))
5713 else if (unformat (i, "uu-flood"))
5714 flags |= L2_UU_FLOOD;
5715 else if (unformat (i, "arp-term"))
5716 flags |= L2_ARP_TERM;
5717 else if (unformat (i, "off"))
5719 else if (unformat (i, "disable"))
5727 errmsg ("missing bridge domain\n");
5731 M (BRIDGE_FLAGS, bridge_flags);
5733 mp->bd_id = ntohl (bd_id);
5734 mp->feature_bitmap = ntohl (flags);
5735 mp->is_set = is_set;
5744 api_bd_ip_mac_add_del (vat_main_t * vam)
5746 unformat_input_t *i = vam->input;
5747 vl_api_bd_ip_mac_add_del_t *mp;
5755 ip4_address_t v4addr;
5756 ip6_address_t v6addr;
5760 /* Parse args required to build the message */
5761 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5763 if (unformat (i, "bd_id %d", &bd_id))
5767 else if (unformat (i, "%U", unformat_ip4_address, &v4addr))
5771 else if (unformat (i, "%U", unformat_ip6_address, &v6addr))
5776 else if (unformat (i, "%U", unformat_ethernet_address, macaddr))
5780 else if (unformat (i, "del"))
5788 errmsg ("missing bridge domain\n");
5791 else if (ip_set == 0)
5793 errmsg ("missing IP address\n");
5796 else if (mac_set == 0)
5798 errmsg ("missing MAC address\n");
5802 M (BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
5804 mp->bd_id = ntohl (bd_id);
5805 mp->is_ipv6 = is_ipv6;
5806 mp->is_add = is_add;
5808 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
5810 clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
5811 clib_memcpy (mp->mac_address, macaddr, 6);
5819 api_tap_connect (vat_main_t * vam)
5821 unformat_input_t *i = vam->input;
5822 vl_api_tap_connect_t *mp;
5830 memset (mac_address, 0, sizeof (mac_address));
5832 /* Parse args required to build the message */
5833 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5835 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5839 else if (unformat (i, "random-mac"))
5841 else if (unformat (i, "tapname %s", &tap_name))
5843 else if (unformat (i, "tag %s", &tag))
5851 errmsg ("missing tap name\n");
5854 if (vec_len (tap_name) > 63)
5856 errmsg ("tap name too long\n");
5859 vec_add1 (tap_name, 0);
5861 if (vec_len (tag) > 63)
5863 errmsg ("tag too long\n");
5867 /* Construct the API message */
5868 M (TAP_CONNECT, tap_connect);
5870 mp->use_random_mac = random_mac;
5871 clib_memcpy (mp->mac_address, mac_address, 6);
5872 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5874 clib_memcpy (mp->tag, tag, vec_len (tag));
5876 vec_free (tap_name);
5882 /* Wait for a reply... */
5887 api_tap_modify (vat_main_t * vam)
5889 unformat_input_t *i = vam->input;
5890 vl_api_tap_modify_t *mp;
5896 u32 sw_if_index = ~0;
5897 u8 sw_if_index_set = 0;
5899 memset (mac_address, 0, sizeof (mac_address));
5901 /* Parse args required to build the message */
5902 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5904 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5905 sw_if_index_set = 1;
5906 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5907 sw_if_index_set = 1;
5908 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
5912 else if (unformat (i, "random-mac"))
5914 else if (unformat (i, "tapname %s", &tap_name))
5920 if (sw_if_index_set == 0)
5922 errmsg ("missing vpp interface name");
5927 errmsg ("missing tap name\n");
5930 if (vec_len (tap_name) > 63)
5932 errmsg ("tap name too long\n");
5934 vec_add1 (tap_name, 0);
5936 /* Construct the API message */
5937 M (TAP_MODIFY, tap_modify);
5939 mp->use_random_mac = random_mac;
5940 mp->sw_if_index = ntohl (sw_if_index);
5941 clib_memcpy (mp->mac_address, mac_address, 6);
5942 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
5943 vec_free (tap_name);
5948 /* Wait for a reply... */
5953 api_tap_delete (vat_main_t * vam)
5955 unformat_input_t *i = vam->input;
5956 vl_api_tap_delete_t *mp;
5958 u32 sw_if_index = ~0;
5959 u8 sw_if_index_set = 0;
5961 /* Parse args required to build the message */
5962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5964 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5965 sw_if_index_set = 1;
5966 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5967 sw_if_index_set = 1;
5972 if (sw_if_index_set == 0)
5974 errmsg ("missing vpp interface name");
5978 /* Construct the API message */
5979 M (TAP_DELETE, tap_delete);
5981 mp->sw_if_index = ntohl (sw_if_index);
5986 /* Wait for a reply... */
5991 api_ip_add_del_route (vat_main_t * vam)
5993 unformat_input_t *i = vam->input;
5994 vl_api_ip_add_del_route_t *mp;
5996 u32 sw_if_index = ~0, vrf_id = 0;
5998 u8 is_local = 0, is_drop = 0;
5999 u8 is_unreach = 0, is_prohibit = 0;
6000 u8 create_vrf_if_needed = 0;
6002 u32 next_hop_weight = 1;
6004 u8 is_multipath = 0;
6006 u8 address_length_set = 0;
6007 u32 next_hop_table_id = 0;
6008 u32 resolve_attempts = 0;
6009 u32 dst_address_length = 0;
6010 u8 next_hop_set = 0;
6011 ip4_address_t v4_dst_address, v4_next_hop_address;
6012 ip6_address_t v6_dst_address, v6_next_hop_address;
6016 u32 random_add_del = 0;
6017 u32 *random_vector = 0;
6019 u32 random_seed = 0xdeaddabe;
6020 u32 classify_table_index = ~0;
6022 u8 resolve_host = 0, resolve_attached = 0;
6023 mpls_label_t *next_hop_out_label_stack = NULL;
6024 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6025 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6027 /* Parse args required to build the message */
6028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6030 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6032 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6034 else if (unformat (i, "%U", unformat_ip4_address, &v4_dst_address))
6039 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address))
6044 else if (unformat (i, "/%d", &dst_address_length))
6046 address_length_set = 1;
6049 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
6050 &v4_next_hop_address))
6054 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
6055 &v6_next_hop_address))
6059 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
6061 else if (unformat (i, "weight %d", &next_hop_weight))
6063 else if (unformat (i, "drop"))
6067 else if (unformat (i, "null-send-unreach"))
6071 else if (unformat (i, "null-send-prohibit"))
6075 else if (unformat (i, "local"))
6079 else if (unformat (i, "classify %d", &classify_table_index))
6083 else if (unformat (i, "del"))
6085 else if (unformat (i, "add"))
6087 else if (unformat (i, "not-last"))
6089 else if (unformat (i, "resolve-via-host"))
6091 else if (unformat (i, "resolve-via-attached"))
6092 resolve_attached = 1;
6093 else if (unformat (i, "multipath"))
6095 else if (unformat (i, "vrf %d", &vrf_id))
6097 else if (unformat (i, "create-vrf"))
6098 create_vrf_if_needed = 1;
6099 else if (unformat (i, "count %d", &count))
6101 else if (unformat (i, "lookup-in-vrf %d", &next_hop_table_id))
6103 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6105 else if (unformat (i, "out-label %d", &next_hop_out_label))
6106 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6107 else if (unformat (i, "via-label %d", &next_hop_via_label))
6109 else if (unformat (i, "random"))
6111 else if (unformat (i, "seed %d", &random_seed))
6115 clib_warning ("parse error '%U'", format_unformat_error, i);
6120 if (!next_hop_set && !is_drop && !is_local &&
6121 !is_classify && !is_unreach && !is_prohibit &&
6122 MPLS_LABEL_INVALID == next_hop_via_label)
6125 ("next hop / local / drop / unreach / prohibit / classify not set\n");
6129 if (next_hop_set && MPLS_LABEL_INVALID != next_hop_via_label)
6131 errmsg ("next hop and next-hop via label set\n");
6134 if (address_set == 0)
6136 errmsg ("missing addresses\n");
6140 if (address_length_set == 0)
6142 errmsg ("missing address length\n");
6146 /* Generate a pile of unique, random routes */
6149 u32 this_random_address;
6150 random_hash = hash_create (count, sizeof (uword));
6152 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
6153 for (j = 0; j <= count; j++)
6157 this_random_address = random_u32 (&random_seed);
6158 this_random_address =
6159 clib_host_to_net_u32 (this_random_address);
6161 while (hash_get (random_hash, this_random_address));
6162 vec_add1 (random_vector, this_random_address);
6163 hash_set (random_hash, this_random_address, 1);
6165 hash_free (random_hash);
6166 v4_dst_address.as_u32 = random_vector[0];
6171 /* Turn on async mode */
6172 vam->async_mode = 1;
6173 vam->async_errors = 0;
6174 before = vat_time_now (vam);
6177 for (j = 0; j < count; j++)
6179 /* Construct the API message */
6180 M2 (IP_ADD_DEL_ROUTE, ip_add_del_route,
6181 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6183 mp->next_hop_sw_if_index = ntohl (sw_if_index);
6184 mp->table_id = ntohl (vrf_id);
6185 mp->create_vrf_if_needed = create_vrf_if_needed;
6187 mp->is_add = is_add;
6188 mp->is_drop = is_drop;
6189 mp->is_unreach = is_unreach;
6190 mp->is_prohibit = is_prohibit;
6191 mp->is_ipv6 = is_ipv6;
6192 mp->is_local = is_local;
6193 mp->is_classify = is_classify;
6194 mp->is_multipath = is_multipath;
6195 mp->is_resolve_host = resolve_host;
6196 mp->is_resolve_attached = resolve_attached;
6197 mp->not_last = not_last;
6198 mp->next_hop_weight = next_hop_weight;
6199 mp->dst_address_length = dst_address_length;
6200 mp->next_hop_table_id = ntohl (next_hop_table_id);
6201 mp->classify_table_index = ntohl (classify_table_index);
6202 mp->next_hop_via_label = ntohl (next_hop_via_label);
6203 mp->next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6204 if (0 != mp->next_hop_n_out_labels)
6206 memcpy (mp->next_hop_out_label_stack,
6207 next_hop_out_label_stack,
6208 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6209 vec_free (next_hop_out_label_stack);
6214 clib_memcpy (mp->dst_address, &v6_dst_address,
6215 sizeof (v6_dst_address));
6217 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
6218 sizeof (v6_next_hop_address));
6219 increment_v6_address (&v6_dst_address);
6223 clib_memcpy (mp->dst_address, &v4_dst_address,
6224 sizeof (v4_dst_address));
6226 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
6227 sizeof (v4_next_hop_address));
6229 v4_dst_address.as_u32 = random_vector[j + 1];
6231 increment_v4_address (&v4_dst_address);
6235 /* If we receive SIGTERM, stop now... */
6240 /* When testing multiple add/del ops, use a control-ping to sync */
6243 vl_api_control_ping_t *mp;
6246 /* Shut off async mode */
6247 vam->async_mode = 0;
6249 M (CONTROL_PING, control_ping);
6252 timeout = vat_time_now (vam) + 1.0;
6253 while (vat_time_now (vam) < timeout)
6254 if (vam->result_ready == 1)
6259 if (vam->retval == -99)
6260 errmsg ("timeout\n");
6262 if (vam->async_errors > 0)
6264 errmsg ("%d asynchronous errors\n", vam->async_errors);
6267 vam->async_errors = 0;
6268 after = vat_time_now (vam);
6270 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6274 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6275 count, after - before, count / (after - before));
6279 /* Wait for a reply... */
6283 /* Return the good/bad news */
6284 return (vam->retval);
6288 api_mpls_route_add_del (vat_main_t * vam)
6290 unformat_input_t *i = vam->input;
6291 vl_api_mpls_route_add_del_t *mp;
6293 u32 sw_if_index = ~0, table_id = 0;
6294 u8 create_table_if_needed = 0;
6296 u32 next_hop_weight = 1;
6297 u8 is_multipath = 0;
6298 u32 next_hop_table_id = 0;
6299 u8 next_hop_set = 0;
6300 ip4_address_t v4_next_hop_address = {
6303 ip6_address_t v6_next_hop_address = { {0} };
6307 u32 classify_table_index = ~0;
6309 u8 resolve_host = 0, resolve_attached = 0;
6310 mpls_label_t next_hop_via_label = MPLS_LABEL_INVALID;
6311 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID;
6312 mpls_label_t *next_hop_out_label_stack = NULL;
6313 mpls_label_t local_label = MPLS_LABEL_INVALID;
6315 u8 next_hop_proto_is_ip4 = 1;
6317 /* Parse args required to build the message */
6318 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6320 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6322 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6324 else if (unformat (i, "%d", &local_label))
6326 else if (unformat (i, "eos"))
6328 else if (unformat (i, "non-eos"))
6330 else if (unformat (i, "via %U", unformat_ip4_address,
6331 &v4_next_hop_address))
6334 next_hop_proto_is_ip4 = 1;
6336 else if (unformat (i, "via %U", unformat_ip6_address,
6337 &v6_next_hop_address))
6340 next_hop_proto_is_ip4 = 0;
6342 else if (unformat (i, "weight %d", &next_hop_weight))
6344 else if (unformat (i, "create-table"))
6345 create_table_if_needed = 1;
6346 else if (unformat (i, "classify %d", &classify_table_index))
6350 else if (unformat (i, "del"))
6352 else if (unformat (i, "add"))
6354 else if (unformat (i, "resolve-via-host"))
6356 else if (unformat (i, "resolve-via-attached"))
6357 resolve_attached = 1;
6358 else if (unformat (i, "multipath"))
6360 else if (unformat (i, "count %d", &count))
6362 else if (unformat (i, "lookup-in-ip4-table %d", &next_hop_table_id))
6365 next_hop_proto_is_ip4 = 1;
6367 else if (unformat (i, "lookup-in-ip6-table %d", &next_hop_table_id))
6370 next_hop_proto_is_ip4 = 0;
6372 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6374 else if (unformat (i, "via-label %d", &next_hop_via_label))
6376 else if (unformat (i, "out-label %d", &next_hop_out_label))
6377 vec_add1 (next_hop_out_label_stack, ntohl (next_hop_out_label));
6380 clib_warning ("parse error '%U'", format_unformat_error, i);
6385 if (!next_hop_set && !is_classify)
6387 errmsg ("next hop / classify not set\n");
6391 if (MPLS_LABEL_INVALID == local_label)
6393 errmsg ("missing label\n");
6399 /* Turn on async mode */
6400 vam->async_mode = 1;
6401 vam->async_errors = 0;
6402 before = vat_time_now (vam);
6405 for (j = 0; j < count; j++)
6407 /* Construct the API message */
6408 M2 (MPLS_ROUTE_ADD_DEL, mpls_route_add_del,
6409 sizeof (mpls_label_t) * vec_len (next_hop_out_label_stack));
6411 mp->mr_next_hop_sw_if_index = ntohl (sw_if_index);
6412 mp->mr_table_id = ntohl (table_id);
6413 mp->mr_create_table_if_needed = create_table_if_needed;
6415 mp->mr_is_add = is_add;
6416 mp->mr_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6417 mp->mr_is_classify = is_classify;
6418 mp->mr_is_multipath = is_multipath;
6419 mp->mr_is_resolve_host = resolve_host;
6420 mp->mr_is_resolve_attached = resolve_attached;
6421 mp->mr_next_hop_weight = next_hop_weight;
6422 mp->mr_next_hop_table_id = ntohl (next_hop_table_id);
6423 mp->mr_classify_table_index = ntohl (classify_table_index);
6424 mp->mr_next_hop_via_label = ntohl (next_hop_via_label);
6425 mp->mr_label = ntohl (local_label);
6426 mp->mr_eos = is_eos;
6428 mp->mr_next_hop_n_out_labels = vec_len (next_hop_out_label_stack);
6429 if (0 != mp->mr_next_hop_n_out_labels)
6431 memcpy (mp->mr_next_hop_out_label_stack,
6432 next_hop_out_label_stack,
6433 vec_len (next_hop_out_label_stack) * sizeof (mpls_label_t));
6434 vec_free (next_hop_out_label_stack);
6439 if (next_hop_proto_is_ip4)
6441 clib_memcpy (mp->mr_next_hop,
6442 &v4_next_hop_address,
6443 sizeof (v4_next_hop_address));
6447 clib_memcpy (mp->mr_next_hop,
6448 &v6_next_hop_address,
6449 sizeof (v6_next_hop_address));
6456 /* If we receive SIGTERM, stop now... */
6461 /* When testing multiple add/del ops, use a control-ping to sync */
6464 vl_api_control_ping_t *mp;
6467 /* Shut off async mode */
6468 vam->async_mode = 0;
6470 M (CONTROL_PING, control_ping);
6473 timeout = vat_time_now (vam) + 1.0;
6474 while (vat_time_now (vam) < timeout)
6475 if (vam->result_ready == 1)
6480 if (vam->retval == -99)
6481 errmsg ("timeout\n");
6483 if (vam->async_errors > 0)
6485 errmsg ("%d asynchronous errors\n", vam->async_errors);
6488 vam->async_errors = 0;
6489 after = vat_time_now (vam);
6491 /* slim chance, but we might have eaten SIGTERM on the first iteration */
6495 fformat (vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
6496 count, after - before, count / (after - before));
6500 /* Wait for a reply... */
6504 /* Return the good/bad news */
6505 return (vam->retval);
6509 api_mpls_ip_bind_unbind (vat_main_t * vam)
6511 unformat_input_t *i = vam->input;
6512 vl_api_mpls_ip_bind_unbind_t *mp;
6514 u32 ip_table_id = 0;
6515 u8 create_table_if_needed = 0;
6518 ip4_address_t v4_address;
6519 ip6_address_t v6_address;
6522 mpls_label_t local_label = MPLS_LABEL_INVALID;
6524 /* Parse args required to build the message */
6525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6527 if (unformat (i, "%U/%d", unformat_ip4_address,
6528 &v4_address, &address_length))
6533 else if (unformat (i, "%U/%d", unformat_ip6_address,
6534 &v6_address, &address_length))
6539 else if (unformat (i, "%d", &local_label))
6541 else if (unformat (i, "create-table"))
6542 create_table_if_needed = 1;
6543 else if (unformat (i, "table-id %d", &ip_table_id))
6545 else if (unformat (i, "unbind"))
6547 else if (unformat (i, "bind"))
6551 clib_warning ("parse error '%U'", format_unformat_error, i);
6558 errmsg ("IP addres not set\n");
6562 if (MPLS_LABEL_INVALID == local_label)
6564 errmsg ("missing label\n");
6568 /* Construct the API message */
6569 M (MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind);
6571 mp->mb_create_table_if_needed = create_table_if_needed;
6572 mp->mb_is_bind = is_bind;
6573 mp->mb_is_ip4 = is_ip4;
6574 mp->mb_ip_table_id = ntohl (ip_table_id);
6575 mp->mb_mpls_table_id = 0;
6576 mp->mb_label = ntohl (local_label);
6577 mp->mb_address_length = address_length;
6580 clib_memcpy (mp->mb_address, &v4_address, sizeof (v4_address));
6582 clib_memcpy (mp->mb_address, &v6_address, sizeof (v6_address));
6587 /* Wait for a reply... */
6592 api_proxy_arp_add_del (vat_main_t * vam)
6594 unformat_input_t *i = vam->input;
6595 vl_api_proxy_arp_add_del_t *mp;
6599 ip4_address_t lo, hi;
6602 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6604 if (unformat (i, "vrf %d", &vrf_id))
6606 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
6607 unformat_ip4_address, &hi))
6609 else if (unformat (i, "del"))
6613 clib_warning ("parse error '%U'", format_unformat_error, i);
6620 errmsg ("address range not set\n");
6624 M (PROXY_ARP_ADD_DEL, proxy_arp_add_del);
6626 mp->vrf_id = ntohl (vrf_id);
6627 mp->is_add = is_add;
6628 clib_memcpy (mp->low_address, &lo, sizeof (mp->low_address));
6629 clib_memcpy (mp->hi_address, &hi, sizeof (mp->hi_address));
6638 api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
6640 unformat_input_t *i = vam->input;
6641 vl_api_proxy_arp_intfc_enable_disable_t *mp;
6645 u8 sw_if_index_set = 0;
6647 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6649 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6650 sw_if_index_set = 1;
6651 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6652 sw_if_index_set = 1;
6653 else if (unformat (i, "enable"))
6655 else if (unformat (i, "disable"))
6659 clib_warning ("parse error '%U'", format_unformat_error, i);
6664 if (sw_if_index_set == 0)
6666 errmsg ("missing interface name or sw_if_index\n");
6670 M (PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
6672 mp->sw_if_index = ntohl (sw_if_index);
6673 mp->enable_disable = enable;
6682 api_mpls_tunnel_add_del (vat_main_t * vam)
6684 unformat_input_t *i = vam->input;
6685 vl_api_mpls_tunnel_add_del_t *mp;
6690 u32 sw_if_index = ~0;
6691 u32 next_hop_sw_if_index = ~0;
6692 u32 next_hop_proto_is_ip4 = 1;
6694 u32 next_hop_table_id = 0;
6695 ip4_address_t v4_next_hop_address = {
6698 ip6_address_t v6_next_hop_address = { {0} };
6699 mpls_label_t next_hop_out_label = MPLS_LABEL_INVALID, *labels = NULL;
6701 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6703 if (unformat (i, "add"))
6705 else if (unformat (i, "del sw_if_index %d", &sw_if_index))
6707 else if (unformat (i, "sw_if_index %d", &next_hop_sw_if_index))
6709 else if (unformat (i, "via %U",
6710 unformat_ip4_address, &v4_next_hop_address))
6712 next_hop_proto_is_ip4 = 1;
6714 else if (unformat (i, "via %U",
6715 unformat_ip6_address, &v6_next_hop_address))
6717 next_hop_proto_is_ip4 = 0;
6719 else if (unformat (i, "l2-only"))
6721 else if (unformat (i, "next-hop-table %d", &next_hop_table_id))
6723 else if (unformat (i, "out-label %d", &next_hop_out_label))
6724 vec_add1 (labels, ntohl (next_hop_out_label));
6727 clib_warning ("parse error '%U'", format_unformat_error, i);
6732 M2 (MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del,
6733 sizeof (mpls_label_t) * vec_len (labels));
6735 mp->mt_next_hop_sw_if_index = ntohl (next_hop_sw_if_index);
6736 mp->mt_sw_if_index = ntohl (sw_if_index);
6737 mp->mt_is_add = is_add;
6738 mp->mt_l2_only = l2_only;
6739 mp->mt_next_hop_table_id = ntohl (next_hop_table_id);
6740 mp->mt_next_hop_proto_is_ip4 = next_hop_proto_is_ip4;
6742 mp->mt_next_hop_n_out_labels = vec_len (labels);
6744 if (0 != mp->mt_next_hop_n_out_labels)
6746 clib_memcpy (mp->mt_next_hop_out_label_stack, labels,
6747 sizeof (mpls_label_t) * mp->mt_next_hop_n_out_labels);
6751 if (next_hop_proto_is_ip4)
6753 clib_memcpy (mp->mt_next_hop,
6754 &v4_next_hop_address, sizeof (v4_next_hop_address));
6758 clib_memcpy (mp->mt_next_hop,
6759 &v6_next_hop_address, sizeof (v6_next_hop_address));
6769 api_sw_interface_set_unnumbered (vat_main_t * vam)
6771 unformat_input_t *i = vam->input;
6772 vl_api_sw_interface_set_unnumbered_t *mp;
6775 u32 unnum_sw_index = ~0;
6777 u8 sw_if_index_set = 0;
6779 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6781 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6782 sw_if_index_set = 1;
6783 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6784 sw_if_index_set = 1;
6785 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
6787 else if (unformat (i, "del"))
6791 clib_warning ("parse error '%U'", format_unformat_error, i);
6796 if (sw_if_index_set == 0)
6798 errmsg ("missing interface name or sw_if_index\n");
6802 M (SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
6804 mp->sw_if_index = ntohl (sw_if_index);
6805 mp->unnumbered_sw_if_index = ntohl (unnum_sw_index);
6806 mp->is_add = is_add;
6815 api_ip_neighbor_add_del (vat_main_t * vam)
6817 unformat_input_t *i = vam->input;
6818 vl_api_ip_neighbor_add_del_t *mp;
6821 u8 sw_if_index_set = 0;
6827 u8 v4_address_set = 0;
6828 u8 v6_address_set = 0;
6829 ip4_address_t v4address;
6830 ip6_address_t v6address;
6832 memset (mac_address, 0, sizeof (mac_address));
6834 /* Parse args required to build the message */
6835 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6837 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
6841 else if (unformat (i, "del"))
6843 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6844 sw_if_index_set = 1;
6845 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6846 sw_if_index_set = 1;
6847 else if (unformat (i, "is_static"))
6849 else if (unformat (i, "vrf %d", &vrf_id))
6851 else if (unformat (i, "dst %U", unformat_ip4_address, &v4address))
6853 else if (unformat (i, "dst %U", unformat_ip6_address, &v6address))
6857 clib_warning ("parse error '%U'", format_unformat_error, i);
6862 if (sw_if_index_set == 0)
6864 errmsg ("missing interface name or sw_if_index\n");
6867 if (v4_address_set && v6_address_set)
6869 errmsg ("both v4 and v6 addresses set\n");
6872 if (!v4_address_set && !v6_address_set)
6874 errmsg ("no address set\n");
6878 /* Construct the API message */
6879 M (IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
6881 mp->sw_if_index = ntohl (sw_if_index);
6882 mp->is_add = is_add;
6883 mp->vrf_id = ntohl (vrf_id);
6884 mp->is_static = is_static;
6886 clib_memcpy (mp->mac_address, mac_address, 6);
6890 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
6894 /* mp->is_ipv6 = 0; via memset in M macro above */
6895 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
6901 /* Wait for a reply, return good/bad news */
6909 api_reset_vrf (vat_main_t * vam)
6911 unformat_input_t *i = vam->input;
6912 vl_api_reset_vrf_t *mp;
6918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6920 if (unformat (i, "vrf %d", &vrf_id))
6922 else if (unformat (i, "ipv6"))
6926 clib_warning ("parse error '%U'", format_unformat_error, i);
6931 if (vrf_id_set == 0)
6933 errmsg ("missing vrf id\n");
6937 M (RESET_VRF, reset_vrf);
6939 mp->vrf_id = ntohl (vrf_id);
6940 mp->is_ipv6 = is_ipv6;
6949 api_create_vlan_subif (vat_main_t * vam)
6951 unformat_input_t *i = vam->input;
6952 vl_api_create_vlan_subif_t *mp;
6955 u8 sw_if_index_set = 0;
6959 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6961 if (unformat (i, "sw_if_index %d", &sw_if_index))
6962 sw_if_index_set = 1;
6963 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6964 sw_if_index_set = 1;
6965 else if (unformat (i, "vlan %d", &vlan_id))
6969 clib_warning ("parse error '%U'", format_unformat_error, i);
6974 if (sw_if_index_set == 0)
6976 errmsg ("missing interface name or sw_if_index\n");
6980 if (vlan_id_set == 0)
6982 errmsg ("missing vlan_id\n");
6985 M (CREATE_VLAN_SUBIF, create_vlan_subif);
6987 mp->sw_if_index = ntohl (sw_if_index);
6988 mp->vlan_id = ntohl (vlan_id);
6996 #define foreach_create_subif_bit \
7003 _(outer_vlan_id_any) \
7004 _(inner_vlan_id_any)
7007 api_create_subif (vat_main_t * vam)
7009 unformat_input_t *i = vam->input;
7010 vl_api_create_subif_t *mp;
7013 u8 sw_if_index_set = 0;
7020 u32 exact_match = 0;
7021 u32 default_sub = 0;
7022 u32 outer_vlan_id_any = 0;
7023 u32 inner_vlan_id_any = 0;
7025 u16 outer_vlan_id = 0;
7026 u16 inner_vlan_id = 0;
7028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7030 if (unformat (i, "sw_if_index %d", &sw_if_index))
7031 sw_if_index_set = 1;
7032 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7033 sw_if_index_set = 1;
7034 else if (unformat (i, "sub_id %d", &sub_id))
7036 else if (unformat (i, "outer_vlan_id %d", &tmp))
7037 outer_vlan_id = tmp;
7038 else if (unformat (i, "inner_vlan_id %d", &tmp))
7039 inner_vlan_id = tmp;
7041 #define _(a) else if (unformat (i, #a)) a = 1 ;
7042 foreach_create_subif_bit
7046 clib_warning ("parse error '%U'", format_unformat_error, i);
7051 if (sw_if_index_set == 0)
7053 errmsg ("missing interface name or sw_if_index\n");
7057 if (sub_id_set == 0)
7059 errmsg ("missing sub_id\n");
7062 M (CREATE_SUBIF, create_subif);
7064 mp->sw_if_index = ntohl (sw_if_index);
7065 mp->sub_id = ntohl (sub_id);
7067 #define _(a) mp->a = a;
7068 foreach_create_subif_bit;
7071 mp->outer_vlan_id = ntohs (outer_vlan_id);
7072 mp->inner_vlan_id = ntohs (inner_vlan_id);
7081 api_oam_add_del (vat_main_t * vam)
7083 unformat_input_t *i = vam->input;
7084 vl_api_oam_add_del_t *mp;
7088 ip4_address_t src, dst;
7092 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7094 if (unformat (i, "vrf %d", &vrf_id))
7096 else if (unformat (i, "src %U", unformat_ip4_address, &src))
7098 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
7100 else if (unformat (i, "del"))
7104 clib_warning ("parse error '%U'", format_unformat_error, i);
7111 errmsg ("missing src addr\n");
7117 errmsg ("missing dst addr\n");
7121 M (OAM_ADD_DEL, oam_add_del);
7123 mp->vrf_id = ntohl (vrf_id);
7124 mp->is_add = is_add;
7125 clib_memcpy (mp->src_address, &src, sizeof (mp->src_address));
7126 clib_memcpy (mp->dst_address, &dst, sizeof (mp->dst_address));
7135 api_reset_fib (vat_main_t * vam)
7137 unformat_input_t *i = vam->input;
7138 vl_api_reset_fib_t *mp;
7144 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7146 if (unformat (i, "vrf %d", &vrf_id))
7148 else if (unformat (i, "ipv6"))
7152 clib_warning ("parse error '%U'", format_unformat_error, i);
7157 if (vrf_id_set == 0)
7159 errmsg ("missing vrf id\n");
7163 M (RESET_FIB, reset_fib);
7165 mp->vrf_id = ntohl (vrf_id);
7166 mp->is_ipv6 = is_ipv6;
7175 api_dhcp_proxy_config (vat_main_t * vam)
7177 unformat_input_t *i = vam->input;
7178 vl_api_dhcp_proxy_config_t *mp;
7183 u8 v4_address_set = 0;
7184 u8 v6_address_set = 0;
7185 ip4_address_t v4address;
7186 ip6_address_t v6address;
7187 u8 v4_src_address_set = 0;
7188 u8 v6_src_address_set = 0;
7189 ip4_address_t v4srcaddress;
7190 ip6_address_t v6srcaddress;
7192 /* Parse args required to build the message */
7193 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7195 if (unformat (i, "del"))
7197 else if (unformat (i, "vrf %d", &vrf_id))
7199 else if (unformat (i, "insert-cid %d", &insert_cid))
7201 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7203 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7205 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7206 v4_src_address_set = 1;
7207 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7208 v6_src_address_set = 1;
7213 if (v4_address_set && v6_address_set)
7215 errmsg ("both v4 and v6 server addresses set\n");
7218 if (!v4_address_set && !v6_address_set)
7220 errmsg ("no server addresses set\n");
7224 if (v4_src_address_set && v6_src_address_set)
7226 errmsg ("both v4 and v6 src addresses set\n");
7229 if (!v4_src_address_set && !v6_src_address_set)
7231 errmsg ("no src addresses set\n");
7235 if (!(v4_src_address_set && v4_address_set) &&
7236 !(v6_src_address_set && v6_address_set))
7238 errmsg ("no matching server and src addresses set\n");
7242 /* Construct the API message */
7243 M (DHCP_PROXY_CONFIG, dhcp_proxy_config);
7245 mp->insert_circuit_id = insert_cid;
7246 mp->is_add = is_add;
7247 mp->vrf_id = ntohl (vrf_id);
7251 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7252 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7256 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7257 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7263 /* Wait for a reply, return good/bad news */
7270 api_dhcp_proxy_config_2 (vat_main_t * vam)
7272 unformat_input_t *i = vam->input;
7273 vl_api_dhcp_proxy_config_2_t *mp;
7276 u32 server_vrf_id = 0;
7279 u8 v4_address_set = 0;
7280 u8 v6_address_set = 0;
7281 ip4_address_t v4address;
7282 ip6_address_t v6address;
7283 u8 v4_src_address_set = 0;
7284 u8 v6_src_address_set = 0;
7285 ip4_address_t v4srcaddress;
7286 ip6_address_t v6srcaddress;
7288 /* Parse args required to build the message */
7289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7291 if (unformat (i, "del"))
7293 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
7295 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
7297 else if (unformat (i, "insert-cid %d", &insert_cid))
7299 else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
7301 else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
7303 else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
7304 v4_src_address_set = 1;
7305 else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
7306 v6_src_address_set = 1;
7311 if (v4_address_set && v6_address_set)
7313 errmsg ("both v4 and v6 server addresses set\n");
7316 if (!v4_address_set && !v6_address_set)
7318 errmsg ("no server addresses set\n");
7322 if (v4_src_address_set && v6_src_address_set)
7324 errmsg ("both v4 and v6 src addresses set\n");
7327 if (!v4_src_address_set && !v6_src_address_set)
7329 errmsg ("no src addresses set\n");
7333 if (!(v4_src_address_set && v4_address_set) &&
7334 !(v6_src_address_set && v6_address_set))
7336 errmsg ("no matching server and src addresses set\n");
7340 /* Construct the API message */
7341 M (DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
7343 mp->insert_circuit_id = insert_cid;
7344 mp->is_add = is_add;
7345 mp->rx_vrf_id = ntohl (rx_vrf_id);
7346 mp->server_vrf_id = ntohl (server_vrf_id);
7350 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
7351 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
7355 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
7356 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
7362 /* Wait for a reply, return good/bad news */
7369 api_dhcp_proxy_set_vss (vat_main_t * vam)
7371 unformat_input_t *i = vam->input;
7372 vl_api_dhcp_proxy_set_vss_t *mp;
7383 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7385 if (unformat (i, "tbl_id %d", &tbl_id))
7387 if (unformat (i, "fib_id %d", &fib_id))
7389 if (unformat (i, "oui %d", &oui))
7391 else if (unformat (i, "ipv6"))
7393 else if (unformat (i, "del"))
7397 clib_warning ("parse error '%U'", format_unformat_error, i);
7402 if (tbl_id_set == 0)
7404 errmsg ("missing tbl id\n");
7408 if (fib_id_set == 0)
7410 errmsg ("missing fib id\n");
7415 errmsg ("missing oui\n");
7419 M (DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
7420 mp->tbl_id = ntohl (tbl_id);
7421 mp->fib_id = ntohl (fib_id);
7422 mp->oui = ntohl (oui);
7423 mp->is_ipv6 = is_ipv6;
7424 mp->is_add = is_add;
7433 api_dhcp_client_config (vat_main_t * vam)
7435 unformat_input_t *i = vam->input;
7436 vl_api_dhcp_client_config_t *mp;
7439 u8 sw_if_index_set = 0;
7442 u8 disable_event = 0;
7444 /* Parse args required to build the message */
7445 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7447 if (unformat (i, "del"))
7449 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7450 sw_if_index_set = 1;
7451 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7452 sw_if_index_set = 1;
7453 else if (unformat (i, "hostname %s", &hostname))
7455 else if (unformat (i, "disable_event"))
7461 if (sw_if_index_set == 0)
7463 errmsg ("missing interface name or sw_if_index\n");
7467 if (vec_len (hostname) > 63)
7469 errmsg ("hostname too long\n");
7471 vec_add1 (hostname, 0);
7473 /* Construct the API message */
7474 M (DHCP_CLIENT_CONFIG, dhcp_client_config);
7476 mp->sw_if_index = ntohl (sw_if_index);
7477 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
7478 vec_free (hostname);
7479 mp->is_add = is_add;
7480 mp->want_dhcp_event = disable_event ? 0 : 1;
7481 mp->pid = getpid ();
7486 /* Wait for a reply, return good/bad news */
7493 api_set_ip_flow_hash (vat_main_t * vam)
7495 unformat_input_t *i = vam->input;
7496 vl_api_set_ip_flow_hash_t *mp;
7508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7510 if (unformat (i, "vrf %d", &vrf_id))
7512 else if (unformat (i, "ipv6"))
7514 else if (unformat (i, "src"))
7516 else if (unformat (i, "dst"))
7518 else if (unformat (i, "sport"))
7520 else if (unformat (i, "dport"))
7522 else if (unformat (i, "proto"))
7524 else if (unformat (i, "reverse"))
7529 clib_warning ("parse error '%U'", format_unformat_error, i);
7534 if (vrf_id_set == 0)
7536 errmsg ("missing vrf id\n");
7540 M (SET_IP_FLOW_HASH, set_ip_flow_hash);
7546 mp->reverse = reverse;
7547 mp->vrf_id = ntohl (vrf_id);
7548 mp->is_ipv6 = is_ipv6;
7557 api_sw_interface_ip6_enable_disable (vat_main_t * vam)
7559 unformat_input_t *i = vam->input;
7560 vl_api_sw_interface_ip6_enable_disable_t *mp;
7563 u8 sw_if_index_set = 0;
7566 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7568 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7569 sw_if_index_set = 1;
7570 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7571 sw_if_index_set = 1;
7572 else if (unformat (i, "enable"))
7574 else if (unformat (i, "disable"))
7578 clib_warning ("parse error '%U'", format_unformat_error, i);
7583 if (sw_if_index_set == 0)
7585 errmsg ("missing interface name or sw_if_index\n");
7589 M (SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
7591 mp->sw_if_index = ntohl (sw_if_index);
7592 mp->enable = enable;
7601 api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
7603 unformat_input_t *i = vam->input;
7604 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
7607 u8 sw_if_index_set = 0;
7608 u32 address_length = 0;
7609 u8 v6_address_set = 0;
7610 ip6_address_t v6address;
7612 /* Parse args required to build the message */
7613 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7615 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7616 sw_if_index_set = 1;
7617 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7618 sw_if_index_set = 1;
7619 else if (unformat (i, "%U/%d",
7620 unformat_ip6_address, &v6address, &address_length))
7626 if (sw_if_index_set == 0)
7628 errmsg ("missing interface name or sw_if_index\n");
7631 if (!v6_address_set)
7633 errmsg ("no address set\n");
7637 /* Construct the API message */
7638 M (SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS,
7639 sw_interface_ip6_set_link_local_address);
7641 mp->sw_if_index = ntohl (sw_if_index);
7642 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7643 mp->address_length = address_length;
7648 /* Wait for a reply, return good/bad news */
7657 api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
7659 unformat_input_t *i = vam->input;
7660 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
7663 u8 sw_if_index_set = 0;
7664 u32 address_length = 0;
7665 u8 v6_address_set = 0;
7666 ip6_address_t v6address;
7668 u8 no_advertise = 0;
7670 u8 no_autoconfig = 0;
7673 u32 val_lifetime = 0;
7674 u32 pref_lifetime = 0;
7676 /* Parse args required to build the message */
7677 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7679 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7680 sw_if_index_set = 1;
7681 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7682 sw_if_index_set = 1;
7683 else if (unformat (i, "%U/%d",
7684 unformat_ip6_address, &v6address, &address_length))
7686 else if (unformat (i, "val_life %d", &val_lifetime))
7688 else if (unformat (i, "pref_life %d", &pref_lifetime))
7690 else if (unformat (i, "def"))
7692 else if (unformat (i, "noadv"))
7694 else if (unformat (i, "offl"))
7696 else if (unformat (i, "noauto"))
7698 else if (unformat (i, "nolink"))
7700 else if (unformat (i, "isno"))
7704 clib_warning ("parse error '%U'", format_unformat_error, i);
7709 if (sw_if_index_set == 0)
7711 errmsg ("missing interface name or sw_if_index\n");
7714 if (!v6_address_set)
7716 errmsg ("no address set\n");
7720 /* Construct the API message */
7721 M (SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
7723 mp->sw_if_index = ntohl (sw_if_index);
7724 clib_memcpy (mp->address, &v6address, sizeof (v6address));
7725 mp->address_length = address_length;
7726 mp->use_default = use_default;
7727 mp->no_advertise = no_advertise;
7728 mp->off_link = off_link;
7729 mp->no_autoconfig = no_autoconfig;
7730 mp->no_onlink = no_onlink;
7732 mp->val_lifetime = ntohl (val_lifetime);
7733 mp->pref_lifetime = ntohl (pref_lifetime);
7738 /* Wait for a reply, return good/bad news */
7746 api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
7748 unformat_input_t *i = vam->input;
7749 vl_api_sw_interface_ip6nd_ra_config_t *mp;
7752 u8 sw_if_index_set = 0;
7757 u8 send_unicast = 0;
7760 u8 default_router = 0;
7761 u32 max_interval = 0;
7762 u32 min_interval = 0;
7764 u32 initial_count = 0;
7765 u32 initial_interval = 0;
7768 /* Parse args required to build the message */
7769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7771 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7772 sw_if_index_set = 1;
7773 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7774 sw_if_index_set = 1;
7775 else if (unformat (i, "maxint %d", &max_interval))
7777 else if (unformat (i, "minint %d", &min_interval))
7779 else if (unformat (i, "life %d", &lifetime))
7781 else if (unformat (i, "count %d", &initial_count))
7783 else if (unformat (i, "interval %d", &initial_interval))
7785 else if (unformat (i, "suppress") || unformat (i, "surpress"))
7787 else if (unformat (i, "managed"))
7789 else if (unformat (i, "other"))
7791 else if (unformat (i, "ll"))
7793 else if (unformat (i, "send"))
7795 else if (unformat (i, "cease"))
7797 else if (unformat (i, "isno"))
7799 else if (unformat (i, "def"))
7803 clib_warning ("parse error '%U'", format_unformat_error, i);
7808 if (sw_if_index_set == 0)
7810 errmsg ("missing interface name or sw_if_index\n");
7814 /* Construct the API message */
7815 M (SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
7817 mp->sw_if_index = ntohl (sw_if_index);
7818 mp->max_interval = ntohl (max_interval);
7819 mp->min_interval = ntohl (min_interval);
7820 mp->lifetime = ntohl (lifetime);
7821 mp->initial_count = ntohl (initial_count);
7822 mp->initial_interval = ntohl (initial_interval);
7823 mp->suppress = suppress;
7824 mp->managed = managed;
7826 mp->ll_option = ll_option;
7827 mp->send_unicast = send_unicast;
7830 mp->default_router = default_router;
7835 /* Wait for a reply, return good/bad news */
7843 api_set_arp_neighbor_limit (vat_main_t * vam)
7845 unformat_input_t *i = vam->input;
7846 vl_api_set_arp_neighbor_limit_t *mp;
7852 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7854 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
7856 else if (unformat (i, "ipv6"))
7860 clib_warning ("parse error '%U'", format_unformat_error, i);
7867 errmsg ("missing limit value\n");
7871 M (SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
7873 mp->arp_neighbor_limit = ntohl (arp_nbr_limit);
7874 mp->is_ipv6 = is_ipv6;
7883 api_l2_patch_add_del (vat_main_t * vam)
7885 unformat_input_t *i = vam->input;
7886 vl_api_l2_patch_add_del_t *mp;
7889 u8 rx_sw_if_index_set = 0;
7891 u8 tx_sw_if_index_set = 0;
7894 /* Parse args required to build the message */
7895 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7897 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
7898 rx_sw_if_index_set = 1;
7899 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
7900 tx_sw_if_index_set = 1;
7901 else if (unformat (i, "rx"))
7903 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7905 if (unformat (i, "%U", unformat_sw_if_index, vam,
7907 rx_sw_if_index_set = 1;
7912 else if (unformat (i, "tx"))
7914 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
7916 if (unformat (i, "%U", unformat_sw_if_index, vam,
7918 tx_sw_if_index_set = 1;
7923 else if (unformat (i, "del"))
7929 if (rx_sw_if_index_set == 0)
7931 errmsg ("missing rx interface name or rx_sw_if_index\n");
7935 if (tx_sw_if_index_set == 0)
7937 errmsg ("missing tx interface name or tx_sw_if_index\n");
7941 M (L2_PATCH_ADD_DEL, l2_patch_add_del);
7943 mp->rx_sw_if_index = ntohl (rx_sw_if_index);
7944 mp->tx_sw_if_index = ntohl (tx_sw_if_index);
7945 mp->is_add = is_add;
7954 api_ioam_enable (vat_main_t * vam)
7956 unformat_input_t *input = vam->input;
7957 vl_api_ioam_enable_t *mp;
7960 int has_trace_option = 0;
7961 int has_pot_option = 0;
7962 int has_seqno_option = 0;
7963 int has_analyse_option = 0;
7965 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
7967 if (unformat (input, "trace"))
7968 has_trace_option = 1;
7969 else if (unformat (input, "pot"))
7971 else if (unformat (input, "seqno"))
7972 has_seqno_option = 1;
7973 else if (unformat (input, "analyse"))
7974 has_analyse_option = 1;
7978 M (IOAM_ENABLE, ioam_enable);
7979 mp->id = htons (id);
7980 mp->seqno = has_seqno_option;
7981 mp->analyse = has_analyse_option;
7982 mp->pot_enable = has_pot_option;
7983 mp->trace_enable = has_trace_option;
7994 api_ioam_disable (vat_main_t * vam)
7996 vl_api_ioam_disable_t *mp;
7999 M (IOAM_DISABLE, ioam_disable);
8006 api_sr_tunnel_add_del (vat_main_t * vam)
8008 unformat_input_t *i = vam->input;
8009 vl_api_sr_tunnel_add_del_t *mp;
8013 ip6_address_t src_address;
8014 int src_address_set = 0;
8015 ip6_address_t dst_address;
8017 int dst_address_set = 0;
8019 u32 rx_table_id = 0;
8020 u32 tx_table_id = 0;
8021 ip6_address_t *segments = 0;
8022 ip6_address_t *this_seg;
8023 ip6_address_t *tags = 0;
8024 ip6_address_t *this_tag;
8025 ip6_address_t next_address, tag;
8027 u8 *policy_name = 0;
8029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8031 if (unformat (i, "del"))
8033 else if (unformat (i, "name %s", &name))
8035 else if (unformat (i, "policy %s", &policy_name))
8037 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
8039 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
8041 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
8042 src_address_set = 1;
8043 else if (unformat (i, "dst %U/%d",
8044 unformat_ip6_address, &dst_address, &dst_mask_width))
8045 dst_address_set = 1;
8046 else if (unformat (i, "next %U", unformat_ip6_address, &next_address))
8048 vec_add2 (segments, this_seg, 1);
8049 clib_memcpy (this_seg->as_u8, next_address.as_u8,
8050 sizeof (*this_seg));
8052 else if (unformat (i, "tag %U", unformat_ip6_address, &tag))
8054 vec_add2 (tags, this_tag, 1);
8055 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
8057 else if (unformat (i, "clean"))
8058 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
8059 else if (unformat (i, "protected"))
8060 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
8061 else if (unformat (i, "InPE %d", &pl_index))
8063 if (pl_index <= 0 || pl_index > 4)
8065 pl_index_range_error:
8066 errmsg ("pl index %d out of range\n", pl_index);
8070 IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3 * (pl_index - 1));
8072 else if (unformat (i, "EgPE %d", &pl_index))
8074 if (pl_index <= 0 || pl_index > 4)
8075 goto pl_index_range_error;
8077 IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3 * (pl_index - 1));
8079 else if (unformat (i, "OrgSrc %d", &pl_index))
8081 if (pl_index <= 0 || pl_index > 4)
8082 goto pl_index_range_error;
8084 IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3 * (pl_index - 1));
8090 if (!src_address_set)
8092 errmsg ("src address required\n");
8096 if (!dst_address_set)
8098 errmsg ("dst address required\n");
8104 errmsg ("at least one sr segment required\n");
8108 M2 (SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
8109 vec_len (segments) * sizeof (ip6_address_t)
8110 + vec_len (tags) * sizeof (ip6_address_t));
8112 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
8113 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
8114 mp->dst_mask_width = dst_mask_width;
8115 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
8116 mp->n_segments = vec_len (segments);
8117 mp->n_tags = vec_len (tags);
8118 mp->is_add = is_del == 0;
8119 clib_memcpy (mp->segs_and_tags, segments,
8120 vec_len (segments) * sizeof (ip6_address_t));
8121 clib_memcpy (mp->segs_and_tags +
8122 vec_len (segments) * sizeof (ip6_address_t), tags,
8123 vec_len (tags) * sizeof (ip6_address_t));
8125 mp->outer_vrf_id = ntohl (rx_table_id);
8126 mp->inner_vrf_id = ntohl (tx_table_id);
8127 memcpy (mp->name, name, vec_len (name));
8128 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8130 vec_free (segments);
8139 api_sr_policy_add_del (vat_main_t * vam)
8141 unformat_input_t *input = vam->input;
8142 vl_api_sr_policy_add_del_t *mp;
8146 u8 *tunnel_name = 0;
8147 u8 **tunnel_names = 0;
8152 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
8153 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
8155 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8157 if (unformat (input, "del"))
8159 else if (unformat (input, "name %s", &name))
8161 else if (unformat (input, "tunnel %s", &tunnel_name))
8165 vec_add1 (tunnel_names, tunnel_name);
8167 - length = #bytes to store in serial vector
8168 - +1 = byte to store that length
8170 tunnel_names_length += (vec_len (tunnel_name) + 1);
8181 errmsg ("policy name required\n");
8185 if ((!tunnel_set) && (!is_del))
8187 errmsg ("tunnel name required\n");
8191 M2 (SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
8195 mp->is_add = !is_del;
8197 memcpy (mp->name, name, vec_len (name));
8198 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
8199 u8 *serial_orig = 0;
8200 vec_validate (serial_orig, tunnel_names_length);
8201 *serial_orig = vec_len (tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
8202 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
8204 for (j = 0; j < vec_len (tunnel_names); j++)
8206 tun_name_len = vec_len (tunnel_names[j]);
8207 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
8208 serial_orig += 1; // Move along one byte to store the actual tunnel name
8209 memcpy (serial_orig, tunnel_names[j], tun_name_len);
8210 serial_orig += tun_name_len; // Advance past the copy
8212 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
8214 vec_free (tunnel_names);
8215 vec_free (tunnel_name);
8223 api_sr_multicast_map_add_del (vat_main_t * vam)
8225 unformat_input_t *input = vam->input;
8226 vl_api_sr_multicast_map_add_del_t *mp;
8229 ip6_address_t multicast_address;
8230 u8 *policy_name = 0;
8231 int multicast_address_set = 0;
8233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8235 if (unformat (input, "del"))
8239 (input, "address %U", unformat_ip6_address, &multicast_address))
8240 multicast_address_set = 1;
8241 else if (unformat (input, "sr-policy %s", &policy_name))
8247 if (!is_del && !policy_name)
8249 errmsg ("sr-policy name required\n");
8254 if (!multicast_address_set)
8256 errmsg ("address required\n");
8260 M (SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
8262 mp->is_add = !is_del;
8263 memcpy (mp->policy_name, policy_name, vec_len (policy_name));
8264 clib_memcpy (mp->multicast_address, &multicast_address,
8265 sizeof (mp->multicast_address));
8268 vec_free (policy_name);
8276 #define foreach_tcp_proto_field \
8280 #define foreach_udp_proto_field \
8284 #define foreach_ip4_proto_field \
8295 unformat_tcp_mask (unformat_input_t * input, va_list * args)
8297 u8 **maskp = va_arg (*args, u8 **);
8299 u8 found_something = 0;
8302 #define _(a) u8 a=0;
8303 foreach_tcp_proto_field;
8306 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8309 #define _(a) else if (unformat (input, #a)) a=1;
8310 foreach_tcp_proto_field
8316 #define _(a) found_something += a;
8317 foreach_tcp_proto_field;
8320 if (found_something == 0)
8323 vec_validate (mask, sizeof (*tcp) - 1);
8325 tcp = (tcp_header_t *) mask;
8327 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a));
8328 foreach_tcp_proto_field;
8336 unformat_udp_mask (unformat_input_t * input, va_list * args)
8338 u8 **maskp = va_arg (*args, u8 **);
8340 u8 found_something = 0;
8343 #define _(a) u8 a=0;
8344 foreach_udp_proto_field;
8347 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8350 #define _(a) else if (unformat (input, #a)) a=1;
8351 foreach_udp_proto_field
8357 #define _(a) found_something += a;
8358 foreach_udp_proto_field;
8361 if (found_something == 0)
8364 vec_validate (mask, sizeof (*udp) - 1);
8366 udp = (udp_header_t *) mask;
8368 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a));
8369 foreach_udp_proto_field;
8378 u16 src_port, dst_port;
8382 unformat_l4_mask (unformat_input_t * input, va_list * args)
8384 u8 **maskp = va_arg (*args, u8 **);
8385 u16 src_port = 0, dst_port = 0;
8386 tcpudp_header_t *tcpudp;
8388 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8390 if (unformat (input, "tcp %U", unformat_tcp_mask, maskp))
8392 else if (unformat (input, "udp %U", unformat_udp_mask, maskp))
8394 else if (unformat (input, "src_port"))
8396 else if (unformat (input, "dst_port"))
8402 if (!src_port && !dst_port)
8406 vec_validate (mask, sizeof (tcpudp_header_t) - 1);
8408 tcpudp = (tcpudp_header_t *) mask;
8409 tcpudp->src_port = src_port;
8410 tcpudp->dst_port = dst_port;
8418 unformat_ip4_mask (unformat_input_t * input, va_list * args)
8420 u8 **maskp = va_arg (*args, u8 **);
8422 u8 found_something = 0;
8425 #define _(a) u8 a=0;
8426 foreach_ip4_proto_field;
8432 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8434 if (unformat (input, "version"))
8436 else if (unformat (input, "hdr_length"))
8438 else if (unformat (input, "src"))
8440 else if (unformat (input, "dst"))
8442 else if (unformat (input, "proto"))
8445 #define _(a) else if (unformat (input, #a)) a=1;
8446 foreach_ip4_proto_field
8452 #define _(a) found_something += a;
8453 foreach_ip4_proto_field;
8456 if (found_something == 0)
8459 vec_validate (mask, sizeof (*ip) - 1);
8461 ip = (ip4_header_t *) mask;
8463 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8464 foreach_ip4_proto_field;
8467 ip->ip_version_and_header_length = 0;
8470 ip->ip_version_and_header_length |= 0xF0;
8473 ip->ip_version_and_header_length |= 0x0F;
8479 #define foreach_ip6_proto_field \
8487 unformat_ip6_mask (unformat_input_t * input, va_list * args)
8489 u8 **maskp = va_arg (*args, u8 **);
8491 u8 found_something = 0;
8493 u32 ip_version_traffic_class_and_flow_label;
8495 #define _(a) u8 a=0;
8496 foreach_ip6_proto_field;
8499 u8 traffic_class = 0;
8502 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8504 if (unformat (input, "version"))
8506 else if (unformat (input, "traffic-class"))
8508 else if (unformat (input, "flow-label"))
8510 else if (unformat (input, "src"))
8512 else if (unformat (input, "dst"))
8514 else if (unformat (input, "proto"))
8517 #define _(a) else if (unformat (input, #a)) a=1;
8518 foreach_ip6_proto_field
8524 #define _(a) found_something += a;
8525 foreach_ip6_proto_field;
8528 if (found_something == 0)
8531 vec_validate (mask, sizeof (*ip) - 1);
8533 ip = (ip6_header_t *) mask;
8535 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
8536 foreach_ip6_proto_field;
8539 ip_version_traffic_class_and_flow_label = 0;
8542 ip_version_traffic_class_and_flow_label |= 0xF0000000;
8545 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
8548 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
8550 ip->ip_version_traffic_class_and_flow_label =
8551 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
8558 unformat_l3_mask (unformat_input_t * input, va_list * args)
8560 u8 **maskp = va_arg (*args, u8 **);
8562 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8564 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
8566 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
8575 unformat_l2_mask (unformat_input_t * input, va_list * args)
8577 u8 **maskp = va_arg (*args, u8 **);
8592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8594 if (unformat (input, "src"))
8596 else if (unformat (input, "dst"))
8598 else if (unformat (input, "proto"))
8600 else if (unformat (input, "tag1"))
8602 else if (unformat (input, "tag2"))
8604 else if (unformat (input, "ignore-tag1"))
8606 else if (unformat (input, "ignore-tag2"))
8608 else if (unformat (input, "cos1"))
8610 else if (unformat (input, "cos2"))
8612 else if (unformat (input, "dot1q"))
8614 else if (unformat (input, "dot1ad"))
8619 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
8620 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
8623 if (tag1 || ignore_tag1 || cos1 || dot1q)
8625 if (tag2 || ignore_tag2 || cos2 || dot1ad)
8628 vec_validate (mask, len - 1);
8631 memset (mask, 0xff, 6);
8634 memset (mask + 6, 0xff, 6);
8638 /* inner vlan tag */
8647 mask[21] = mask[20] = 0xff;
8668 mask[16] = mask[17] = 0xff;
8678 mask[12] = mask[13] = 0xff;
8685 unformat_classify_mask (unformat_input_t * input, va_list * args)
8687 u8 **maskp = va_arg (*args, u8 **);
8688 u32 *skipp = va_arg (*args, u32 *);
8689 u32 *matchp = va_arg (*args, u32 *);
8697 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8699 if (unformat (input, "hex %U", unformat_hex_string, &mask))
8701 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
8703 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
8705 else if (unformat (input, "l4 %U", unformat_l4_mask, &l4))
8719 if (mask || l2 || l3 || l4)
8723 /* "With a free Ethernet header in every package" */
8725 vec_validate (l2, 13);
8729 vec_append (mask, l3);
8734 vec_append (mask, l4);
8739 /* Scan forward looking for the first significant mask octet */
8740 for (i = 0; i < vec_len (mask); i++)
8744 /* compute (skip, match) params */
8745 *skipp = i / sizeof (u32x4);
8746 vec_delete (mask, *skipp * sizeof (u32x4), 0);
8748 /* Pad mask to an even multiple of the vector size */
8749 while (vec_len (mask) % sizeof (u32x4))
8752 match = vec_len (mask) / sizeof (u32x4);
8754 for (i = match * sizeof (u32x4); i > 0; i -= sizeof (u32x4))
8756 u64 *tmp = (u64 *) (mask + (i - sizeof (u32x4)));
8757 if (*tmp || *(tmp + 1))
8762 clib_warning ("BUG: match 0");
8764 _vec_len (mask) = match * sizeof (u32x4);
8775 #define foreach_l2_next \
8777 _(ethernet, ETHERNET_INPUT) \
8782 unformat_l2_next_index (unformat_input_t * input, va_list * args)
8784 u32 *miss_next_indexp = va_arg (*args, u32 *);
8789 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;}
8793 if (unformat (input, "%d", &tmp))
8802 *miss_next_indexp = next_index;
8806 #define foreach_ip_next \
8812 unformat_ip_next_index (unformat_input_t * input, va_list * args)
8814 u32 *miss_next_indexp = va_arg (*args, u32 *);
8819 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
8823 if (unformat (input, "%d", &tmp))
8832 *miss_next_indexp = next_index;
8836 #define foreach_acl_next \
8840 unformat_acl_next_index (unformat_input_t * input, va_list * args)
8842 u32 *miss_next_indexp = va_arg (*args, u32 *);
8847 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
8851 if (unformat (input, "permit"))
8856 else if (unformat (input, "%d", &tmp))
8865 *miss_next_indexp = next_index;
8870 unformat_policer_precolor (unformat_input_t * input, va_list * args)
8872 u32 *r = va_arg (*args, u32 *);
8874 if (unformat (input, "conform-color"))
8875 *r = POLICE_CONFORM;
8876 else if (unformat (input, "exceed-color"))
8885 api_classify_add_del_table (vat_main_t * vam)
8887 unformat_input_t *i = vam->input;
8888 vl_api_classify_add_del_table_t *mp;
8894 u32 table_index = ~0;
8895 u32 next_table_index = ~0;
8896 u32 miss_next_index = ~0;
8897 u32 memory_size = 32 << 20;
8900 u32 current_data_flag = 0;
8901 int current_data_offset = 0;
8903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
8905 if (unformat (i, "del"))
8907 else if (unformat (i, "buckets %d", &nbuckets))
8909 else if (unformat (i, "memory_size %d", &memory_size))
8911 else if (unformat (i, "skip %d", &skip))
8913 else if (unformat (i, "match %d", &match))
8915 else if (unformat (i, "table %d", &table_index))
8917 else if (unformat (i, "mask %U", unformat_classify_mask,
8918 &mask, &skip, &match))
8920 else if (unformat (i, "next-table %d", &next_table_index))
8922 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
8925 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
8928 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
8931 else if (unformat (i, "current-data-flag %d", ¤t_data_flag))
8933 else if (unformat (i, "current-data-offset %d", ¤t_data_offset))
8939 if (is_add && mask == 0)
8941 errmsg ("Mask required\n");
8945 if (is_add && skip == ~0)
8947 errmsg ("skip count required\n");
8951 if (is_add && match == ~0)
8953 errmsg ("match count required\n");
8957 if (!is_add && table_index == ~0)
8959 errmsg ("table index required for delete\n");
8963 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table, vec_len (mask));
8965 mp->is_add = is_add;
8966 mp->table_index = ntohl (table_index);
8967 mp->nbuckets = ntohl (nbuckets);
8968 mp->memory_size = ntohl (memory_size);
8969 mp->skip_n_vectors = ntohl (skip);
8970 mp->match_n_vectors = ntohl (match);
8971 mp->next_table_index = ntohl (next_table_index);
8972 mp->miss_next_index = ntohl (miss_next_index);
8973 mp->current_data_flag = ntohl (current_data_flag);
8974 mp->current_data_offset = ntohl (current_data_offset);
8975 clib_memcpy (mp->mask, mask, vec_len (mask));
8985 unformat_l4_match (unformat_input_t * input, va_list * args)
8987 u8 **matchp = va_arg (*args, u8 **);
8989 u8 *proto_header = 0;
8995 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
8997 if (unformat (input, "src_port %d", &src_port))
8999 else if (unformat (input, "dst_port %d", &dst_port))
9005 h.src_port = clib_host_to_net_u16 (src_port);
9006 h.dst_port = clib_host_to_net_u16 (dst_port);
9007 vec_validate (proto_header, sizeof (h) - 1);
9008 memcpy (proto_header, &h, sizeof (h));
9010 *matchp = proto_header;
9016 unformat_ip4_match (unformat_input_t * input, va_list * args)
9018 u8 **matchp = va_arg (*args, u8 **);
9025 int src = 0, dst = 0;
9026 ip4_address_t src_val, dst_val;
9033 int fragment_id = 0;
9034 u32 fragment_id_val;
9040 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9042 if (unformat (input, "version %d", &version_val))
9044 else if (unformat (input, "hdr_length %d", &hdr_length_val))
9046 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
9048 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
9050 else if (unformat (input, "proto %d", &proto_val))
9052 else if (unformat (input, "tos %d", &tos_val))
9054 else if (unformat (input, "length %d", &length_val))
9056 else if (unformat (input, "fragment_id %d", &fragment_id_val))
9058 else if (unformat (input, "ttl %d", &ttl_val))
9060 else if (unformat (input, "checksum %d", &checksum_val))
9066 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
9067 + ttl + checksum == 0)
9071 * Aligned because we use the real comparison functions
9073 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9075 ip = (ip4_header_t *) match;
9077 /* These are realistically matched in practice */
9079 ip->src_address.as_u32 = src_val.as_u32;
9082 ip->dst_address.as_u32 = dst_val.as_u32;
9085 ip->protocol = proto_val;
9088 /* These are not, but they're included for completeness */
9090 ip->ip_version_and_header_length |= (version_val & 0xF) << 4;
9093 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
9099 ip->length = clib_host_to_net_u16 (length_val);
9105 ip->checksum = clib_host_to_net_u16 (checksum_val);
9112 unformat_ip6_match (unformat_input_t * input, va_list * args)
9114 u8 **matchp = va_arg (*args, u8 **);
9119 u8 traffic_class = 0;
9120 u32 traffic_class_val = 0;
9123 int src = 0, dst = 0;
9124 ip6_address_t src_val, dst_val;
9127 int payload_length = 0;
9128 u32 payload_length_val;
9131 u32 ip_version_traffic_class_and_flow_label;
9133 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9135 if (unformat (input, "version %d", &version_val))
9137 else if (unformat (input, "traffic_class %d", &traffic_class_val))
9139 else if (unformat (input, "flow_label %d", &flow_label_val))
9141 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
9143 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
9145 else if (unformat (input, "proto %d", &proto_val))
9147 else if (unformat (input, "payload_length %d", &payload_length_val))
9149 else if (unformat (input, "hop_limit %d", &hop_limit_val))
9155 if (version + traffic_class + flow_label + src + dst + proto +
9156 payload_length + hop_limit == 0)
9160 * Aligned because we use the real comparison functions
9162 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof (u32x4));
9164 ip = (ip6_header_t *) match;
9167 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
9170 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
9173 ip->protocol = proto_val;
9175 ip_version_traffic_class_and_flow_label = 0;
9178 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
9181 ip_version_traffic_class_and_flow_label |=
9182 (traffic_class_val & 0xFF) << 20;
9185 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
9187 ip->ip_version_traffic_class_and_flow_label =
9188 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
9191 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
9194 ip->hop_limit = hop_limit_val;
9201 unformat_l3_match (unformat_input_t * input, va_list * args)
9203 u8 **matchp = va_arg (*args, u8 **);
9205 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9207 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
9209 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
9218 unformat_vlan_tag (unformat_input_t * input, va_list * args)
9220 u8 *tagp = va_arg (*args, u8 *);
9223 if (unformat (input, "%d", &tag))
9225 tagp[0] = (tag >> 8) & 0x0F;
9226 tagp[1] = tag & 0xFF;
9234 unformat_l2_match (unformat_input_t * input, va_list * args)
9236 u8 **matchp = va_arg (*args, u8 **);
9256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9258 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
9261 if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
9263 else if (unformat (input, "proto %U",
9264 unformat_ethernet_type_host_byte_order, &proto_val))
9266 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
9268 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
9270 else if (unformat (input, "ignore-tag1"))
9272 else if (unformat (input, "ignore-tag2"))
9274 else if (unformat (input, "cos1 %d", &cos1_val))
9276 else if (unformat (input, "cos2 %d", &cos2_val))
9281 if ((src + dst + proto + tag1 + tag2 +
9282 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
9285 if (tag1 || ignore_tag1 || cos1)
9287 if (tag2 || ignore_tag2 || cos2)
9290 vec_validate_aligned (match, len - 1, sizeof (u32x4));
9293 clib_memcpy (match, dst_val, 6);
9296 clib_memcpy (match + 6, src_val, 6);
9300 /* inner vlan tag */
9301 match[19] = tag2_val[1];
9302 match[18] = tag2_val[0];
9304 match[18] |= (cos2_val & 0x7) << 5;
9307 match[21] = proto_val & 0xff;
9308 match[20] = proto_val >> 8;
9312 match[15] = tag1_val[1];
9313 match[14] = tag1_val[0];
9316 match[14] |= (cos1_val & 0x7) << 5;
9322 match[15] = tag1_val[1];
9323 match[14] = tag1_val[0];
9326 match[17] = proto_val & 0xff;
9327 match[16] = proto_val >> 8;
9330 match[14] |= (cos1_val & 0x7) << 5;
9336 match[18] |= (cos2_val & 0x7) << 5;
9338 match[14] |= (cos1_val & 0x7) << 5;
9341 match[13] = proto_val & 0xff;
9342 match[12] = proto_val >> 8;
9351 unformat_classify_match (unformat_input_t * input, va_list * args)
9353 u8 **matchp = va_arg (*args, u8 **);
9354 u32 skip_n_vectors = va_arg (*args, u32);
9355 u32 match_n_vectors = va_arg (*args, u32);
9362 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9364 if (unformat (input, "hex %U", unformat_hex_string, &match))
9366 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
9368 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
9370 else if (unformat (input, "l4 %U", unformat_l4_match, &l4))
9384 if (match || l2 || l3 || l4)
9388 /* "Win a free Ethernet header in every packet" */
9390 vec_validate_aligned (l2, 13, sizeof (u32x4));
9394 vec_append_aligned (match, l3, sizeof (u32x4));
9399 vec_append_aligned (match, l4, sizeof (u32x4));
9404 /* Make sure the vector is big enough even if key is all 0's */
9405 vec_validate_aligned
9406 (match, ((match_n_vectors + skip_n_vectors) * sizeof (u32x4)) - 1,
9409 /* Set size, include skipped vectors */
9410 _vec_len (match) = (match_n_vectors + skip_n_vectors) * sizeof (u32x4);
9421 api_classify_add_del_session (vat_main_t * vam)
9423 unformat_input_t *i = vam->input;
9424 vl_api_classify_add_del_session_t *mp;
9426 u32 table_index = ~0;
9427 u32 hit_next_index = ~0;
9428 u32 opaque_index = ~0;
9432 u32 skip_n_vectors = 0;
9433 u32 match_n_vectors = 0;
9438 * Warning: you have to supply skip_n and match_n
9439 * because the API client cant simply look at the classify
9443 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9445 if (unformat (i, "del"))
9447 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
9450 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
9453 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
9456 else if (unformat (i, "policer-hit-next %d", &hit_next_index))
9458 else if (unformat (i, "%U", unformat_policer_precolor, &opaque_index))
9460 else if (unformat (i, "opaque-index %d", &opaque_index))
9462 else if (unformat (i, "skip_n %d", &skip_n_vectors))
9464 else if (unformat (i, "match_n %d", &match_n_vectors))
9466 else if (unformat (i, "match %U", unformat_classify_match,
9467 &match, skip_n_vectors, match_n_vectors))
9469 else if (unformat (i, "advance %d", &advance))
9471 else if (unformat (i, "table-index %d", &table_index))
9473 else if (unformat (i, "action set-ip4-fib-id %d", &metadata))
9475 else if (unformat (i, "action set-ip6-fib-id %d", &metadata))
9477 else if (unformat (i, "action %d", &action))
9479 else if (unformat (i, "metadata %d", &metadata))
9485 if (table_index == ~0)
9487 errmsg ("Table index required\n");
9491 if (is_add && match == 0)
9493 errmsg ("Match value required\n");
9497 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session, vec_len (match));
9499 mp->is_add = is_add;
9500 mp->table_index = ntohl (table_index);
9501 mp->hit_next_index = ntohl (hit_next_index);
9502 mp->opaque_index = ntohl (opaque_index);
9503 mp->advance = ntohl (advance);
9504 mp->action = action;
9505 mp->metadata = ntohl (metadata);
9506 clib_memcpy (mp->match, match, vec_len (match));
9515 api_classify_set_interface_ip_table (vat_main_t * vam)
9517 unformat_input_t *i = vam->input;
9518 vl_api_classify_set_interface_ip_table_t *mp;
9521 int sw_if_index_set;
9522 u32 table_index = ~0;
9525 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9527 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9528 sw_if_index_set = 1;
9529 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9530 sw_if_index_set = 1;
9531 else if (unformat (i, "table %d", &table_index))
9535 clib_warning ("parse error '%U'", format_unformat_error, i);
9540 if (sw_if_index_set == 0)
9542 errmsg ("missing interface name or sw_if_index\n");
9547 M (CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
9549 mp->sw_if_index = ntohl (sw_if_index);
9550 mp->table_index = ntohl (table_index);
9551 mp->is_ipv6 = is_ipv6;
9560 api_classify_set_interface_l2_tables (vat_main_t * vam)
9562 unformat_input_t *i = vam->input;
9563 vl_api_classify_set_interface_l2_tables_t *mp;
9566 int sw_if_index_set;
9567 u32 ip4_table_index = ~0;
9568 u32 ip6_table_index = ~0;
9569 u32 other_table_index = ~0;
9572 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9574 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9575 sw_if_index_set = 1;
9576 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9577 sw_if_index_set = 1;
9578 else if (unformat (i, "ip4-table %d", &ip4_table_index))
9580 else if (unformat (i, "ip6-table %d", &ip6_table_index))
9582 else if (unformat (i, "other-table %d", &other_table_index))
9584 else if (unformat (i, "is-input %d", &is_input))
9588 clib_warning ("parse error '%U'", format_unformat_error, i);
9593 if (sw_if_index_set == 0)
9595 errmsg ("missing interface name or sw_if_index\n");
9600 M (CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
9602 mp->sw_if_index = ntohl (sw_if_index);
9603 mp->ip4_table_index = ntohl (ip4_table_index);
9604 mp->ip6_table_index = ntohl (ip6_table_index);
9605 mp->other_table_index = ntohl (other_table_index);
9606 mp->is_input = (u8) is_input;
9615 api_set_ipfix_exporter (vat_main_t * vam)
9617 unformat_input_t *i = vam->input;
9618 vl_api_set_ipfix_exporter_t *mp;
9619 ip4_address_t collector_address;
9620 u8 collector_address_set = 0;
9621 u32 collector_port = ~0;
9622 ip4_address_t src_address;
9623 u8 src_address_set = 0;
9626 u32 template_interval = ~0;
9627 u8 udp_checksum = 0;
9630 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9632 if (unformat (i, "collector_address %U", unformat_ip4_address,
9633 &collector_address))
9634 collector_address_set = 1;
9635 else if (unformat (i, "collector_port %d", &collector_port))
9637 else if (unformat (i, "src_address %U", unformat_ip4_address,
9639 src_address_set = 1;
9640 else if (unformat (i, "vrf_id %d", &vrf_id))
9642 else if (unformat (i, "path_mtu %d", &path_mtu))
9644 else if (unformat (i, "template_interval %d", &template_interval))
9646 else if (unformat (i, "udp_checksum"))
9652 if (collector_address_set == 0)
9654 errmsg ("collector_address required\n");
9658 if (src_address_set == 0)
9660 errmsg ("src_address required\n");
9664 M (SET_IPFIX_EXPORTER, set_ipfix_exporter);
9666 memcpy (mp->collector_address, collector_address.data,
9667 sizeof (collector_address.data));
9668 mp->collector_port = htons ((u16) collector_port);
9669 memcpy (mp->src_address, src_address.data, sizeof (src_address.data));
9670 mp->vrf_id = htonl (vrf_id);
9671 mp->path_mtu = htonl (path_mtu);
9672 mp->template_interval = htonl (template_interval);
9673 mp->udp_checksum = udp_checksum;
9681 api_set_ipfix_classify_stream (vat_main_t * vam)
9683 unformat_input_t *i = vam->input;
9684 vl_api_set_ipfix_classify_stream_t *mp;
9686 u32 src_port = UDP_DST_PORT_ipfix;
9689 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9691 if (unformat (i, "domain %d", &domain_id))
9693 else if (unformat (i, "src_port %d", &src_port))
9697 errmsg ("unknown input `%U'", format_unformat_error, i);
9702 M (SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream);
9704 mp->domain_id = htonl (domain_id);
9705 mp->src_port = htons ((u16) src_port);
9713 api_ipfix_classify_table_add_del (vat_main_t * vam)
9715 unformat_input_t *i = vam->input;
9716 vl_api_ipfix_classify_table_add_del_t *mp;
9718 u32 classify_table_index = ~0;
9720 u8 transport_protocol = 255;
9723 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9725 if (unformat (i, "add"))
9727 else if (unformat (i, "del"))
9729 else if (unformat (i, "table %d", &classify_table_index))
9731 else if (unformat (i, "ip4"))
9733 else if (unformat (i, "ip6"))
9735 else if (unformat (i, "tcp"))
9736 transport_protocol = 6;
9737 else if (unformat (i, "udp"))
9738 transport_protocol = 17;
9741 errmsg ("unknown input `%U'", format_unformat_error, i);
9748 errmsg ("expecting: add|del");
9751 if (classify_table_index == ~0)
9753 errmsg ("classifier table not specified");
9756 if (ip_version == 0)
9758 errmsg ("IP version not specified");
9762 M (IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del);
9764 mp->is_add = is_add;
9765 mp->table_id = htonl (classify_table_index);
9766 mp->ip_version = ip_version;
9767 mp->transport_protocol = transport_protocol;
9775 api_get_node_index (vat_main_t * vam)
9777 unformat_input_t *i = vam->input;
9778 vl_api_get_node_index_t *mp;
9782 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9784 if (unformat (i, "node %s", &name))
9791 errmsg ("node name required\n");
9794 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9796 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9800 M (GET_NODE_INDEX, get_node_index);
9801 clib_memcpy (mp->node_name, name, vec_len (name));
9811 api_get_next_index (vat_main_t * vam)
9813 unformat_input_t *i = vam->input;
9814 vl_api_get_next_index_t *mp;
9816 u8 *node_name = 0, *next_node_name = 0;
9818 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9820 if (unformat (i, "node-name %s", &node_name))
9822 else if (unformat (i, "next-node-name %s", &next_node_name))
9828 errmsg ("node name required\n");
9831 if (vec_len (node_name) >= ARRAY_LEN (mp->node_name))
9833 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9837 if (next_node_name == 0)
9839 errmsg ("next node name required\n");
9842 if (vec_len (next_node_name) >= ARRAY_LEN (mp->next_name))
9844 errmsg ("next node name too long, max %d\n", ARRAY_LEN (mp->next_name));
9848 M (GET_NEXT_INDEX, get_next_index);
9849 clib_memcpy (mp->node_name, node_name, vec_len (node_name));
9850 clib_memcpy (mp->next_name, next_node_name, vec_len (next_node_name));
9851 vec_free (node_name);
9852 vec_free (next_node_name);
9861 api_add_node_next (vat_main_t * vam)
9863 unformat_input_t *i = vam->input;
9864 vl_api_add_node_next_t *mp;
9869 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9871 if (unformat (i, "node %s", &name))
9873 else if (unformat (i, "next %s", &next))
9880 errmsg ("node name required\n");
9883 if (vec_len (name) >= ARRAY_LEN (mp->node_name))
9885 errmsg ("node name too long, max %d\n", ARRAY_LEN (mp->node_name));
9890 errmsg ("next node required\n");
9893 if (vec_len (next) >= ARRAY_LEN (mp->next_name))
9895 errmsg ("next name too long, max %d\n", ARRAY_LEN (mp->next_name));
9899 M (ADD_NODE_NEXT, add_node_next);
9900 clib_memcpy (mp->node_name, name, vec_len (name));
9901 clib_memcpy (mp->next_name, next, vec_len (next));
9912 api_l2tpv3_create_tunnel (vat_main_t * vam)
9914 unformat_input_t *i = vam->input;
9915 ip6_address_t client_address, our_address;
9916 int client_address_set = 0;
9917 int our_address_set = 0;
9918 u32 local_session_id = 0;
9919 u32 remote_session_id = 0;
9920 u64 local_cookie = 0;
9921 u64 remote_cookie = 0;
9922 u8 l2_sublayer_present = 0;
9923 vl_api_l2tpv3_create_tunnel_t *mp;
9926 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9928 if (unformat (i, "client_address %U", unformat_ip6_address,
9930 client_address_set = 1;
9931 else if (unformat (i, "our_address %U", unformat_ip6_address,
9933 our_address_set = 1;
9934 else if (unformat (i, "local_session_id %d", &local_session_id))
9936 else if (unformat (i, "remote_session_id %d", &remote_session_id))
9938 else if (unformat (i, "local_cookie %lld", &local_cookie))
9940 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
9942 else if (unformat (i, "l2-sublayer-present"))
9943 l2_sublayer_present = 1;
9948 if (client_address_set == 0)
9950 errmsg ("client_address required\n");
9954 if (our_address_set == 0)
9956 errmsg ("our_address required\n");
9960 M (L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
9962 clib_memcpy (mp->client_address, client_address.as_u8,
9963 sizeof (mp->client_address));
9965 clib_memcpy (mp->our_address, our_address.as_u8, sizeof (mp->our_address));
9967 mp->local_session_id = ntohl (local_session_id);
9968 mp->remote_session_id = ntohl (remote_session_id);
9969 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
9970 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
9971 mp->l2_sublayer_present = l2_sublayer_present;
9981 api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
9983 unformat_input_t *i = vam->input;
9985 u8 sw_if_index_set = 0;
9986 u64 new_local_cookie = 0;
9987 u64 new_remote_cookie = 0;
9988 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
9991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
9993 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
9994 sw_if_index_set = 1;
9995 else if (unformat (i, "sw_if_index %d", &sw_if_index))
9996 sw_if_index_set = 1;
9997 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
9999 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
10005 if (sw_if_index_set == 0)
10007 errmsg ("missing interface name or sw_if_index\n");
10011 M (L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
10013 mp->sw_if_index = ntohl (sw_if_index);
10014 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
10015 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
10024 api_l2tpv3_interface_enable_disable (vat_main_t * vam)
10026 unformat_input_t *i = vam->input;
10027 vl_api_l2tpv3_interface_enable_disable_t *mp;
10030 u8 sw_if_index_set = 0;
10031 u8 enable_disable = 1;
10033 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10035 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10036 sw_if_index_set = 1;
10037 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10038 sw_if_index_set = 1;
10039 else if (unformat (i, "enable"))
10040 enable_disable = 1;
10041 else if (unformat (i, "disable"))
10042 enable_disable = 0;
10047 if (sw_if_index_set == 0)
10049 errmsg ("missing interface name or sw_if_index\n");
10053 M (L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
10055 mp->sw_if_index = ntohl (sw_if_index);
10056 mp->enable_disable = enable_disable;
10065 api_l2tpv3_set_lookup_key (vat_main_t * vam)
10067 unformat_input_t *i = vam->input;
10068 vl_api_l2tpv3_set_lookup_key_t *mp;
10072 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10074 if (unformat (i, "lookup_v6_src"))
10075 key = L2T_LOOKUP_SRC_ADDRESS;
10076 else if (unformat (i, "lookup_v6_dst"))
10077 key = L2T_LOOKUP_DST_ADDRESS;
10078 else if (unformat (i, "lookup_session_id"))
10079 key = L2T_LOOKUP_SESSION_ID;
10084 if (key == (u8) ~ 0)
10086 errmsg ("l2tp session lookup key unset\n");
10090 M (L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
10100 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
10101 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10103 vat_main_t *vam = &vat_main;
10105 fformat (vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
10106 format_ip6_address, mp->our_address,
10107 format_ip6_address, mp->client_address,
10108 clib_net_to_host_u32 (mp->sw_if_index));
10111 " local cookies %016llx %016llx remote cookie %016llx\n",
10112 clib_net_to_host_u64 (mp->local_cookie[0]),
10113 clib_net_to_host_u64 (mp->local_cookie[1]),
10114 clib_net_to_host_u64 (mp->remote_cookie));
10116 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
10117 clib_net_to_host_u32 (mp->local_session_id),
10118 clib_net_to_host_u32 (mp->remote_session_id));
10120 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
10121 mp->l2_sublayer_present ? "preset" : "absent");
10125 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
10126 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
10128 vat_main_t *vam = &vat_main;
10129 vat_json_node_t *node = NULL;
10130 struct in6_addr addr;
10132 if (VAT_JSON_ARRAY != vam->json_tree.type)
10134 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10135 vat_json_init_array (&vam->json_tree);
10137 node = vat_json_array_add (&vam->json_tree);
10139 vat_json_init_object (node);
10141 clib_memcpy (&addr, mp->our_address, sizeof (addr));
10142 vat_json_object_add_ip6 (node, "our_address", addr);
10143 clib_memcpy (&addr, mp->client_address, sizeof (addr));
10144 vat_json_object_add_ip6 (node, "client_address", addr);
10146 vat_json_node_t *lc = vat_json_object_add (node, "local_cookie");
10147 vat_json_init_array (lc);
10148 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[0]));
10149 vat_json_array_add_uint (lc, clib_net_to_host_u64 (mp->local_cookie[1]));
10150 vat_json_object_add_uint (node, "remote_cookie",
10151 clib_net_to_host_u64 (mp->remote_cookie));
10153 printf ("local id: %u", clib_net_to_host_u32 (mp->local_session_id));
10154 vat_json_object_add_uint (node, "local_session_id",
10155 clib_net_to_host_u32 (mp->local_session_id));
10156 vat_json_object_add_uint (node, "remote_session_id",
10157 clib_net_to_host_u32 (mp->remote_session_id));
10158 vat_json_object_add_string_copy (node, "l2_sublayer",
10159 mp->l2_sublayer_present ? (u8 *) "present"
10160 : (u8 *) "absent");
10164 api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
10166 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
10169 /* Get list of l2tpv3-tunnel interfaces */
10170 M (SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
10173 /* Use a control ping for synchronization */
10175 vl_api_control_ping_t *mp;
10176 M (CONTROL_PING, control_ping);
10183 static void vl_api_sw_interface_tap_details_t_handler
10184 (vl_api_sw_interface_tap_details_t * mp)
10186 vat_main_t *vam = &vat_main;
10188 fformat (vam->ofp, "%-16s %d\n",
10189 mp->dev_name, clib_net_to_host_u32 (mp->sw_if_index));
10192 static void vl_api_sw_interface_tap_details_t_handler_json
10193 (vl_api_sw_interface_tap_details_t * mp)
10195 vat_main_t *vam = &vat_main;
10196 vat_json_node_t *node = NULL;
10198 if (VAT_JSON_ARRAY != vam->json_tree.type)
10200 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10201 vat_json_init_array (&vam->json_tree);
10203 node = vat_json_array_add (&vam->json_tree);
10205 vat_json_init_object (node);
10206 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10207 vat_json_object_add_string_copy (node, "dev_name", mp->dev_name);
10211 api_sw_interface_tap_dump (vat_main_t * vam)
10213 vl_api_sw_interface_tap_dump_t *mp;
10216 fformat (vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
10217 /* Get list of tap interfaces */
10218 M (SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
10221 /* Use a control ping for synchronization */
10223 vl_api_control_ping_t *mp;
10224 M (CONTROL_PING, control_ping);
10230 static uword unformat_vxlan_decap_next
10231 (unformat_input_t * input, va_list * args)
10233 u32 *result = va_arg (*args, u32 *);
10236 if (unformat (input, "l2"))
10237 *result = VXLAN_INPUT_NEXT_L2_INPUT;
10238 else if (unformat (input, "%d", &tmp))
10246 api_vxlan_add_del_tunnel (vat_main_t * vam)
10248 unformat_input_t *line_input = vam->input;
10249 vl_api_vxlan_add_del_tunnel_t *mp;
10251 ip46_address_t src, dst;
10253 u8 ipv4_set = 0, ipv6_set = 0;
10257 u32 mcast_sw_if_index = ~0;
10258 u32 encap_vrf_id = 0;
10259 u32 decap_next_index = ~0;
10262 /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
10263 memset (&src, 0, sizeof src);
10264 memset (&dst, 0, sizeof dst);
10266 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10268 if (unformat (line_input, "del"))
10271 if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4))
10277 if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4))
10283 if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6))
10289 if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6))
10294 else if (unformat (line_input, "group %U %U",
10295 unformat_ip4_address, &dst.ip4,
10296 unformat_sw_if_index, vam, &mcast_sw_if_index))
10298 grp_set = dst_set = 1;
10301 else if (unformat (line_input, "group %U",
10302 unformat_ip4_address, &dst.ip4))
10304 grp_set = dst_set = 1;
10307 else if (unformat (line_input, "group %U %U",
10308 unformat_ip6_address, &dst.ip6,
10309 unformat_sw_if_index, vam, &mcast_sw_if_index))
10311 grp_set = dst_set = 1;
10314 else if (unformat (line_input, "group %U",
10315 unformat_ip6_address, &dst.ip6))
10317 grp_set = dst_set = 1;
10321 if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
10323 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
10325 else if (unformat (line_input, "decap-next %U",
10326 unformat_vxlan_decap_next, &decap_next_index))
10328 else if (unformat (line_input, "vni %d", &vni))
10332 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10339 errmsg ("tunnel src address not specified\n");
10344 errmsg ("tunnel dst address not specified\n");
10348 if (grp_set && !ip46_address_is_multicast (&dst))
10350 errmsg ("tunnel group address not multicast\n");
10353 if (grp_set && mcast_sw_if_index == ~0)
10355 errmsg ("tunnel nonexistent multicast device\n");
10360 if (ipv4_set && ipv6_set)
10362 errmsg ("both IPv4 and IPv6 addresses specified");
10366 if ((vni == 0) || (vni >> 24))
10368 errmsg ("vni not specified or out of range\n");
10372 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
10376 clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
10377 clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
10381 clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
10382 clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
10384 mp->encap_vrf_id = ntohl (encap_vrf_id);
10385 mp->decap_next_index = ntohl (decap_next_index);
10386 mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
10387 mp->vni = ntohl (vni);
10388 mp->is_add = is_add;
10389 mp->is_ipv6 = ipv6_set;
10397 static void vl_api_vxlan_tunnel_details_t_handler
10398 (vl_api_vxlan_tunnel_details_t * mp)
10400 vat_main_t *vam = &vat_main;
10401 ip46_address_t src, dst;
10403 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &src);
10404 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &dst);
10406 fformat (vam->ofp, "%11d%24U%24U%14d%18d%13d%19d\n",
10407 ntohl (mp->sw_if_index),
10408 format_ip46_address, &src, IP46_TYPE_ANY,
10409 format_ip46_address, &dst, IP46_TYPE_ANY,
10410 ntohl (mp->encap_vrf_id),
10411 ntohl (mp->decap_next_index), ntohl (mp->vni),
10412 ntohl (mp->mcast_sw_if_index));
10415 static void vl_api_vxlan_tunnel_details_t_handler_json
10416 (vl_api_vxlan_tunnel_details_t * mp)
10418 vat_main_t *vam = &vat_main;
10419 vat_json_node_t *node = NULL;
10421 if (VAT_JSON_ARRAY != vam->json_tree.type)
10423 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10424 vat_json_init_array (&vam->json_tree);
10426 node = vat_json_array_add (&vam->json_tree);
10428 vat_json_init_object (node);
10429 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10432 struct in6_addr ip6;
10434 clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
10435 vat_json_object_add_ip6 (node, "src_address", ip6);
10436 clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
10437 vat_json_object_add_ip6 (node, "dst_address", ip6);
10441 struct in_addr ip4;
10443 clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
10444 vat_json_object_add_ip4 (node, "src_address", ip4);
10445 clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
10446 vat_json_object_add_ip4 (node, "dst_address", ip4);
10448 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
10449 vat_json_object_add_uint (node, "decap_next_index",
10450 ntohl (mp->decap_next_index));
10451 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
10452 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
10453 vat_json_object_add_uint (node, "mcast_sw_if_index",
10454 ntohl (mp->mcast_sw_if_index));
10458 api_vxlan_tunnel_dump (vat_main_t * vam)
10460 unformat_input_t *i = vam->input;
10461 vl_api_vxlan_tunnel_dump_t *mp;
10464 u8 sw_if_index_set = 0;
10466 /* Parse args required to build the message */
10467 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10469 if (unformat (i, "sw_if_index %d", &sw_if_index))
10470 sw_if_index_set = 1;
10475 if (sw_if_index_set == 0)
10480 if (!vam->json_output)
10482 fformat (vam->ofp, "%11s%24s%24s%14s%18s%13s%19s\n",
10483 "sw_if_index", "src_address", "dst_address",
10484 "encap_vrf_id", "decap_next_index", "vni",
10485 "mcast_sw_if_index");
10488 /* Get list of vxlan-tunnel interfaces */
10489 M (VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
10491 mp->sw_if_index = htonl (sw_if_index);
10495 /* Use a control ping for synchronization */
10497 vl_api_control_ping_t *mp;
10498 M (CONTROL_PING, control_ping);
10505 api_gre_add_del_tunnel (vat_main_t * vam)
10507 unformat_input_t *line_input = vam->input;
10508 vl_api_gre_add_del_tunnel_t *mp;
10510 ip4_address_t src4, dst4;
10515 u32 outer_fib_id = 0;
10517 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
10519 if (unformat (line_input, "del"))
10521 else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
10523 else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
10525 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
10527 else if (unformat (line_input, "teb"))
10531 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
10538 errmsg ("tunnel src address not specified\n");
10543 errmsg ("tunnel dst address not specified\n");
10548 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
10550 clib_memcpy (&mp->src_address, &src4, sizeof (src4));
10551 clib_memcpy (&mp->dst_address, &dst4, sizeof (dst4));
10552 mp->outer_fib_id = ntohl (outer_fib_id);
10553 mp->is_add = is_add;
10562 static void vl_api_gre_tunnel_details_t_handler
10563 (vl_api_gre_tunnel_details_t * mp)
10565 vat_main_t *vam = &vat_main;
10567 fformat (vam->ofp, "%11d%15U%15U%6d%14d\n",
10568 ntohl (mp->sw_if_index),
10569 format_ip4_address, &mp->src_address,
10570 format_ip4_address, &mp->dst_address,
10571 mp->teb, ntohl (mp->outer_fib_id));
10574 static void vl_api_gre_tunnel_details_t_handler_json
10575 (vl_api_gre_tunnel_details_t * mp)
10577 vat_main_t *vam = &vat_main;
10578 vat_json_node_t *node = NULL;
10579 struct in_addr ip4;
10581 if (VAT_JSON_ARRAY != vam->json_tree.type)
10583 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10584 vat_json_init_array (&vam->json_tree);
10586 node = vat_json_array_add (&vam->json_tree);
10588 vat_json_init_object (node);
10589 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10590 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
10591 vat_json_object_add_ip4 (node, "src_address", ip4);
10592 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
10593 vat_json_object_add_ip4 (node, "dst_address", ip4);
10594 vat_json_object_add_uint (node, "teb", mp->teb);
10595 vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
10599 api_gre_tunnel_dump (vat_main_t * vam)
10601 unformat_input_t *i = vam->input;
10602 vl_api_gre_tunnel_dump_t *mp;
10605 u8 sw_if_index_set = 0;
10607 /* Parse args required to build the message */
10608 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10610 if (unformat (i, "sw_if_index %d", &sw_if_index))
10611 sw_if_index_set = 1;
10616 if (sw_if_index_set == 0)
10621 if (!vam->json_output)
10623 fformat (vam->ofp, "%11s%15s%15s%6s%14s\n",
10624 "sw_if_index", "src_address", "dst_address", "teb",
10628 /* Get list of gre-tunnel interfaces */
10629 M (GRE_TUNNEL_DUMP, gre_tunnel_dump);
10631 mp->sw_if_index = htonl (sw_if_index);
10635 /* Use a control ping for synchronization */
10637 vl_api_control_ping_t *mp;
10638 M (CONTROL_PING, control_ping);
10645 api_l2_fib_clear_table (vat_main_t * vam)
10647 // unformat_input_t * i = vam->input;
10648 vl_api_l2_fib_clear_table_t *mp;
10651 M (L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
10660 api_l2_interface_efp_filter (vat_main_t * vam)
10662 unformat_input_t *i = vam->input;
10663 vl_api_l2_interface_efp_filter_t *mp;
10667 u8 sw_if_index_set = 0;
10669 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10671 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10672 sw_if_index_set = 1;
10673 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10674 sw_if_index_set = 1;
10675 else if (unformat (i, "enable"))
10677 else if (unformat (i, "disable"))
10681 clib_warning ("parse error '%U'", format_unformat_error, i);
10686 if (sw_if_index_set == 0)
10688 errmsg ("missing sw_if_index\n");
10692 M (L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
10694 mp->sw_if_index = ntohl (sw_if_index);
10695 mp->enable_disable = enable;
10703 #define foreach_vtr_op \
10704 _("disable", L2_VTR_DISABLED) \
10705 _("push-1", L2_VTR_PUSH_1) \
10706 _("push-2", L2_VTR_PUSH_2) \
10707 _("pop-1", L2_VTR_POP_1) \
10708 _("pop-2", L2_VTR_POP_2) \
10709 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
10710 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
10711 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
10712 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
10715 api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
10717 unformat_input_t *i = vam->input;
10718 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
10721 u8 sw_if_index_set = 0;
10724 u32 push_dot1q = 1;
10728 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10730 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10731 sw_if_index_set = 1;
10732 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10733 sw_if_index_set = 1;
10734 else if (unformat (i, "vtr_op %d", &vtr_op))
10736 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
10739 else if (unformat (i, "push_dot1q %d", &push_dot1q))
10741 else if (unformat (i, "tag1 %d", &tag1))
10743 else if (unformat (i, "tag2 %d", &tag2))
10747 clib_warning ("parse error '%U'", format_unformat_error, i);
10752 if ((sw_if_index_set == 0) || (vtr_op_set == 0))
10754 errmsg ("missing vtr operation or sw_if_index\n");
10758 M (L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
10759 mp->sw_if_index = ntohl (sw_if_index);
10760 mp->vtr_op = ntohl (vtr_op);
10761 mp->push_dot1q = ntohl (push_dot1q);
10762 mp->tag1 = ntohl (tag1);
10763 mp->tag2 = ntohl (tag2);
10772 api_create_vhost_user_if (vat_main_t * vam)
10774 unformat_input_t *i = vam->input;
10775 vl_api_create_vhost_user_if_t *mp;
10779 u8 file_name_set = 0;
10780 u32 custom_dev_instance = ~0;
10782 u8 use_custom_mac = 0;
10785 /* Shut up coverity */
10786 memset (hwaddr, 0, sizeof (hwaddr));
10788 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10790 if (unformat (i, "socket %s", &file_name))
10794 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10796 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
10797 use_custom_mac = 1;
10798 else if (unformat (i, "server"))
10800 else if (unformat (i, "tag %s", &tag))
10806 if (file_name_set == 0)
10808 errmsg ("missing socket file name\n");
10812 if (vec_len (file_name) > 255)
10814 errmsg ("socket file name too long\n");
10817 vec_add1 (file_name, 0);
10819 M (CREATE_VHOST_USER_IF, create_vhost_user_if);
10821 mp->is_server = is_server;
10822 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10823 vec_free (file_name);
10824 if (custom_dev_instance != ~0)
10827 mp->custom_dev_instance = ntohl (custom_dev_instance);
10829 mp->use_custom_mac = use_custom_mac;
10830 clib_memcpy (mp->mac_address, hwaddr, 6);
10832 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
10842 api_modify_vhost_user_if (vat_main_t * vam)
10844 unformat_input_t *i = vam->input;
10845 vl_api_modify_vhost_user_if_t *mp;
10849 u8 file_name_set = 0;
10850 u32 custom_dev_instance = ~0;
10851 u8 sw_if_index_set = 0;
10852 u32 sw_if_index = (u32) ~ 0;
10854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10856 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10857 sw_if_index_set = 1;
10858 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10859 sw_if_index_set = 1;
10860 else if (unformat (i, "socket %s", &file_name))
10864 else if (unformat (i, "renumber %" PRIu32, &custom_dev_instance))
10866 else if (unformat (i, "server"))
10872 if (sw_if_index_set == 0)
10874 errmsg ("missing sw_if_index or interface name\n");
10878 if (file_name_set == 0)
10880 errmsg ("missing socket file name\n");
10884 if (vec_len (file_name) > 255)
10886 errmsg ("socket file name too long\n");
10889 vec_add1 (file_name, 0);
10891 M (MODIFY_VHOST_USER_IF, modify_vhost_user_if);
10893 mp->sw_if_index = ntohl (sw_if_index);
10894 mp->is_server = is_server;
10895 clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
10896 vec_free (file_name);
10897 if (custom_dev_instance != ~0)
10900 mp->custom_dev_instance = ntohl (custom_dev_instance);
10910 api_delete_vhost_user_if (vat_main_t * vam)
10912 unformat_input_t *i = vam->input;
10913 vl_api_delete_vhost_user_if_t *mp;
10915 u32 sw_if_index = ~0;
10916 u8 sw_if_index_set = 0;
10918 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
10920 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
10921 sw_if_index_set = 1;
10922 else if (unformat (i, "sw_if_index %d", &sw_if_index))
10923 sw_if_index_set = 1;
10928 if (sw_if_index_set == 0)
10930 errmsg ("missing sw_if_index or interface name\n");
10935 M (DELETE_VHOST_USER_IF, delete_vhost_user_if);
10937 mp->sw_if_index = ntohl (sw_if_index);
10945 static void vl_api_sw_interface_vhost_user_details_t_handler
10946 (vl_api_sw_interface_vhost_user_details_t * mp)
10948 vat_main_t *vam = &vat_main;
10950 fformat (vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
10951 (char *) mp->interface_name,
10952 ntohl (mp->sw_if_index), ntohl (mp->virtio_net_hdr_sz),
10953 clib_net_to_host_u64 (mp->features), mp->is_server,
10954 ntohl (mp->num_regions), (char *) mp->sock_filename);
10955 fformat (vam->ofp, " Status: '%s'\n", strerror (ntohl (mp->sock_errno)));
10958 static void vl_api_sw_interface_vhost_user_details_t_handler_json
10959 (vl_api_sw_interface_vhost_user_details_t * mp)
10961 vat_main_t *vam = &vat_main;
10962 vat_json_node_t *node = NULL;
10964 if (VAT_JSON_ARRAY != vam->json_tree.type)
10966 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
10967 vat_json_init_array (&vam->json_tree);
10969 node = vat_json_array_add (&vam->json_tree);
10971 vat_json_init_object (node);
10972 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
10973 vat_json_object_add_string_copy (node, "interface_name",
10974 mp->interface_name);
10975 vat_json_object_add_uint (node, "virtio_net_hdr_sz",
10976 ntohl (mp->virtio_net_hdr_sz));
10977 vat_json_object_add_uint (node, "features",
10978 clib_net_to_host_u64 (mp->features));
10979 vat_json_object_add_uint (node, "is_server", mp->is_server);
10980 vat_json_object_add_string_copy (node, "sock_filename", mp->sock_filename);
10981 vat_json_object_add_uint (node, "num_regions", ntohl (mp->num_regions));
10982 vat_json_object_add_uint (node, "sock_errno", ntohl (mp->sock_errno));
10986 api_sw_interface_vhost_user_dump (vat_main_t * vam)
10988 vl_api_sw_interface_vhost_user_dump_t *mp;
10991 "Interface name idx hdr_sz features server regions filename\n");
10993 /* Get list of vhost-user interfaces */
10994 M (SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
10997 /* Use a control ping for synchronization */
10999 vl_api_control_ping_t *mp;
11000 M (CONTROL_PING, control_ping);
11007 api_show_version (vat_main_t * vam)
11009 vl_api_show_version_t *mp;
11012 M (SHOW_VERSION, show_version);
11022 api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
11024 unformat_input_t *line_input = vam->input;
11025 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
11027 ip4_address_t local4, remote4;
11028 ip6_address_t local6, remote6;
11030 u8 ipv4_set = 0, ipv6_set = 0;
11033 u32 encap_vrf_id = 0;
11034 u32 decap_vrf_id = 0;
11039 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11041 if (unformat (line_input, "del"))
11043 else if (unformat (line_input, "local %U",
11044 unformat_ip4_address, &local4))
11049 else if (unformat (line_input, "remote %U",
11050 unformat_ip4_address, &remote4))
11055 else if (unformat (line_input, "local %U",
11056 unformat_ip6_address, &local6))
11061 else if (unformat (line_input, "remote %U",
11062 unformat_ip6_address, &remote6))
11067 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
11069 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
11071 else if (unformat (line_input, "vni %d", &vni))
11073 else if (unformat (line_input, "next-ip4"))
11075 else if (unformat (line_input, "next-ip6"))
11077 else if (unformat (line_input, "next-ethernet"))
11079 else if (unformat (line_input, "next-nsh"))
11083 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
11088 if (local_set == 0)
11090 errmsg ("tunnel local address not specified\n");
11093 if (remote_set == 0)
11095 errmsg ("tunnel remote address not specified\n");
11098 if (ipv4_set && ipv6_set)
11100 errmsg ("both IPv4 and IPv6 addresses specified");
11106 errmsg ("vni not specified\n");
11110 M (VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
11115 clib_memcpy (&mp->local, &local6, sizeof (local6));
11116 clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
11120 clib_memcpy (&mp->local, &local4, sizeof (local4));
11121 clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
11124 mp->encap_vrf_id = ntohl (encap_vrf_id);
11125 mp->decap_vrf_id = ntohl (decap_vrf_id);
11126 mp->protocol = ntohl (protocol);
11127 mp->vni = ntohl (vni);
11128 mp->is_add = is_add;
11129 mp->is_ipv6 = ipv6_set;
11137 static void vl_api_vxlan_gpe_tunnel_details_t_handler
11138 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11140 vat_main_t *vam = &vat_main;
11142 fformat (vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
11143 ntohl (mp->sw_if_index),
11144 format_ip46_address, &(mp->local[0]),
11145 format_ip46_address, &(mp->remote[0]),
11147 ntohl (mp->protocol),
11148 ntohl (mp->encap_vrf_id), ntohl (mp->decap_vrf_id));
11151 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
11152 (vl_api_vxlan_gpe_tunnel_details_t * mp)
11154 vat_main_t *vam = &vat_main;
11155 vat_json_node_t *node = NULL;
11156 struct in_addr ip4;
11157 struct in6_addr ip6;
11159 if (VAT_JSON_ARRAY != vam->json_tree.type)
11161 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11162 vat_json_init_array (&vam->json_tree);
11164 node = vat_json_array_add (&vam->json_tree);
11166 vat_json_init_object (node);
11167 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11170 clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
11171 vat_json_object_add_ip6 (node, "local", ip6);
11172 clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
11173 vat_json_object_add_ip6 (node, "remote", ip6);
11177 clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
11178 vat_json_object_add_ip4 (node, "local", ip4);
11179 clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
11180 vat_json_object_add_ip4 (node, "remote", ip4);
11182 vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
11183 vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
11184 vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
11185 vat_json_object_add_uint (node, "decap_vrf_id", ntohl (mp->decap_vrf_id));
11186 vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
11190 api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
11192 unformat_input_t *i = vam->input;
11193 vl_api_vxlan_gpe_tunnel_dump_t *mp;
11196 u8 sw_if_index_set = 0;
11198 /* Parse args required to build the message */
11199 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11201 if (unformat (i, "sw_if_index %d", &sw_if_index))
11202 sw_if_index_set = 1;
11207 if (sw_if_index_set == 0)
11212 if (!vam->json_output)
11214 fformat (vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
11215 "sw_if_index", "local", "remote", "vni",
11216 "protocol", "encap_vrf_id", "decap_vrf_id");
11219 /* Get list of vxlan-tunnel interfaces */
11220 M (VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
11222 mp->sw_if_index = htonl (sw_if_index);
11226 /* Use a control ping for synchronization */
11228 vl_api_control_ping_t *mp;
11229 M (CONTROL_PING, control_ping);
11236 format_l2_fib_mac_address (u8 * s, va_list * args)
11238 u8 *a = va_arg (*args, u8 *);
11240 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
11241 a[2], a[3], a[4], a[5], a[6], a[7]);
11244 static void vl_api_l2_fib_table_entry_t_handler
11245 (vl_api_l2_fib_table_entry_t * mp)
11247 vat_main_t *vam = &vat_main;
11249 fformat (vam->ofp, "%3" PRIu32 " %U %3" PRIu32
11251 ntohl (mp->bd_id), format_l2_fib_mac_address, &mp->mac,
11252 ntohl (mp->sw_if_index), mp->static_mac, mp->filter_mac,
11256 static void vl_api_l2_fib_table_entry_t_handler_json
11257 (vl_api_l2_fib_table_entry_t * mp)
11259 vat_main_t *vam = &vat_main;
11260 vat_json_node_t *node = NULL;
11262 if (VAT_JSON_ARRAY != vam->json_tree.type)
11264 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
11265 vat_json_init_array (&vam->json_tree);
11267 node = vat_json_array_add (&vam->json_tree);
11269 vat_json_init_object (node);
11270 vat_json_object_add_uint (node, "bd_id", ntohl (mp->bd_id));
11271 vat_json_object_add_uint (node, "mac", clib_net_to_host_u64 (mp->mac));
11272 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
11273 vat_json_object_add_uint (node, "static_mac", mp->static_mac);
11274 vat_json_object_add_uint (node, "filter_mac", mp->filter_mac);
11275 vat_json_object_add_uint (node, "bvi_mac", mp->bvi_mac);
11279 api_l2_fib_table_dump (vat_main_t * vam)
11281 unformat_input_t *i = vam->input;
11282 vl_api_l2_fib_table_dump_t *mp;
11287 /* Parse args required to build the message */
11288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11290 if (unformat (i, "bd_id %d", &bd_id))
11296 if (bd_id_set == 0)
11298 errmsg ("missing bridge domain\n");
11303 "BD-ID Mac Address sw-ndx Static Filter BVI\n");
11305 /* Get list of l2 fib entries */
11306 M (L2_FIB_TABLE_DUMP, l2_fib_table_dump);
11308 mp->bd_id = ntohl (bd_id);
11311 /* Use a control ping for synchronization */
11313 vl_api_control_ping_t *mp;
11314 M (CONTROL_PING, control_ping);
11322 api_interface_name_renumber (vat_main_t * vam)
11324 unformat_input_t *line_input = vam->input;
11325 vl_api_interface_name_renumber_t *mp;
11326 u32 sw_if_index = ~0;
11328 u32 new_show_dev_instance = ~0;
11330 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11332 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
11335 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
11337 else if (unformat (line_input, "new_show_dev_instance %d",
11338 &new_show_dev_instance))
11344 if (sw_if_index == ~0)
11346 errmsg ("missing interface name or sw_if_index\n");
11350 if (new_show_dev_instance == ~0)
11352 errmsg ("missing new_show_dev_instance\n");
11356 M (INTERFACE_NAME_RENUMBER, interface_name_renumber);
11358 mp->sw_if_index = ntohl (sw_if_index);
11359 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
11366 api_want_ip4_arp_events (vat_main_t * vam)
11368 unformat_input_t *line_input = vam->input;
11369 vl_api_want_ip4_arp_events_t *mp;
11371 ip4_address_t address;
11372 int address_set = 0;
11373 u32 enable_disable = 1;
11375 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11377 if (unformat (line_input, "address %U", unformat_ip4_address, &address))
11379 else if (unformat (line_input, "del"))
11380 enable_disable = 0;
11385 if (address_set == 0)
11387 errmsg ("missing addresses\n");
11391 M (WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
11392 mp->enable_disable = enable_disable;
11393 mp->pid = getpid ();
11394 mp->address = address.as_u32;
11401 api_want_ip6_nd_events (vat_main_t * vam)
11403 unformat_input_t *line_input = vam->input;
11404 vl_api_want_ip6_nd_events_t *mp;
11406 ip6_address_t address;
11407 int address_set = 0;
11408 u32 enable_disable = 1;
11410 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
11412 if (unformat (line_input, "address %U", unformat_ip6_address, &address))
11414 else if (unformat (line_input, "del"))
11415 enable_disable = 0;
11420 if (address_set == 0)
11422 errmsg ("missing addresses\n");
11426 M (WANT_IP6_ND_EVENTS, want_ip6_nd_events);
11427 mp->enable_disable = enable_disable;
11428 mp->pid = getpid ();
11429 clib_memcpy (mp->address, &address, sizeof (ip6_address_t));
11436 api_input_acl_set_interface (vat_main_t * vam)
11438 unformat_input_t *i = vam->input;
11439 vl_api_input_acl_set_interface_t *mp;
11442 int sw_if_index_set;
11443 u32 ip4_table_index = ~0;
11444 u32 ip6_table_index = ~0;
11445 u32 l2_table_index = ~0;
11448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11450 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11451 sw_if_index_set = 1;
11452 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11453 sw_if_index_set = 1;
11454 else if (unformat (i, "del"))
11456 else if (unformat (i, "ip4-table %d", &ip4_table_index))
11458 else if (unformat (i, "ip6-table %d", &ip6_table_index))
11460 else if (unformat (i, "l2-table %d", &l2_table_index))
11464 clib_warning ("parse error '%U'", format_unformat_error, i);
11469 if (sw_if_index_set == 0)
11471 errmsg ("missing interface name or sw_if_index\n");
11475 M (INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
11477 mp->sw_if_index = ntohl (sw_if_index);
11478 mp->ip4_table_index = ntohl (ip4_table_index);
11479 mp->ip6_table_index = ntohl (ip6_table_index);
11480 mp->l2_table_index = ntohl (l2_table_index);
11481 mp->is_add = is_add;
11490 api_ip_address_dump (vat_main_t * vam)
11492 unformat_input_t *i = vam->input;
11493 vl_api_ip_address_dump_t *mp;
11494 u32 sw_if_index = ~0;
11495 u8 sw_if_index_set = 0;
11500 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11502 if (unformat (i, "sw_if_index %d", &sw_if_index))
11503 sw_if_index_set = 1;
11504 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11505 sw_if_index_set = 1;
11506 else if (unformat (i, "ipv4"))
11508 else if (unformat (i, "ipv6"))
11514 if (ipv4_set && ipv6_set)
11516 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11520 if ((!ipv4_set) && (!ipv6_set))
11522 errmsg ("no ipv4 nor ipv6 flag set\n");
11526 if (sw_if_index_set == 0)
11528 errmsg ("missing interface name or sw_if_index\n");
11532 vam->current_sw_if_index = sw_if_index;
11533 vam->is_ipv6 = ipv6_set;
11535 M (IP_ADDRESS_DUMP, ip_address_dump);
11536 mp->sw_if_index = ntohl (sw_if_index);
11537 mp->is_ipv6 = ipv6_set;
11540 /* Use a control ping for synchronization */
11542 vl_api_control_ping_t *mp;
11543 M (CONTROL_PING, control_ping);
11550 api_ip_dump (vat_main_t * vam)
11552 vl_api_ip_dump_t *mp;
11553 unformat_input_t *in = vam->input;
11560 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT)
11562 if (unformat (in, "ipv4"))
11564 else if (unformat (in, "ipv6"))
11570 if (ipv4_set && ipv6_set)
11572 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
11576 if ((!ipv4_set) && (!ipv6_set))
11578 errmsg ("no ipv4 nor ipv6 flag set\n");
11582 is_ipv6 = ipv6_set;
11583 vam->is_ipv6 = is_ipv6;
11585 /* free old data */
11586 for (i = 0; i < vec_len (vam->ip_details_by_sw_if_index[is_ipv6]); i++)
11588 vec_free (vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
11590 vec_free (vam->ip_details_by_sw_if_index[is_ipv6]);
11592 M (IP_DUMP, ip_dump);
11593 mp->is_ipv6 = ipv6_set;
11596 /* Use a control ping for synchronization */
11598 vl_api_control_ping_t *mp;
11599 M (CONTROL_PING, control_ping);
11606 api_ipsec_spd_add_del (vat_main_t * vam)
11608 unformat_input_t *i = vam->input;
11609 vl_api_ipsec_spd_add_del_t *mp;
11614 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11616 if (unformat (i, "spd_id %d", &spd_id))
11618 else if (unformat (i, "del"))
11622 clib_warning ("parse error '%U'", format_unformat_error, i);
11628 errmsg ("spd_id must be set\n");
11632 M (IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
11634 mp->spd_id = ntohl (spd_id);
11635 mp->is_add = is_add;
11644 api_ipsec_interface_add_del_spd (vat_main_t * vam)
11646 unformat_input_t *i = vam->input;
11647 vl_api_ipsec_interface_add_del_spd_t *mp;
11650 u8 sw_if_index_set = 0;
11651 u32 spd_id = (u32) ~ 0;
11654 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11656 if (unformat (i, "del"))
11658 else if (unformat (i, "spd_id %d", &spd_id))
11660 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
11661 sw_if_index_set = 1;
11662 else if (unformat (i, "sw_if_index %d", &sw_if_index))
11663 sw_if_index_set = 1;
11666 clib_warning ("parse error '%U'", format_unformat_error, i);
11672 if (spd_id == (u32) ~ 0)
11674 errmsg ("spd_id must be set\n");
11678 if (sw_if_index_set == 0)
11680 errmsg ("missing interface name or sw_if_index\n");
11684 M (IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
11686 mp->spd_id = ntohl (spd_id);
11687 mp->sw_if_index = ntohl (sw_if_index);
11688 mp->is_add = is_add;
11697 api_ipsec_spd_add_del_entry (vat_main_t * vam)
11699 unformat_input_t *i = vam->input;
11700 vl_api_ipsec_spd_add_del_entry_t *mp;
11702 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
11703 u32 spd_id = 0, sa_id = 0, protocol = 0, policy = 0;
11705 u32 rport_start = 0, rport_stop = (u32) ~ 0;
11706 u32 lport_start = 0, lport_stop = (u32) ~ 0;
11707 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
11708 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
11710 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
11711 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~ 0;
11712 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
11713 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
11714 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~ 0;
11715 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~ 0;
11717 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11719 if (unformat (i, "del"))
11721 if (unformat (i, "outbound"))
11723 if (unformat (i, "inbound"))
11725 else if (unformat (i, "spd_id %d", &spd_id))
11727 else if (unformat (i, "sa_id %d", &sa_id))
11729 else if (unformat (i, "priority %d", &priority))
11731 else if (unformat (i, "protocol %d", &protocol))
11733 else if (unformat (i, "lport_start %d", &lport_start))
11735 else if (unformat (i, "lport_stop %d", &lport_stop))
11737 else if (unformat (i, "rport_start %d", &rport_start))
11739 else if (unformat (i, "rport_stop %d", &rport_stop))
11743 (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
11749 if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
11756 (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
11762 if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
11769 (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
11775 if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
11782 (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
11788 if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
11794 if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
11796 if (policy == IPSEC_POLICY_ACTION_RESOLVE)
11798 clib_warning ("unsupported action: 'resolve'");
11804 clib_warning ("parse error '%U'", format_unformat_error, i);
11810 M (IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
11812 mp->spd_id = ntohl (spd_id);
11813 mp->priority = ntohl (priority);
11814 mp->is_outbound = is_outbound;
11816 mp->is_ipv6 = is_ipv6;
11817 if (is_ipv6 || is_ip_any)
11819 clib_memcpy (mp->remote_address_start, &raddr6_start,
11820 sizeof (ip6_address_t));
11821 clib_memcpy (mp->remote_address_stop, &raddr6_stop,
11822 sizeof (ip6_address_t));
11823 clib_memcpy (mp->local_address_start, &laddr6_start,
11824 sizeof (ip6_address_t));
11825 clib_memcpy (mp->local_address_stop, &laddr6_stop,
11826 sizeof (ip6_address_t));
11830 clib_memcpy (mp->remote_address_start, &raddr4_start,
11831 sizeof (ip4_address_t));
11832 clib_memcpy (mp->remote_address_stop, &raddr4_stop,
11833 sizeof (ip4_address_t));
11834 clib_memcpy (mp->local_address_start, &laddr4_start,
11835 sizeof (ip4_address_t));
11836 clib_memcpy (mp->local_address_stop, &laddr4_stop,
11837 sizeof (ip4_address_t));
11839 mp->protocol = (u8) protocol;
11840 mp->local_port_start = ntohs ((u16) lport_start);
11841 mp->local_port_stop = ntohs ((u16) lport_stop);
11842 mp->remote_port_start = ntohs ((u16) rport_start);
11843 mp->remote_port_stop = ntohs ((u16) rport_stop);
11844 mp->policy = (u8) policy;
11845 mp->sa_id = ntohl (sa_id);
11846 mp->is_add = is_add;
11847 mp->is_ip_any = is_ip_any;
11855 api_ipsec_sad_add_del_entry (vat_main_t * vam)
11857 unformat_input_t *i = vam->input;
11858 vl_api_ipsec_sad_add_del_entry_t *mp;
11860 u32 sad_id = 0, spi = 0;
11861 u8 *ck = 0, *ik = 0;
11864 u8 protocol = IPSEC_PROTOCOL_AH;
11865 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
11866 u32 crypto_alg = 0, integ_alg = 0;
11867 ip4_address_t tun_src4;
11868 ip4_address_t tun_dst4;
11869 ip6_address_t tun_src6;
11870 ip6_address_t tun_dst6;
11872 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
11874 if (unformat (i, "del"))
11876 else if (unformat (i, "sad_id %d", &sad_id))
11878 else if (unformat (i, "spi %d", &spi))
11880 else if (unformat (i, "esp"))
11881 protocol = IPSEC_PROTOCOL_ESP;
11882 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4))
11885 is_tunnel_ipv6 = 0;
11887 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4))
11890 is_tunnel_ipv6 = 0;
11892 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6))
11895 is_tunnel_ipv6 = 1;
11897 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6))
11900 is_tunnel_ipv6 = 1;
11904 (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg))
11906 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
11907 crypto_alg >= IPSEC_CRYPTO_N_ALG)
11909 clib_warning ("unsupported crypto-alg: '%U'",
11910 format_ipsec_crypto_alg, crypto_alg);
11914 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
11918 (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg))
11921 if (integ_alg < IPSEC_INTEG_ALG_NONE ||
11923 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
11925 integ_alg >= IPSEC_INTEG_N_ALG)
11927 clib_warning ("unsupported integ-alg: '%U'",
11928 format_ipsec_integ_alg, integ_alg);
11932 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
11936 clib_warning ("parse error '%U'", format_unformat_error, i);
11943 /*Special cases, aes-gcm-128 encryption */
11944 if (crypto_alg == IPSEC_CRYPTO_ALG_AES_GCM_128)
11946 if (integ_alg != IPSEC_INTEG_ALG_NONE
11947 && integ_alg != IPSEC_INTEG_ALG_AES_GCM_128)
11950 ("unsupported: aes-gcm-128 crypto-alg needs none as integ-alg");
11953 else /*set integ-alg internally to aes-gcm-128 */
11954 integ_alg = IPSEC_INTEG_ALG_AES_GCM_128;
11956 else if (integ_alg == IPSEC_INTEG_ALG_AES_GCM_128)
11958 clib_warning ("unsupported integ-alg: aes-gcm-128");
11961 else if (integ_alg == IPSEC_INTEG_ALG_NONE)
11963 clib_warning ("unsupported integ-alg: none");
11969 M (IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
11971 mp->sad_id = ntohl (sad_id);
11972 mp->is_add = is_add;
11973 mp->protocol = protocol;
11974 mp->spi = ntohl (spi);
11975 mp->is_tunnel = is_tunnel;
11976 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
11977 mp->crypto_algorithm = crypto_alg;
11978 mp->integrity_algorithm = integ_alg;
11979 mp->crypto_key_length = vec_len (ck);
11980 mp->integrity_key_length = vec_len (ik);
11982 if (mp->crypto_key_length > sizeof (mp->crypto_key))
11983 mp->crypto_key_length = sizeof (mp->crypto_key);
11985 if (mp->integrity_key_length > sizeof (mp->integrity_key))
11986 mp->integrity_key_length = sizeof (mp->integrity_key);
11989 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
11991 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
11995 if (is_tunnel_ipv6)
11997 clib_memcpy (mp->tunnel_src_address, &tun_src6,
11998 sizeof (ip6_address_t));
11999 clib_memcpy (mp->tunnel_dst_address, &tun_dst6,
12000 sizeof (ip6_address_t));
12004 clib_memcpy (mp->tunnel_src_address, &tun_src4,
12005 sizeof (ip4_address_t));
12006 clib_memcpy (mp->tunnel_dst_address, &tun_dst4,
12007 sizeof (ip4_address_t));
12018 api_ipsec_sa_set_key (vat_main_t * vam)
12020 unformat_input_t *i = vam->input;
12021 vl_api_ipsec_sa_set_key_t *mp;
12024 u8 *ck = 0, *ik = 0;
12026 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12028 if (unformat (i, "sa_id %d", &sa_id))
12030 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
12032 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
12036 clib_warning ("parse error '%U'", format_unformat_error, i);
12041 M (IPSEC_SA_SET_KEY, ipsec_set_sa_key);
12043 mp->sa_id = ntohl (sa_id);
12044 mp->crypto_key_length = vec_len (ck);
12045 mp->integrity_key_length = vec_len (ik);
12047 if (mp->crypto_key_length > sizeof (mp->crypto_key))
12048 mp->crypto_key_length = sizeof (mp->crypto_key);
12050 if (mp->integrity_key_length > sizeof (mp->integrity_key))
12051 mp->integrity_key_length = sizeof (mp->integrity_key);
12054 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
12056 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
12065 api_ikev2_profile_add_del (vat_main_t * vam)
12067 unformat_input_t *i = vam->input;
12068 vl_api_ikev2_profile_add_del_t *mp;
12073 const char *valid_chars = "a-zA-Z0-9_";
12075 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12077 if (unformat (i, "del"))
12079 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12080 vec_add1 (name, 0);
12083 errmsg ("parse error '%U'", format_unformat_error, i);
12088 if (!vec_len (name))
12090 errmsg ("profile name must be specified");
12094 if (vec_len (name) > 64)
12096 errmsg ("profile name too long");
12100 M (IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
12102 clib_memcpy (mp->name, name, vec_len (name));
12103 mp->is_add = is_add;
12113 api_ikev2_profile_set_auth (vat_main_t * vam)
12115 unformat_input_t *i = vam->input;
12116 vl_api_ikev2_profile_set_auth_t *mp;
12120 u32 auth_method = 0;
12123 const char *valid_chars = "a-zA-Z0-9_";
12125 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12127 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12128 vec_add1 (name, 0);
12129 else if (unformat (i, "auth_method %U",
12130 unformat_ikev2_auth_method, &auth_method))
12132 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
12134 else if (unformat (i, "auth_data %v", &data))
12138 errmsg ("parse error '%U'", format_unformat_error, i);
12143 if (!vec_len (name))
12145 errmsg ("profile name must be specified");
12149 if (vec_len (name) > 64)
12151 errmsg ("profile name too long");
12155 if (!vec_len (data))
12157 errmsg ("auth_data must be specified");
12163 errmsg ("auth_method must be specified");
12167 M (IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
12169 mp->is_hex = is_hex;
12170 mp->auth_method = (u8) auth_method;
12171 mp->data_len = vec_len (data);
12172 clib_memcpy (mp->name, name, vec_len (name));
12173 clib_memcpy (mp->data, data, vec_len (data));
12184 api_ikev2_profile_set_id (vat_main_t * vam)
12186 unformat_input_t *i = vam->input;
12187 vl_api_ikev2_profile_set_id_t *mp;
12195 const char *valid_chars = "a-zA-Z0-9_";
12197 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12199 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12200 vec_add1 (name, 0);
12201 else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
12203 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
12205 data = vec_new (u8, 4);
12206 clib_memcpy (data, ip4.as_u8, 4);
12208 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
12210 else if (unformat (i, "id_data %v", &data))
12212 else if (unformat (i, "local"))
12214 else if (unformat (i, "remote"))
12218 errmsg ("parse error '%U'", format_unformat_error, i);
12223 if (!vec_len (name))
12225 errmsg ("profile name must be specified");
12229 if (vec_len (name) > 64)
12231 errmsg ("profile name too long");
12235 if (!vec_len (data))
12237 errmsg ("id_data must be specified");
12243 errmsg ("id_type must be specified");
12247 M (IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
12249 mp->is_local = is_local;
12250 mp->id_type = (u8) id_type;
12251 mp->data_len = vec_len (data);
12252 clib_memcpy (mp->name, name, vec_len (name));
12253 clib_memcpy (mp->data, data, vec_len (data));
12264 api_ikev2_profile_set_ts (vat_main_t * vam)
12266 unformat_input_t *i = vam->input;
12267 vl_api_ikev2_profile_set_ts_t *mp;
12271 u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
12272 ip4_address_t start_addr, end_addr;
12274 const char *valid_chars = "a-zA-Z0-9_";
12276 start_addr.as_u32 = 0;
12277 end_addr.as_u32 = (u32) ~ 0;
12279 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12281 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
12282 vec_add1 (name, 0);
12283 else if (unformat (i, "protocol %d", &proto))
12285 else if (unformat (i, "start_port %d", &start_port))
12287 else if (unformat (i, "end_port %d", &end_port))
12290 if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
12292 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
12294 else if (unformat (i, "local"))
12296 else if (unformat (i, "remote"))
12300 errmsg ("parse error '%U'", format_unformat_error, i);
12305 if (!vec_len (name))
12307 errmsg ("profile name must be specified");
12311 if (vec_len (name) > 64)
12313 errmsg ("profile name too long");
12317 M (IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
12319 mp->is_local = is_local;
12320 mp->proto = (u8) proto;
12321 mp->start_port = (u16) start_port;
12322 mp->end_port = (u16) end_port;
12323 mp->start_addr = start_addr.as_u32;
12324 mp->end_addr = end_addr.as_u32;
12325 clib_memcpy (mp->name, name, vec_len (name));
12335 api_ikev2_set_local_key (vat_main_t * vam)
12337 unformat_input_t *i = vam->input;
12338 vl_api_ikev2_set_local_key_t *mp;
12342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12344 if (unformat (i, "file %v", &file))
12345 vec_add1 (file, 0);
12348 errmsg ("parse error '%U'", format_unformat_error, i);
12353 if (!vec_len (file))
12355 errmsg ("RSA key file must be specified");
12359 if (vec_len (file) > 256)
12361 errmsg ("file name too long");
12365 M (IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
12367 clib_memcpy (mp->key_file, file, vec_len (file));
12380 api_map_add_domain (vat_main_t * vam)
12382 unformat_input_t *i = vam->input;
12383 vl_api_map_add_domain_t *mp;
12386 ip4_address_t ip4_prefix;
12387 ip6_address_t ip6_prefix;
12388 ip6_address_t ip6_src;
12389 u32 num_m_args = 0;
12390 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, ea_bits_len = 0, psid_offset =
12391 0, psid_length = 0;
12392 u8 is_translation = 0;
12394 u32 ip6_src_len = 128;
12396 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12398 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
12399 &ip4_prefix, &ip4_prefix_len))
12401 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
12402 &ip6_prefix, &ip6_prefix_len))
12406 (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src,
12409 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
12411 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
12413 else if (unformat (i, "psid-offset %d", &psid_offset))
12415 else if (unformat (i, "psid-len %d", &psid_length))
12417 else if (unformat (i, "mtu %d", &mtu))
12419 else if (unformat (i, "map-t"))
12420 is_translation = 1;
12423 clib_warning ("parse error '%U'", format_unformat_error, i);
12428 if (num_m_args < 3)
12430 errmsg ("mandatory argument(s) missing\n");
12434 /* Construct the API message */
12435 M (MAP_ADD_DOMAIN, map_add_domain);
12437 clib_memcpy (mp->ip4_prefix, &ip4_prefix, sizeof (ip4_prefix));
12438 mp->ip4_prefix_len = ip4_prefix_len;
12440 clib_memcpy (mp->ip6_prefix, &ip6_prefix, sizeof (ip6_prefix));
12441 mp->ip6_prefix_len = ip6_prefix_len;
12443 clib_memcpy (mp->ip6_src, &ip6_src, sizeof (ip6_src));
12444 mp->ip6_src_prefix_len = ip6_src_len;
12446 mp->ea_bits_len = ea_bits_len;
12447 mp->psid_offset = psid_offset;
12448 mp->psid_length = psid_length;
12449 mp->is_translation = is_translation;
12450 mp->mtu = htons (mtu);
12455 /* Wait for a reply, return good/bad news */
12460 api_map_del_domain (vat_main_t * vam)
12462 unformat_input_t *i = vam->input;
12463 vl_api_map_del_domain_t *mp;
12466 u32 num_m_args = 0;
12469 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12471 if (unformat (i, "index %d", &index))
12475 clib_warning ("parse error '%U'", format_unformat_error, i);
12480 if (num_m_args != 1)
12482 errmsg ("mandatory argument(s) missing\n");
12486 /* Construct the API message */
12487 M (MAP_DEL_DOMAIN, map_del_domain);
12489 mp->index = ntohl (index);
12494 /* Wait for a reply, return good/bad news */
12499 api_map_add_del_rule (vat_main_t * vam)
12501 unformat_input_t *i = vam->input;
12502 vl_api_map_add_del_rule_t *mp;
12505 ip6_address_t ip6_dst;
12506 u32 num_m_args = 0, index, psid = 0;
12508 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12510 if (unformat (i, "index %d", &index))
12512 else if (unformat (i, "psid %d", &psid))
12514 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
12516 else if (unformat (i, "del"))
12522 clib_warning ("parse error '%U'", format_unformat_error, i);
12527 /* Construct the API message */
12528 M (MAP_ADD_DEL_RULE, map_add_del_rule);
12530 mp->index = ntohl (index);
12531 mp->is_add = is_add;
12532 clib_memcpy (mp->ip6_dst, &ip6_dst, sizeof (ip6_dst));
12533 mp->psid = ntohs (psid);
12538 /* Wait for a reply, return good/bad news */
12543 api_map_domain_dump (vat_main_t * vam)
12545 vl_api_map_domain_dump_t *mp;
12548 /* Construct the API message */
12549 M (MAP_DOMAIN_DUMP, map_domain_dump);
12554 /* Use a control ping for synchronization */
12556 vl_api_control_ping_t *mp;
12557 M (CONTROL_PING, control_ping);
12564 api_map_rule_dump (vat_main_t * vam)
12566 unformat_input_t *i = vam->input;
12567 vl_api_map_rule_dump_t *mp;
12569 u32 domain_index = ~0;
12571 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12573 if (unformat (i, "index %u", &domain_index))
12579 if (domain_index == ~0)
12581 clib_warning ("parse error: domain index expected");
12585 /* Construct the API message */
12586 M (MAP_RULE_DUMP, map_rule_dump);
12588 mp->domain_index = htonl (domain_index);
12593 /* Use a control ping for synchronization */
12595 vl_api_control_ping_t *mp;
12596 M (CONTROL_PING, control_ping);
12602 static void vl_api_map_add_domain_reply_t_handler
12603 (vl_api_map_add_domain_reply_t * mp)
12605 vat_main_t *vam = &vat_main;
12606 i32 retval = ntohl (mp->retval);
12608 if (vam->async_mode)
12610 vam->async_errors += (retval < 0);
12614 vam->retval = retval;
12615 vam->result_ready = 1;
12619 static void vl_api_map_add_domain_reply_t_handler_json
12620 (vl_api_map_add_domain_reply_t * mp)
12622 vat_main_t *vam = &vat_main;
12623 vat_json_node_t node;
12625 vat_json_init_object (&node);
12626 vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
12627 vat_json_object_add_uint (&node, "index", ntohl (mp->index));
12629 vat_json_print (vam->ofp, &node);
12630 vat_json_free (&node);
12632 vam->retval = ntohl (mp->retval);
12633 vam->result_ready = 1;
12637 api_get_first_msg_id (vat_main_t * vam)
12639 vl_api_get_first_msg_id_t *mp;
12641 unformat_input_t *i = vam->input;
12645 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
12647 if (unformat (i, "client %s", &name))
12655 errmsg ("missing client name\n");
12658 vec_add1 (name, 0);
12660 if (vec_len (name) > 63)
12662 errmsg ("client name too long\n");
12666 M (GET_FIRST_MSG_ID, get_first_msg_id);
12667 clib_memcpy (mp->name, name, vec_len (name));
12675 api_cop_interface_enable_disable (vat_main_t * vam)
12677 unformat_input_t *line_input = vam->input;
12678 vl_api_cop_interface_enable_disable_t *mp;
12680 u32 sw_if_index = ~0;
12681 u8 enable_disable = 1;
12683 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12685 if (unformat (line_input, "disable"))
12686 enable_disable = 0;
12687 if (unformat (line_input, "enable"))
12688 enable_disable = 1;
12689 else if (unformat (line_input, "%U", unformat_sw_if_index,
12690 vam, &sw_if_index))
12692 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12698 if (sw_if_index == ~0)
12700 errmsg ("missing interface name or sw_if_index\n");
12704 /* Construct the API message */
12705 M (COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
12706 mp->sw_if_index = ntohl (sw_if_index);
12707 mp->enable_disable = enable_disable;
12711 /* Wait for the reply */
12716 api_cop_whitelist_enable_disable (vat_main_t * vam)
12718 unformat_input_t *line_input = vam->input;
12719 vl_api_cop_whitelist_enable_disable_t *mp;
12721 u32 sw_if_index = ~0;
12722 u8 ip4 = 0, ip6 = 0, default_cop = 0;
12725 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
12727 if (unformat (line_input, "ip4"))
12729 else if (unformat (line_input, "ip6"))
12731 else if (unformat (line_input, "default"))
12733 else if (unformat (line_input, "%U", unformat_sw_if_index,
12734 vam, &sw_if_index))
12736 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
12738 else if (unformat (line_input, "fib-id %d", &fib_id))
12744 if (sw_if_index == ~0)
12746 errmsg ("missing interface name or sw_if_index\n");
12750 /* Construct the API message */
12751 M (COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
12752 mp->sw_if_index = ntohl (sw_if_index);
12753 mp->fib_id = ntohl (fib_id);
12756 mp->default_cop = default_cop;
12760 /* Wait for the reply */
12765 api_get_node_graph (vat_main_t * vam)
12767 vl_api_get_node_graph_t *mp;
12770 M (GET_NODE_GRAPH, get_node_graph);
12774 /* Wait for the reply */
12779 /** Used for parsing LISP eids */
12780 typedef CLIB_PACKED(struct{
12781 u8 addr[16]; /**< eid address */
12782 u32 len; /**< prefix length if IP */
12783 u8 type; /**< type of eid */
12788 unformat_lisp_eid_vat (unformat_input_t * input, va_list * args)
12790 lisp_eid_vat_t *a = va_arg (*args, lisp_eid_vat_t *);
12792 memset (a, 0, sizeof (a[0]));
12794 if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
12796 a->type = 0; /* ipv4 type */
12798 else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
12800 a->type = 1; /* ipv6 type */
12802 else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
12804 a->type = 2; /* mac type */
12811 if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
12820 lisp_eid_size_vat (u8 type)
12835 lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
12837 clib_memcpy (dst, eid, lisp_eid_size_vat (type));
12841 /** Used for transferring locators via VPP API */
12842 typedef CLIB_PACKED(struct
12844 u32 sw_if_index; /**< locator sw_if_index */
12845 u8 priority; /**< locator priority */
12846 u8 weight; /**< locator weight */
12851 api_lisp_add_del_locator_set (vat_main_t * vam)
12853 unformat_input_t *input = vam->input;
12854 vl_api_lisp_add_del_locator_set_t *mp;
12857 u8 *locator_set_name = NULL;
12858 u8 locator_set_name_set = 0;
12859 ls_locator_t locator, *locators = 0;
12860 u32 sw_if_index, priority, weight;
12863 /* Parse args required to build the message */
12864 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12866 if (unformat (input, "del"))
12870 else if (unformat (input, "locator-set %s", &locator_set_name))
12872 locator_set_name_set = 1;
12874 else if (unformat (input, "sw_if_index %u p %u w %u",
12875 &sw_if_index, &priority, &weight))
12877 locator.sw_if_index = htonl (sw_if_index);
12878 locator.priority = priority;
12879 locator.weight = weight;
12880 vec_add1 (locators, locator);
12882 else if (unformat (input, "iface %U p %u w %u", unformat_sw_if_index,
12883 vam, &sw_if_index, &priority, &weight))
12885 locator.sw_if_index = htonl (sw_if_index);
12886 locator.priority = priority;
12887 locator.weight = weight;
12888 vec_add1 (locators, locator);
12894 if (locator_set_name_set == 0)
12896 errmsg ("missing locator-set name");
12897 vec_free (locators);
12901 if (vec_len (locator_set_name) > 64)
12903 errmsg ("locator-set name too long\n");
12904 vec_free (locator_set_name);
12905 vec_free (locators);
12908 vec_add1 (locator_set_name, 0);
12910 data_len = sizeof (ls_locator_t) * vec_len (locators);
12912 /* Construct the API message */
12913 M2 (LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set, data_len);
12915 mp->is_add = is_add;
12916 clib_memcpy (mp->locator_set_name, locator_set_name,
12917 vec_len (locator_set_name));
12918 vec_free (locator_set_name);
12920 mp->locator_num = clib_host_to_net_u32 (vec_len (locators));
12922 clib_memcpy (mp->locators, locators, data_len);
12923 vec_free (locators);
12928 /* Wait for a reply... */
12936 api_lisp_add_del_locator (vat_main_t * vam)
12938 unformat_input_t *input = vam->input;
12939 vl_api_lisp_add_del_locator_t *mp;
12941 u32 tmp_if_index = ~0;
12942 u32 sw_if_index = ~0;
12943 u8 sw_if_index_set = 0;
12944 u8 sw_if_index_if_name_set = 0;
12946 u8 priority_set = 0;
12950 u8 *locator_set_name = NULL;
12951 u8 locator_set_name_set = 0;
12953 /* Parse args required to build the message */
12954 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
12956 if (unformat (input, "del"))
12960 else if (unformat (input, "locator-set %s", &locator_set_name))
12962 locator_set_name_set = 1;
12964 else if (unformat (input, "iface %U", unformat_sw_if_index, vam,
12967 sw_if_index_if_name_set = 1;
12968 sw_if_index = tmp_if_index;
12970 else if (unformat (input, "sw_if_index %d", &tmp_if_index))
12972 sw_if_index_set = 1;
12973 sw_if_index = tmp_if_index;
12975 else if (unformat (input, "p %d", &priority))
12979 else if (unformat (input, "w %d", &weight))
12987 if (locator_set_name_set == 0)
12989 errmsg ("missing locator-set name");
12993 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0)
12995 errmsg ("missing sw_if_index");
12996 vec_free (locator_set_name);
13000 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0)
13002 errmsg ("cannot use both params interface name and sw_if_index");
13003 vec_free (locator_set_name);
13007 if (priority_set == 0)
13009 errmsg ("missing locator-set priority\n");
13010 vec_free (locator_set_name);
13014 if (weight_set == 0)
13016 errmsg ("missing locator-set weight\n");
13017 vec_free (locator_set_name);
13021 if (vec_len (locator_set_name) > 64)
13023 errmsg ("locator-set name too long\n");
13024 vec_free (locator_set_name);
13027 vec_add1 (locator_set_name, 0);
13029 /* Construct the API message */
13030 M (LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
13032 mp->is_add = is_add;
13033 mp->sw_if_index = ntohl (sw_if_index);
13034 mp->priority = priority;
13035 mp->weight = weight;
13036 clib_memcpy (mp->locator_set_name, locator_set_name,
13037 vec_len (locator_set_name));
13038 vec_free (locator_set_name);
13043 /* Wait for a reply... */
13051 unformat_hmac_key_id (unformat_input_t * input, va_list * args)
13053 u32 *key_id = va_arg (*args, u32 *);
13056 if (unformat (input, "%s", &s))
13058 if (!strcmp ((char *) s, "sha1"))
13059 key_id[0] = HMAC_SHA_1_96;
13060 else if (!strcmp ((char *) s, "sha256"))
13061 key_id[0] = HMAC_SHA_256_128;
13064 clib_warning ("invalid key_id: '%s'", s);
13065 key_id[0] = HMAC_NO_KEY;
13076 api_lisp_add_del_local_eid (vat_main_t * vam)
13078 unformat_input_t *input = vam->input;
13079 vl_api_lisp_add_del_local_eid_t *mp;
13083 lisp_eid_vat_t _eid, *eid = &_eid;
13084 u8 *locator_set_name = 0;
13085 u8 locator_set_name_set = 0;
13090 /* Parse args required to build the message */
13091 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13093 if (unformat (input, "del"))
13097 else if (unformat (input, "vni %d", &vni))
13101 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13105 else if (unformat (input, "locator-set %s", &locator_set_name))
13107 locator_set_name_set = 1;
13109 else if (unformat (input, "key-id %U", unformat_hmac_key_id, &key_id))
13111 else if (unformat (input, "secret-key %_%v%_", &key))
13117 if (locator_set_name_set == 0)
13119 errmsg ("missing locator-set name\n");
13125 errmsg ("EID address not set!");
13126 vec_free (locator_set_name);
13130 if (key && (0 == key_id))
13132 errmsg ("invalid key_id!");
13136 if (vec_len (key) > 64)
13138 errmsg ("key too long");
13143 if (vec_len (locator_set_name) > 64)
13145 errmsg ("locator-set name too long\n");
13146 vec_free (locator_set_name);
13149 vec_add1 (locator_set_name, 0);
13151 /* Construct the API message */
13152 M (LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
13154 mp->is_add = is_add;
13155 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13156 mp->eid_type = eid->type;
13157 mp->prefix_len = eid->len;
13158 mp->vni = clib_host_to_net_u32 (vni);
13159 mp->key_id = clib_host_to_net_u16 (key_id);
13160 clib_memcpy (mp->locator_set_name, locator_set_name,
13161 vec_len (locator_set_name));
13162 clib_memcpy (mp->key, key, vec_len (key));
13164 vec_free (locator_set_name);
13170 /* Wait for a reply... */
13178 /** Used for transferring locators via VPP API */
13179 typedef CLIB_PACKED(struct
13181 u8 is_ip4; /**< is locator an IPv4 address? */
13182 u8 priority; /**< locator priority */
13183 u8 weight; /**< locator weight */
13184 u8 addr[16]; /**< IPv4/IPv6 address */
13189 api_lisp_gpe_add_del_fwd_entry (vat_main_t * vam)
13191 unformat_input_t *input = vam->input;
13192 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
13195 lisp_eid_vat_t _rmt_eid, *rmt_eid = &_rmt_eid;
13196 lisp_eid_vat_t _lcl_eid, *lcl_eid = &_lcl_eid;
13197 u8 rmt_eid_set = 0, lcl_eid_set = 0;
13198 u32 action = ~0, p, w;
13199 ip4_address_t rmt_rloc4, lcl_rloc4;
13200 ip6_address_t rmt_rloc6, lcl_rloc6;
13201 rloc_t *rmt_locs = 0, *lcl_locs = 0, rloc, *curr_rloc = 0;
13203 memset (&rloc, 0, sizeof (rloc));
13205 /* Parse args required to build the message */
13206 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13208 if (unformat (input, "del"))
13212 else if (unformat (input, "rmt_eid %U", unformat_lisp_eid_vat, rmt_eid))
13216 else if (unformat (input, "lcl_eid %U", unformat_lisp_eid_vat, lcl_eid))
13220 else if (unformat (input, "p %d w %d", &p, &w))
13224 errmsg ("No RLOC configured for setting priority/weight!");
13227 curr_rloc->priority = p;
13228 curr_rloc->weight = w;
13230 else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
13231 &lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
13235 clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
13236 rloc.priority = rloc.weight = 0;
13237 vec_add1 (lcl_locs, rloc);
13239 clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
13240 vec_add1 (rmt_locs, rloc);
13241 /* priority and weight saved in rmt loc */
13242 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13244 else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
13245 &lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
13248 clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
13249 rloc.priority = rloc.weight = 0;
13250 vec_add1 (lcl_locs, rloc);
13252 clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
13253 vec_add1 (rmt_locs, rloc);
13254 /* priority and weight saved in rmt loc */
13255 curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
13257 else if (unformat (input, "action %d", &action))
13263 clib_warning ("parse error '%U'", format_unformat_error, input);
13270 errmsg ("remote eid addresses not set\n");
13274 if (lcl_eid_set && rmt_eid->type != lcl_eid->type)
13276 errmsg ("eid types don't match\n");
13280 if (0 == rmt_locs && (u32) ~ 0 == action)
13282 errmsg ("action not set for negative mapping\n");
13286 /* Construct the API message */
13287 M (LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
13289 mp->is_add = is_add;
13290 lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
13291 lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
13292 mp->eid_type = rmt_eid->type;
13293 mp->rmt_len = rmt_eid->len;
13294 mp->lcl_len = lcl_eid->len;
13295 mp->action = action;
13297 if (0 != rmt_locs && 0 != lcl_locs)
13299 mp->loc_num = vec_len (rmt_locs);
13300 clib_memcpy (mp->lcl_locs, lcl_locs,
13301 (sizeof (rloc_t) * vec_len (lcl_locs)));
13302 clib_memcpy (mp->rmt_locs, rmt_locs,
13303 (sizeof (rloc_t) * vec_len (rmt_locs)));
13305 vec_free (lcl_locs);
13306 vec_free (rmt_locs);
13311 /* Wait for a reply... */
13319 api_lisp_add_del_map_server (vat_main_t * vam)
13321 unformat_input_t *input = vam->input;
13322 vl_api_lisp_add_del_map_server_t *mp;
13327 ip4_address_t ipv4;
13328 ip6_address_t ipv6;
13330 /* Parse args required to build the message */
13331 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13333 if (unformat (input, "del"))
13337 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13341 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13349 if (ipv4_set && ipv6_set)
13351 errmsg ("both eid v4 and v6 addresses set\n");
13355 if (!ipv4_set && !ipv6_set)
13357 errmsg ("eid addresses not set\n");
13361 /* Construct the API message */
13362 M (LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server);
13364 mp->is_add = is_add;
13368 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13373 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13379 /* Wait for a reply... */
13387 api_lisp_add_del_map_resolver (vat_main_t * vam)
13389 unformat_input_t *input = vam->input;
13390 vl_api_lisp_add_del_map_resolver_t *mp;
13395 ip4_address_t ipv4;
13396 ip6_address_t ipv6;
13398 /* Parse args required to build the message */
13399 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13401 if (unformat (input, "del"))
13405 else if (unformat (input, "%U", unformat_ip4_address, &ipv4))
13409 else if (unformat (input, "%U", unformat_ip6_address, &ipv6))
13417 if (ipv4_set && ipv6_set)
13419 errmsg ("both eid v4 and v6 addresses set\n");
13423 if (!ipv4_set && !ipv6_set)
13425 errmsg ("eid addresses not set\n");
13429 /* Construct the API message */
13430 M (LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
13432 mp->is_add = is_add;
13436 clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
13441 clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
13447 /* Wait for a reply... */
13455 api_lisp_gpe_enable_disable (vat_main_t * vam)
13457 unformat_input_t *input = vam->input;
13458 vl_api_lisp_gpe_enable_disable_t *mp;
13463 /* Parse args required to build the message */
13464 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13466 if (unformat (input, "enable"))
13471 else if (unformat (input, "disable"))
13482 errmsg ("Value not set\n");
13486 /* Construct the API message */
13487 M (LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
13494 /* Wait for a reply... */
13502 api_lisp_rloc_probe_enable_disable (vat_main_t * vam)
13504 unformat_input_t *input = vam->input;
13505 vl_api_lisp_rloc_probe_enable_disable_t *mp;
13510 /* Parse args required to build the message */
13511 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13513 if (unformat (input, "enable"))
13518 else if (unformat (input, "disable"))
13526 errmsg ("Value not set\n");
13530 /* Construct the API message */
13531 M (LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable);
13533 mp->is_enabled = is_en;
13538 /* Wait for a reply... */
13546 api_lisp_map_register_enable_disable (vat_main_t * vam)
13548 unformat_input_t *input = vam->input;
13549 vl_api_lisp_map_register_enable_disable_t *mp;
13554 /* Parse args required to build the message */
13555 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13557 if (unformat (input, "enable"))
13562 else if (unformat (input, "disable"))
13570 errmsg ("Value not set\n");
13574 /* Construct the API message */
13575 M (LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable);
13577 mp->is_enabled = is_en;
13582 /* Wait for a reply... */
13590 api_lisp_enable_disable (vat_main_t * vam)
13592 unformat_input_t *input = vam->input;
13593 vl_api_lisp_enable_disable_t *mp;
13598 /* Parse args required to build the message */
13599 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13601 if (unformat (input, "enable"))
13606 else if (unformat (input, "disable"))
13616 errmsg ("Value not set\n");
13620 /* Construct the API message */
13621 M (LISP_ENABLE_DISABLE, lisp_enable_disable);
13628 /* Wait for a reply... */
13636 api_show_lisp_map_register_state (vat_main_t * vam)
13639 vl_api_show_lisp_map_register_state_t *mp;
13641 M (SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state);
13646 /* wait for reply */
13653 api_show_lisp_rloc_probe_state (vat_main_t * vam)
13656 vl_api_show_lisp_rloc_probe_state_t *mp;
13658 M (SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state);
13663 /* wait for reply */
13670 api_show_lisp_map_request_mode (vat_main_t * vam)
13673 vl_api_show_lisp_map_request_mode_t *mp;
13675 M (SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode);
13680 /* wait for reply */
13687 api_lisp_map_request_mode (vat_main_t * vam)
13690 unformat_input_t *input = vam->input;
13691 vl_api_lisp_map_request_mode_t *mp;
13694 /* Parse args required to build the message */
13695 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13697 if (unformat (input, "dst-only"))
13699 else if (unformat (input, "src-dst"))
13703 errmsg ("parse error '%U'", format_unformat_error, input);
13708 M (LISP_MAP_REQUEST_MODE, lisp_map_request_mode);
13715 /* wait for reply */
13723 * Enable/disable LISP proxy ITR.
13725 * @param vam vpp API test context
13726 * @return return code
13729 api_lisp_pitr_set_locator_set (vat_main_t * vam)
13732 u8 ls_name_set = 0;
13733 unformat_input_t *input = vam->input;
13734 vl_api_lisp_pitr_set_locator_set_t *mp;
13738 /* Parse args required to build the message */
13739 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13741 if (unformat (input, "del"))
13743 else if (unformat (input, "locator-set %s", &ls_name))
13747 errmsg ("parse error '%U'", format_unformat_error, input);
13754 errmsg ("locator-set name not set!");
13758 M (LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
13760 mp->is_add = is_add;
13761 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
13762 vec_free (ls_name);
13767 /* wait for reply */
13775 api_show_lisp_pitr (vat_main_t * vam)
13777 vl_api_show_lisp_pitr_t *mp;
13780 if (!vam->json_output)
13782 fformat (vam->ofp, "%=20s\n", "lisp status:");
13785 M (SHOW_LISP_PITR, show_lisp_pitr);
13789 /* Wait for a reply... */
13797 * Add/delete mapping between vni and vrf
13800 api_lisp_eid_table_add_del_map (vat_main_t * vam)
13803 unformat_input_t *input = vam->input;
13804 vl_api_lisp_eid_table_add_del_map_t *mp;
13805 u8 is_add = 1, vni_set = 0, vrf_set = 0, bd_index_set = 0;
13806 u32 vni, vrf, bd_index;
13808 /* Parse args required to build the message */
13809 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13811 if (unformat (input, "del"))
13813 else if (unformat (input, "vrf %d", &vrf))
13815 else if (unformat (input, "bd_index %d", &bd_index))
13817 else if (unformat (input, "vni %d", &vni))
13823 if (!vni_set || (!vrf_set && !bd_index_set))
13825 errmsg ("missing arguments!");
13829 if (vrf_set && bd_index_set)
13831 errmsg ("error: both vrf and bd entered!");
13835 M (LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
13837 mp->is_add = is_add;
13838 mp->vni = htonl (vni);
13839 mp->dp_table = vrf_set ? htonl (vrf) : htonl (bd_index);
13840 mp->is_l2 = bd_index_set;
13845 /* wait for reply */
13853 unformat_negative_mapping_action (unformat_input_t * input, va_list * args)
13855 u32 *action = va_arg (*args, u32 *);
13858 if (unformat (input, "%s", &s))
13860 if (!strcmp ((char *) s, "no-action"))
13862 else if (!strcmp ((char *) s, "natively-forward"))
13864 else if (!strcmp ((char *) s, "send-map-request"))
13866 else if (!strcmp ((char *) s, "drop"))
13870 clib_warning ("invalid action: '%s'", s);
13882 * Add/del remote mapping to/from LISP control plane
13884 * @param vam vpp API test context
13885 * @return return code
13888 api_lisp_add_del_remote_mapping (vat_main_t * vam)
13890 unformat_input_t *input = vam->input;
13891 vl_api_lisp_add_del_remote_mapping_t *mp;
13894 lisp_eid_vat_t _eid, *eid = &_eid;
13895 lisp_eid_vat_t _seid, *seid = &_seid;
13896 u8 is_add = 1, del_all = 0, eid_set = 0, seid_set = 0;
13897 u32 action = ~0, p, w, data_len;
13898 ip4_address_t rloc4;
13899 ip6_address_t rloc6;
13900 rloc_t *rlocs = 0, rloc, *curr_rloc = 0;
13902 memset (&rloc, 0, sizeof (rloc));
13904 /* Parse args required to build the message */
13905 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
13907 if (unformat (input, "del-all"))
13911 else if (unformat (input, "del"))
13915 else if (unformat (input, "add"))
13919 else if (unformat (input, "eid %U", unformat_lisp_eid_vat, eid))
13923 else if (unformat (input, "seid %U", unformat_lisp_eid_vat, seid))
13927 else if (unformat (input, "vni %d", &vni))
13931 else if (unformat (input, "p %d w %d", &p, &w))
13935 errmsg ("No RLOC configured for setting priority/weight!");
13938 curr_rloc->priority = p;
13939 curr_rloc->weight = w;
13941 else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
13944 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
13945 vec_add1 (rlocs, rloc);
13946 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13948 else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
13951 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
13952 vec_add1 (rlocs, rloc);
13953 curr_rloc = &rlocs[vec_len (rlocs) - 1];
13955 else if (unformat (input, "action %U",
13956 unformat_negative_mapping_action, &action))
13962 clib_warning ("parse error '%U'", format_unformat_error, input);
13969 errmsg ("missing params!");
13973 if (is_add && (~0 == action) && 0 == vec_len (rlocs))
13975 errmsg ("no action set for negative map-reply!");
13979 data_len = vec_len (rlocs) * sizeof (rloc_t);
13981 M2 (LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping, data_len);
13982 mp->is_add = is_add;
13983 mp->vni = htonl (vni);
13984 mp->action = (u8) action;
13985 mp->is_src_dst = seid_set;
13986 mp->eid_len = eid->len;
13987 mp->seid_len = seid->len;
13988 mp->del_all = del_all;
13989 mp->eid_type = eid->type;
13990 lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
13991 lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
13993 mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
13994 clib_memcpy (mp->rlocs, rlocs, data_len);
14000 /* Wait for a reply... */
14008 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
14009 * forwarding entries in data-plane accordingly.
14011 * @param vam vpp API test context
14012 * @return return code
14015 api_lisp_add_del_adjacency (vat_main_t * vam)
14017 unformat_input_t *input = vam->input;
14018 vl_api_lisp_add_del_adjacency_t *mp;
14021 ip4_address_t leid4, reid4;
14022 ip6_address_t leid6, reid6;
14023 u8 reid_mac[6] = { 0 };
14024 u8 leid_mac[6] = { 0 };
14025 u8 reid_type, leid_type;
14026 u32 leid_len = 0, reid_len = 0, len;
14029 leid_type = reid_type = (u8) ~ 0;
14031 /* Parse args required to build the message */
14032 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14034 if (unformat (input, "del"))
14038 else if (unformat (input, "add"))
14042 else if (unformat (input, "reid %U/%d", unformat_ip4_address,
14045 reid_type = 0; /* ipv4 */
14048 else if (unformat (input, "reid %U/%d", unformat_ip6_address,
14051 reid_type = 1; /* ipv6 */
14054 else if (unformat (input, "reid %U", unformat_ethernet_address,
14057 reid_type = 2; /* mac */
14059 else if (unformat (input, "leid %U/%d", unformat_ip4_address,
14062 leid_type = 0; /* ipv4 */
14065 else if (unformat (input, "leid %U/%d", unformat_ip6_address,
14068 leid_type = 1; /* ipv6 */
14071 else if (unformat (input, "leid %U", unformat_ethernet_address,
14074 leid_type = 2; /* mac */
14076 else if (unformat (input, "vni %d", &vni))
14082 errmsg ("parse error '%U'", format_unformat_error, input);
14087 if ((u8) ~ 0 == reid_type)
14089 errmsg ("missing params!");
14093 if (leid_type != reid_type)
14095 errmsg ("remote and local EIDs are of different types!");
14099 M (LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
14100 mp->is_add = is_add;
14101 mp->vni = htonl (vni);
14102 mp->leid_len = leid_len;
14103 mp->reid_len = reid_len;
14104 mp->eid_type = reid_type;
14106 switch (mp->eid_type)
14109 clib_memcpy (mp->leid, &leid4, sizeof (leid4));
14110 clib_memcpy (mp->reid, &reid4, sizeof (reid4));
14113 clib_memcpy (mp->leid, &leid6, sizeof (leid6));
14114 clib_memcpy (mp->reid, &reid6, sizeof (reid6));
14117 clib_memcpy (mp->leid, leid_mac, 6);
14118 clib_memcpy (mp->reid, reid_mac, 6);
14121 errmsg ("unknown EID type %d!", mp->eid_type);
14128 /* Wait for a reply... */
14136 api_lisp_gpe_add_del_iface (vat_main_t * vam)
14138 unformat_input_t *input = vam->input;
14139 vl_api_lisp_gpe_add_del_iface_t *mp;
14141 u8 action_set = 0, is_add = 1, is_l2 = 0, dp_table_set = 0, vni_set = 0;
14142 u32 dp_table = 0, vni = 0;
14144 /* Parse args required to build the message */
14145 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14147 if (unformat (input, "up"))
14152 else if (unformat (input, "down"))
14157 else if (unformat (input, "table_id %d", &dp_table))
14161 else if (unformat (input, "bd_id %d", &dp_table))
14166 else if (unformat (input, "vni %d", &vni))
14174 if (action_set == 0)
14176 errmsg ("Action not set\n");
14179 if (dp_table_set == 0 || vni_set == 0)
14181 errmsg ("vni and dp_table must be set\n");
14185 /* Construct the API message */
14186 M (LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
14188 mp->is_add = is_add;
14189 mp->dp_table = dp_table;
14196 /* Wait for a reply... */
14204 * Add/del map request itr rlocs from LISP control plane and updates
14206 * @param vam vpp API test context
14207 * @return return code
14210 api_lisp_add_del_map_request_itr_rlocs (vat_main_t * vam)
14212 unformat_input_t *input = vam->input;
14213 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
14215 u8 *locator_set_name = 0;
14216 u8 locator_set_name_set = 0;
14219 /* Parse args required to build the message */
14220 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14222 if (unformat (input, "del"))
14226 else if (unformat (input, "%_%v%_", &locator_set_name))
14228 locator_set_name_set = 1;
14232 clib_warning ("parse error '%U'", format_unformat_error, input);
14237 if (is_add && !locator_set_name_set)
14239 errmsg ("itr-rloc is not set!");
14243 if (is_add && vec_len (locator_set_name) > 64)
14245 errmsg ("itr-rloc locator-set name too long\n");
14246 vec_free (locator_set_name);
14250 M (LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
14251 mp->is_add = is_add;
14254 clib_memcpy (mp->locator_set_name, locator_set_name,
14255 vec_len (locator_set_name));
14259 memset (mp->locator_set_name, 0, sizeof (mp->locator_set_name));
14261 vec_free (locator_set_name);
14266 /* Wait for a reply... */
14274 api_lisp_locator_dump (vat_main_t * vam)
14276 unformat_input_t *input = vam->input;
14277 vl_api_lisp_locator_dump_t *mp;
14279 u8 is_index_set = 0, is_name_set = 0;
14283 /* Parse args required to build the message */
14284 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14286 if (unformat (input, "ls_name %_%v%_", &ls_name))
14290 else if (unformat (input, "ls_index %d", &ls_index))
14296 errmsg ("parse error '%U'", format_unformat_error, input);
14301 if (!is_index_set && !is_name_set)
14303 errmsg ("error: expected one of index or name!\n");
14307 if (is_index_set && is_name_set)
14309 errmsg ("error: only one param expected!\n");
14313 if (vec_len (ls_name) > 62)
14315 errmsg ("error: locator set name too long!");
14319 if (!vam->json_output)
14321 fformat (vam->ofp, "%=16s%=16s%=16s\n", "locator", "priority",
14325 M (LISP_LOCATOR_DUMP, lisp_locator_dump);
14326 mp->is_index_set = is_index_set;
14329 mp->ls_index = clib_host_to_net_u32 (ls_index);
14332 vec_add1 (ls_name, 0);
14333 strncpy ((char *) mp->ls_name, (char *) ls_name,
14334 sizeof (mp->ls_name) - 1);
14340 /* Use a control ping for synchronization */
14342 vl_api_control_ping_t *mp;
14343 M (CONTROL_PING, control_ping);
14346 /* Wait for a reply... */
14354 api_lisp_locator_set_dump (vat_main_t * vam)
14356 vl_api_lisp_locator_set_dump_t *mp;
14357 unformat_input_t *input = vam->input;
14361 /* Parse args required to build the message */
14362 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14364 if (unformat (input, "local"))
14368 else if (unformat (input, "remote"))
14374 errmsg ("parse error '%U'", format_unformat_error, input);
14379 if (!vam->json_output)
14381 fformat (vam->ofp, "%=10s%=15s\n", "ls_index", "ls_name");
14384 M (LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
14386 mp->filter = filter;
14391 /* Use a control ping for synchronization */
14393 vl_api_control_ping_t *mp;
14394 M (CONTROL_PING, control_ping);
14397 /* Wait for a reply... */
14405 api_lisp_eid_table_map_dump (vat_main_t * vam)
14409 unformat_input_t *input = vam->input;
14410 vl_api_lisp_eid_table_map_dump_t *mp;
14413 /* Parse args required to build the message */
14414 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
14416 if (unformat (input, "l2"))
14421 else if (unformat (input, "l3"))
14428 errmsg ("parse error '%U'", format_unformat_error, input);
14435 errmsg ("expected one of 'l2' or 'l3' parameter!\n");
14439 if (!vam->json_output)
14441 fformat (vam->ofp, "%=10s%=10s\n", "VNI", is_l2 ? "BD" : "VRF");
14444 M (LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump);
14450 /* Use a control ping for synchronization */
14452 vl_api_control_ping_t *mp;
14453 M (CONTROL_PING, control_ping);
14456 /* Wait for a reply... */
14464 api_lisp_eid_table_vni_dump (vat_main_t * vam)
14466 vl_api_lisp_eid_table_vni_dump_t *mp;
14469 if (!vam->json_output)
14471 fformat (vam->ofp, "VNI\n");
14474 M (LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump);
14479 /* Use a control ping for synchronization */
14481 vl_api_control_ping_t *mp;
14482 M (CONTROL_PING, control_ping);
14485 /* Wait for a reply... */
14493 api_lisp_eid_table_dump (vat_main_t * vam)
14495 unformat_input_t *i = vam->input;
14496 vl_api_lisp_eid_table_dump_t *mp;
14498 struct in_addr ip4;
14499 struct in6_addr ip6;
14501 u8 eid_type = ~0, eid_set = 0;
14502 u32 prefix_length = ~0, t, vni = 0;
14505 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14507 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
14513 else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
14519 else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
14524 else if (unformat (i, "vni %d", &t))
14528 else if (unformat (i, "local"))
14532 else if (unformat (i, "remote"))
14538 errmsg ("parse error '%U'", format_unformat_error, i);
14543 if (!vam->json_output)
14545 fformat (vam->ofp, "%-35s%-20s%-30s%-20s%-20s%-10s%-20s\n", "EID",
14546 "type", "ls_index", "ttl", "authoritative", "key_id", "key");
14549 M (LISP_EID_TABLE_DUMP, lisp_eid_table_dump);
14551 mp->filter = filter;
14555 mp->vni = htonl (vni);
14556 mp->eid_type = eid_type;
14560 mp->prefix_length = prefix_length;
14561 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
14564 mp->prefix_length = prefix_length;
14565 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
14568 clib_memcpy (mp->eid, mac, sizeof (mac));
14571 errmsg ("unknown EID type %d!", eid_type);
14579 /* Use a control ping for synchronization */
14581 vl_api_control_ping_t *mp;
14582 M (CONTROL_PING, control_ping);
14586 /* Wait for a reply... */
14594 api_lisp_gpe_tunnel_dump (vat_main_t * vam)
14596 vl_api_lisp_gpe_tunnel_dump_t *mp;
14599 if (!vam->json_output)
14601 fformat (vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
14602 "%=16s%=16s%=16s%=16s%=16s\n",
14603 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
14604 "Decap next", "Lisp version", "Flags", "Next protocol",
14605 "ver_res", "res", "iid");
14608 M (LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
14612 /* Use a control ping for synchronization */
14614 vl_api_control_ping_t *mp;
14615 M (CONTROL_PING, control_ping);
14618 /* Wait for a reply... */
14626 api_lisp_adjacencies_get (vat_main_t * vam)
14628 unformat_input_t *i = vam->input;
14629 vl_api_lisp_adjacencies_get_t *mp;
14634 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14636 if (unformat (i, "vni %d", &vni))
14642 errmsg ("parse error '%U'\n", format_unformat_error, i);
14649 errmsg ("vni not set!\n");
14653 if (!vam->json_output)
14655 fformat (vam->ofp, "%s %40s\n", "leid", "reid");
14658 M (LISP_ADJACENCIES_GET, lisp_adjacencies_get);
14659 mp->vni = clib_host_to_net_u32 (vni);
14664 /* Wait for a reply... */
14672 api_lisp_map_server_dump (vat_main_t * vam)
14674 vl_api_lisp_map_server_dump_t *mp;
14677 if (!vam->json_output)
14679 fformat (vam->ofp, "%=20s\n", "Map server");
14682 M (LISP_MAP_SERVER_DUMP, lisp_map_server_dump);
14686 /* Use a control ping for synchronization */
14688 vl_api_control_ping_t *mp;
14689 M (CONTROL_PING, control_ping);
14692 /* Wait for a reply... */
14700 api_lisp_map_resolver_dump (vat_main_t * vam)
14702 vl_api_lisp_map_resolver_dump_t *mp;
14705 if (!vam->json_output)
14707 fformat (vam->ofp, "%=20s\n", "Map resolver");
14710 M (LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
14714 /* Use a control ping for synchronization */
14716 vl_api_control_ping_t *mp;
14717 M (CONTROL_PING, control_ping);
14720 /* Wait for a reply... */
14728 api_show_lisp_status (vat_main_t * vam)
14730 vl_api_show_lisp_status_t *mp;
14733 if (!vam->json_output)
14735 fformat (vam->ofp, "%-20s%-16s\n", "lisp status", "locator-set");
14738 M (SHOW_LISP_STATUS, show_lisp_status);
14741 /* Wait for a reply... */
14749 api_lisp_get_map_request_itr_rlocs (vat_main_t * vam)
14751 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
14754 if (!vam->json_output)
14756 fformat (vam->ofp, "%=20s\n", "itr-rlocs:");
14759 M (LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
14762 /* Wait for a reply... */
14770 api_af_packet_create (vat_main_t * vam)
14772 unformat_input_t *i = vam->input;
14773 vl_api_af_packet_create_t *mp;
14775 u8 *host_if_name = 0;
14777 u8 random_hw_addr = 1;
14779 memset (hw_addr, 0, sizeof (hw_addr));
14781 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14783 if (unformat (i, "name %s", &host_if_name))
14784 vec_add1 (host_if_name, 0);
14785 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
14786 random_hw_addr = 0;
14791 if (!vec_len (host_if_name))
14793 errmsg ("host-interface name must be specified");
14797 if (vec_len (host_if_name) > 64)
14799 errmsg ("host-interface name too long");
14803 M (AF_PACKET_CREATE, af_packet_create);
14805 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14806 clib_memcpy (mp->hw_addr, hw_addr, 6);
14807 mp->use_random_hw_addr = random_hw_addr;
14808 vec_free (host_if_name);
14811 W2 (fprintf (vam->ofp, " new sw_if_index = %d ", vam->sw_if_index));
14817 api_af_packet_delete (vat_main_t * vam)
14819 unformat_input_t *i = vam->input;
14820 vl_api_af_packet_delete_t *mp;
14822 u8 *host_if_name = 0;
14824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14826 if (unformat (i, "name %s", &host_if_name))
14827 vec_add1 (host_if_name, 0);
14832 if (!vec_len (host_if_name))
14834 errmsg ("host-interface name must be specified");
14838 if (vec_len (host_if_name) > 64)
14840 errmsg ("host-interface name too long");
14844 M (AF_PACKET_DELETE, af_packet_delete);
14846 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
14847 vec_free (host_if_name);
14856 api_policer_add_del (vat_main_t * vam)
14858 unformat_input_t *i = vam->input;
14859 vl_api_policer_add_del_t *mp;
14870 u8 color_aware = 0;
14871 sse2_qos_pol_action_params_st conform_action, exceed_action, violate_action;
14873 conform_action.action_type = SSE2_QOS_ACTION_TRANSMIT;
14874 conform_action.dscp = 0;
14875 exceed_action.action_type = SSE2_QOS_ACTION_MARK_AND_TRANSMIT;
14876 exceed_action.dscp = 0;
14877 violate_action.action_type = SSE2_QOS_ACTION_DROP;
14878 violate_action.dscp = 0;
14880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14882 if (unformat (i, "del"))
14884 else if (unformat (i, "name %s", &name))
14885 vec_add1 (name, 0);
14886 else if (unformat (i, "cir %u", &cir))
14888 else if (unformat (i, "eir %u", &eir))
14890 else if (unformat (i, "cb %u", &cb))
14892 else if (unformat (i, "eb %u", &eb))
14894 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
14897 else if (unformat (i, "round_type %U", unformat_policer_round_type,
14900 else if (unformat (i, "type %U", unformat_policer_type, &type))
14902 else if (unformat (i, "conform_action %U", unformat_policer_action_type,
14905 else if (unformat (i, "exceed_action %U", unformat_policer_action_type,
14908 else if (unformat (i, "violate_action %U", unformat_policer_action_type,
14911 else if (unformat (i, "color-aware"))
14917 if (!vec_len (name))
14919 errmsg ("policer name must be specified");
14923 if (vec_len (name) > 64)
14925 errmsg ("policer name too long");
14929 M (POLICER_ADD_DEL, policer_add_del);
14931 clib_memcpy (mp->name, name, vec_len (name));
14933 mp->is_add = is_add;
14938 mp->rate_type = rate_type;
14939 mp->round_type = round_type;
14941 mp->conform_action_type = conform_action.action_type;
14942 mp->conform_dscp = conform_action.dscp;
14943 mp->exceed_action_type = exceed_action.action_type;
14944 mp->exceed_dscp = exceed_action.dscp;
14945 mp->violate_action_type = violate_action.action_type;
14946 mp->violate_dscp = violate_action.dscp;
14947 mp->color_aware = color_aware;
14956 api_policer_dump (vat_main_t * vam)
14958 unformat_input_t *i = vam->input;
14959 vl_api_policer_dump_t *mp;
14961 u8 *match_name = 0;
14962 u8 match_name_valid = 0;
14964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
14966 if (unformat (i, "name %s", &match_name))
14968 vec_add1 (match_name, 0);
14969 match_name_valid = 1;
14975 M (POLICER_DUMP, policer_dump);
14976 mp->match_name_valid = match_name_valid;
14977 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
14978 vec_free (match_name);
14982 /* Use a control ping for synchronization */
14984 vl_api_control_ping_t *mp;
14985 M (CONTROL_PING, control_ping);
14988 /* Wait for a reply... */
14996 api_policer_classify_set_interface (vat_main_t * vam)
14998 unformat_input_t *i = vam->input;
14999 vl_api_policer_classify_set_interface_t *mp;
15002 int sw_if_index_set;
15003 u32 ip4_table_index = ~0;
15004 u32 ip6_table_index = ~0;
15005 u32 l2_table_index = ~0;
15008 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15010 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
15011 sw_if_index_set = 1;
15012 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15013 sw_if_index_set = 1;
15014 else if (unformat (i, "del"))
15016 else if (unformat (i, "ip4-table %d", &ip4_table_index))
15018 else if (unformat (i, "ip6-table %d", &ip6_table_index))
15020 else if (unformat (i, "l2-table %d", &l2_table_index))
15024 clib_warning ("parse error '%U'", format_unformat_error, i);
15029 if (sw_if_index_set == 0)
15031 errmsg ("missing interface name or sw_if_index\n");
15035 M (POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface);
15037 mp->sw_if_index = ntohl (sw_if_index);
15038 mp->ip4_table_index = ntohl (ip4_table_index);
15039 mp->ip6_table_index = ntohl (ip6_table_index);
15040 mp->l2_table_index = ntohl (l2_table_index);
15041 mp->is_add = is_add;
15050 api_policer_classify_dump (vat_main_t * vam)
15052 unformat_input_t *i = vam->input;
15053 vl_api_policer_classify_dump_t *mp;
15055 u8 type = POLICER_CLASSIFY_N_TABLES;
15057 if (unformat (i, "type %U", unformat_policer_classify_table_type, &type))
15061 errmsg ("classify table type must be specified\n");
15065 if (!vam->json_output)
15067 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
15070 M (POLICER_CLASSIFY_DUMP, policer_classify_dump);
15075 /* Use a control ping for synchronization */
15077 vl_api_control_ping_t *mp;
15078 M (CONTROL_PING, control_ping);
15081 /* Wait for a reply... */
15089 api_netmap_create (vat_main_t * vam)
15091 unformat_input_t *i = vam->input;
15092 vl_api_netmap_create_t *mp;
15096 u8 random_hw_addr = 1;
15100 memset (hw_addr, 0, sizeof (hw_addr));
15102 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15104 if (unformat (i, "name %s", &if_name))
15105 vec_add1 (if_name, 0);
15106 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
15107 random_hw_addr = 0;
15108 else if (unformat (i, "pipe"))
15110 else if (unformat (i, "master"))
15112 else if (unformat (i, "slave"))
15118 if (!vec_len (if_name))
15120 errmsg ("interface name must be specified");
15124 if (vec_len (if_name) > 64)
15126 errmsg ("interface name too long");
15130 M (NETMAP_CREATE, netmap_create);
15132 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15133 clib_memcpy (mp->hw_addr, hw_addr, 6);
15134 mp->use_random_hw_addr = random_hw_addr;
15135 mp->is_pipe = is_pipe;
15136 mp->is_master = is_master;
15137 vec_free (if_name);
15146 api_netmap_delete (vat_main_t * vam)
15148 unformat_input_t *i = vam->input;
15149 vl_api_netmap_delete_t *mp;
15153 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15155 if (unformat (i, "name %s", &if_name))
15156 vec_add1 (if_name, 0);
15161 if (!vec_len (if_name))
15163 errmsg ("interface name must be specified");
15167 if (vec_len (if_name) > 64)
15169 errmsg ("interface name too long");
15173 M (NETMAP_DELETE, netmap_delete);
15175 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
15176 vec_free (if_name);
15184 static void vl_api_mpls_tunnel_details_t_handler
15185 (vl_api_mpls_tunnel_details_t * mp)
15187 vat_main_t *vam = &vat_main;
15188 i32 len = mp->mt_next_hop_n_labels;
15191 fformat (vam->ofp, "[%d]: via %U %d labels ",
15193 format_ip4_address, mp->mt_next_hop,
15194 ntohl (mp->mt_next_hop_sw_if_index));
15195 for (i = 0; i < len; i++)
15197 fformat (vam->ofp, "%u ", ntohl (mp->mt_next_hop_out_labels[i]));
15199 fformat (vam->ofp, "\n");
15202 static void vl_api_mpls_tunnel_details_t_handler_json
15203 (vl_api_mpls_tunnel_details_t * mp)
15205 vat_main_t *vam = &vat_main;
15206 vat_json_node_t *node = NULL;
15207 struct in_addr ip4;
15209 i32 len = mp->mt_next_hop_n_labels;
15211 if (VAT_JSON_ARRAY != vam->json_tree.type)
15213 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15214 vat_json_init_array (&vam->json_tree);
15216 node = vat_json_array_add (&vam->json_tree);
15218 vat_json_init_object (node);
15219 vat_json_object_add_uint (node, "tunnel_index", ntohl (mp->tunnel_index));
15220 clib_memcpy (&ip4, &(mp->mt_next_hop), sizeof (ip4));
15221 vat_json_object_add_ip4 (node, "next_hop", ip4);
15222 vat_json_object_add_uint (node, "next_hop_sw_if_index",
15223 ntohl (mp->mt_next_hop_sw_if_index));
15224 vat_json_object_add_uint (node, "l2_only", ntohl (mp->mt_l2_only));
15225 vat_json_object_add_uint (node, "label_count", len);
15226 for (i = 0; i < len; i++)
15228 vat_json_object_add_uint (node, "label",
15229 ntohl (mp->mt_next_hop_out_labels[i]));
15234 api_mpls_tunnel_dump (vat_main_t * vam)
15236 vl_api_mpls_tunnel_dump_t *mp;
15240 /* Parse args required to build the message */
15241 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT)
15243 if (!unformat (vam->input, "tunnel_index %d", &index))
15250 fformat (vam->ofp, " tunnel_index %d\n", index);
15252 M (MPLS_TUNNEL_DUMP, mpls_tunnel_dump);
15253 mp->tunnel_index = htonl (index);
15256 /* Use a control ping for synchronization */
15258 vl_api_control_ping_t *mp;
15259 M (CONTROL_PING, control_ping);
15265 #define vl_api_mpls_fib_details_t_endian vl_noop_handler
15266 #define vl_api_mpls_fib_details_t_print vl_noop_handler
15269 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
15271 vat_main_t *vam = &vat_main;
15272 int count = ntohl (mp->count);
15273 vl_api_fib_path2_t *fp;
15277 "table-id %d, label %u, ess_bit %u\n",
15278 ntohl (mp->table_id), ntohl (mp->label), mp->eos_bit);
15280 for (i = 0; i < count; i++)
15282 if (fp->afi == IP46_TYPE_IP6)
15284 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15285 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15286 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15287 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15288 format_ip6_address, fp->next_hop);
15289 else if (fp->afi == IP46_TYPE_IP4)
15291 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15292 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15293 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15294 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15295 format_ip4_address, fp->next_hop);
15300 static void vl_api_mpls_fib_details_t_handler_json
15301 (vl_api_mpls_fib_details_t * mp)
15303 vat_main_t *vam = &vat_main;
15304 int count = ntohl (mp->count);
15305 vat_json_node_t *node = NULL;
15306 struct in_addr ip4;
15307 struct in6_addr ip6;
15308 vl_api_fib_path2_t *fp;
15311 if (VAT_JSON_ARRAY != vam->json_tree.type)
15313 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15314 vat_json_init_array (&vam->json_tree);
15316 node = vat_json_array_add (&vam->json_tree);
15318 vat_json_init_object (node);
15319 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15320 vat_json_object_add_uint (node, "s_bit", mp->eos_bit);
15321 vat_json_object_add_uint (node, "label", ntohl (mp->label));
15322 vat_json_object_add_uint (node, "path_count", count);
15324 for (i = 0; i < count; i++)
15326 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15327 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15328 vat_json_object_add_uint (node, "is_local", fp->is_local);
15329 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15330 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15331 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15332 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15333 if (fp->afi == IP46_TYPE_IP4)
15335 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15336 vat_json_object_add_ip4 (node, "next_hop", ip4);
15338 else if (fp->afi == IP46_TYPE_IP6)
15340 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15341 vat_json_object_add_ip6 (node, "next_hop", ip6);
15347 api_mpls_fib_dump (vat_main_t * vam)
15349 vl_api_mpls_fib_dump_t *mp;
15352 M (MPLS_FIB_DUMP, mpls_fib_dump);
15355 /* Use a control ping for synchronization */
15357 vl_api_control_ping_t *mp;
15358 M (CONTROL_PING, control_ping);
15364 #define vl_api_ip_fib_details_t_endian vl_noop_handler
15365 #define vl_api_ip_fib_details_t_print vl_noop_handler
15368 vl_api_ip_fib_details_t_handler (vl_api_ip_fib_details_t * mp)
15370 vat_main_t *vam = &vat_main;
15371 int count = ntohl (mp->count);
15372 vl_api_fib_path_t *fp;
15376 "table-id %d, prefix %U/%d\n",
15377 ntohl (mp->table_id), format_ip4_address, mp->address,
15378 mp->address_length);
15380 for (i = 0; i < count; i++)
15382 if (fp->afi == IP46_TYPE_IP6)
15384 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15385 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15386 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15387 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15388 format_ip6_address, fp->next_hop);
15389 else if (fp->afi == IP46_TYPE_IP4)
15391 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15392 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15393 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15394 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15395 format_ip4_address, fp->next_hop);
15400 static void vl_api_ip_fib_details_t_handler_json
15401 (vl_api_ip_fib_details_t * mp)
15403 vat_main_t *vam = &vat_main;
15404 int count = ntohl (mp->count);
15405 vat_json_node_t *node = NULL;
15406 struct in_addr ip4;
15407 struct in6_addr ip6;
15408 vl_api_fib_path_t *fp;
15411 if (VAT_JSON_ARRAY != vam->json_tree.type)
15413 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15414 vat_json_init_array (&vam->json_tree);
15416 node = vat_json_array_add (&vam->json_tree);
15418 vat_json_init_object (node);
15419 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15420 clib_memcpy (&ip4, &mp->address, sizeof (ip4));
15421 vat_json_object_add_ip4 (node, "prefix", ip4);
15422 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15423 vat_json_object_add_uint (node, "path_count", count);
15425 for (i = 0; i < count; i++)
15427 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15428 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15429 vat_json_object_add_uint (node, "is_local", fp->is_local);
15430 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15431 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15432 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15433 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15434 if (fp->afi == IP46_TYPE_IP4)
15436 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15437 vat_json_object_add_ip4 (node, "next_hop", ip4);
15439 else if (fp->afi == IP46_TYPE_IP6)
15441 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15442 vat_json_object_add_ip6 (node, "next_hop", ip6);
15448 api_ip_fib_dump (vat_main_t * vam)
15450 vl_api_ip_fib_dump_t *mp;
15453 M (IP_FIB_DUMP, ip_fib_dump);
15456 /* Use a control ping for synchronization */
15458 vl_api_control_ping_t *mp;
15459 M (CONTROL_PING, control_ping);
15465 static void vl_api_ip_neighbor_details_t_handler
15466 (vl_api_ip_neighbor_details_t * mp)
15468 vat_main_t *vam = &vat_main;
15470 fformat (vam->ofp, "%c %U %U\n",
15471 (mp->is_static) ? 'S' : 'D',
15472 format_ethernet_address, &mp->mac_address,
15473 (mp->is_ipv6) ? format_ip6_address : format_ip4_address,
15477 static void vl_api_ip_neighbor_details_t_handler_json
15478 (vl_api_ip_neighbor_details_t * mp)
15481 vat_main_t *vam = &vat_main;
15482 vat_json_node_t *node;
15483 struct in_addr ip4;
15484 struct in6_addr ip6;
15486 if (VAT_JSON_ARRAY != vam->json_tree.type)
15488 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15489 vat_json_init_array (&vam->json_tree);
15491 node = vat_json_array_add (&vam->json_tree);
15493 vat_json_init_object (node);
15494 vat_json_object_add_string_copy (node, "flag",
15495 (mp->is_static) ? (u8 *) "static" : (u8 *)
15498 vat_json_object_add_string_copy (node, "link_layer",
15499 format (0, "%U", format_ethernet_address,
15500 &mp->mac_address));
15504 clib_memcpy (&ip6, &mp->ip_address, sizeof (ip6));
15505 vat_json_object_add_ip6 (node, "ip_address", ip6);
15509 clib_memcpy (&ip4, &mp->ip_address, sizeof (ip4));
15510 vat_json_object_add_ip4 (node, "ip_address", ip4);
15515 api_ip_neighbor_dump (vat_main_t * vam)
15517 unformat_input_t *i = vam->input;
15518 vl_api_ip_neighbor_dump_t *mp;
15521 u32 sw_if_index = ~0;
15523 /* Parse args required to build the message */
15524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15526 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
15528 else if (unformat (i, "sw_if_index %d", &sw_if_index))
15530 else if (unformat (i, "ip6"))
15536 if (sw_if_index == ~0)
15538 errmsg ("missing interface name or sw_if_index\n");
15542 M (IP_NEIGHBOR_DUMP, ip_neighbor_dump);
15543 mp->is_ipv6 = (u8) is_ipv6;
15544 mp->sw_if_index = ntohl (sw_if_index);
15547 /* Use a control ping for synchronization */
15549 vl_api_control_ping_t *mp;
15550 M (CONTROL_PING, control_ping);
15556 #define vl_api_ip6_fib_details_t_endian vl_noop_handler
15557 #define vl_api_ip6_fib_details_t_print vl_noop_handler
15560 vl_api_ip6_fib_details_t_handler (vl_api_ip6_fib_details_t * mp)
15562 vat_main_t *vam = &vat_main;
15563 int count = ntohl (mp->count);
15564 vl_api_fib_path_t *fp;
15568 "table-id %d, prefix %U/%d\n",
15569 ntohl (mp->table_id), format_ip6_address, mp->address,
15570 mp->address_length);
15572 for (i = 0; i < count; i++)
15574 if (fp->afi == IP46_TYPE_IP6)
15576 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15577 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15578 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15579 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15580 format_ip6_address, fp->next_hop);
15581 else if (fp->afi == IP46_TYPE_IP4)
15583 " weight %d, sw_if_index %d, is_local %d, is_drop %d, "
15584 "is_unreach %d, is_prohitbit %d, afi %d, next_hop %U\n",
15585 ntohl (fp->weight), ntohl (fp->sw_if_index), fp->is_local,
15586 fp->is_drop, fp->is_unreach, fp->is_prohibit, fp->afi,
15587 format_ip4_address, fp->next_hop);
15592 static void vl_api_ip6_fib_details_t_handler_json
15593 (vl_api_ip6_fib_details_t * mp)
15595 vat_main_t *vam = &vat_main;
15596 int count = ntohl (mp->count);
15597 vat_json_node_t *node = NULL;
15598 struct in_addr ip4;
15599 struct in6_addr ip6;
15600 vl_api_fib_path_t *fp;
15603 if (VAT_JSON_ARRAY != vam->json_tree.type)
15605 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15606 vat_json_init_array (&vam->json_tree);
15608 node = vat_json_array_add (&vam->json_tree);
15610 vat_json_init_object (node);
15611 vat_json_object_add_uint (node, "table", ntohl (mp->table_id));
15612 clib_memcpy (&ip6, &mp->address, sizeof (ip6));
15613 vat_json_object_add_ip6 (node, "prefix", ip6);
15614 vat_json_object_add_uint (node, "mask_length", mp->address_length);
15615 vat_json_object_add_uint (node, "path_count", count);
15617 for (i = 0; i < count; i++)
15619 vat_json_object_add_uint (node, "weight", ntohl (fp->weight));
15620 vat_json_object_add_uint (node, "sw_if_index", ntohl (fp->sw_if_index));
15621 vat_json_object_add_uint (node, "is_local", fp->is_local);
15622 vat_json_object_add_uint (node, "is_drop", fp->is_drop);
15623 vat_json_object_add_uint (node, "is_unreach", fp->is_unreach);
15624 vat_json_object_add_uint (node, "is_prohibit", fp->is_prohibit);
15625 vat_json_object_add_uint (node, "next_hop_afi", fp->afi);
15626 if (fp->afi == IP46_TYPE_IP4)
15628 clib_memcpy (&ip4, &fp->next_hop, sizeof (ip4));
15629 vat_json_object_add_ip4 (node, "next_hop", ip4);
15631 else if (fp->afi == IP46_TYPE_IP6)
15633 clib_memcpy (&ip6, &fp->next_hop, sizeof (ip6));
15634 vat_json_object_add_ip6 (node, "next_hop", ip6);
15640 api_ip6_fib_dump (vat_main_t * vam)
15642 vl_api_ip6_fib_dump_t *mp;
15645 M (IP6_FIB_DUMP, ip6_fib_dump);
15648 /* Use a control ping for synchronization */
15650 vl_api_control_ping_t *mp;
15651 M (CONTROL_PING, control_ping);
15658 api_classify_table_ids (vat_main_t * vam)
15660 vl_api_classify_table_ids_t *mp;
15663 /* Construct the API message */
15664 M (CLASSIFY_TABLE_IDS, classify_table_ids);
15674 api_classify_table_by_interface (vat_main_t * vam)
15676 unformat_input_t *input = vam->input;
15677 vl_api_classify_table_by_interface_t *mp;
15680 u32 sw_if_index = ~0;
15681 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15683 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
15685 else if (unformat (input, "sw_if_index %d", &sw_if_index))
15690 if (sw_if_index == ~0)
15692 errmsg ("missing interface name or sw_if_index\n");
15696 /* Construct the API message */
15697 M (CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
15699 mp->sw_if_index = ntohl (sw_if_index);
15708 api_classify_table_info (vat_main_t * vam)
15710 unformat_input_t *input = vam->input;
15711 vl_api_classify_table_info_t *mp;
15715 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15717 if (unformat (input, "table_id %d", &table_id))
15722 if (table_id == ~0)
15724 errmsg ("missing table id\n");
15728 /* Construct the API message */
15729 M (CLASSIFY_TABLE_INFO, classify_table_info);
15731 mp->table_id = ntohl (table_id);
15740 api_classify_session_dump (vat_main_t * vam)
15742 unformat_input_t *input = vam->input;
15743 vl_api_classify_session_dump_t *mp;
15747 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
15749 if (unformat (input, "table_id %d", &table_id))
15754 if (table_id == ~0)
15756 errmsg ("missing table id\n");
15760 /* Construct the API message */
15761 M (CLASSIFY_SESSION_DUMP, classify_session_dump);
15763 mp->table_id = ntohl (table_id);
15766 /* Use a control ping for synchronization */
15768 vl_api_control_ping_t *mp;
15769 M (CONTROL_PING, control_ping);
15778 vl_api_ipfix_exporter_details_t_handler (vl_api_ipfix_exporter_details_t * mp)
15780 vat_main_t *vam = &vat_main;
15782 fformat (vam->ofp, "collector_address %U, collector_port %d, "
15783 "src_address %U, vrf_id %d, path_mtu %u, "
15784 "template_interval %u, udp_checksum %d\n",
15785 format_ip4_address, mp->collector_address,
15786 ntohs (mp->collector_port),
15787 format_ip4_address, mp->src_address,
15788 ntohl (mp->vrf_id), ntohl (mp->path_mtu),
15789 ntohl (mp->template_interval), mp->udp_checksum);
15792 vam->result_ready = 1;
15796 vl_api_ipfix_exporter_details_t_handler_json
15797 (vl_api_ipfix_exporter_details_t * mp)
15799 vat_main_t *vam = &vat_main;
15800 vat_json_node_t node;
15801 struct in_addr collector_address;
15802 struct in_addr src_address;
15804 vat_json_init_object (&node);
15805 clib_memcpy (&collector_address, &mp->collector_address,
15806 sizeof (collector_address));
15807 vat_json_object_add_ip4 (&node, "collector_address", collector_address);
15808 vat_json_object_add_uint (&node, "collector_port",
15809 ntohs (mp->collector_port));
15810 clib_memcpy (&src_address, &mp->src_address, sizeof (src_address));
15811 vat_json_object_add_ip4 (&node, "src_address", src_address);
15812 vat_json_object_add_int (&node, "vrf_id", ntohl (mp->vrf_id));
15813 vat_json_object_add_uint (&node, "path_mtu", ntohl (mp->path_mtu));
15814 vat_json_object_add_uint (&node, "template_interval",
15815 ntohl (mp->template_interval));
15816 vat_json_object_add_int (&node, "udp_checksum", mp->udp_checksum);
15818 vat_json_print (vam->ofp, &node);
15819 vat_json_free (&node);
15821 vam->result_ready = 1;
15825 api_ipfix_exporter_dump (vat_main_t * vam)
15827 vl_api_ipfix_exporter_dump_t *mp;
15830 /* Construct the API message */
15831 M (IPFIX_EXPORTER_DUMP, ipfix_exporter_dump);
15841 api_ipfix_classify_stream_dump (vat_main_t * vam)
15843 vl_api_ipfix_classify_stream_dump_t *mp;
15846 /* Construct the API message */
15847 M (IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump);
15857 vl_api_ipfix_classify_stream_details_t_handler
15858 (vl_api_ipfix_classify_stream_details_t * mp)
15860 vat_main_t *vam = &vat_main;
15861 fformat (vam->ofp, "domain_id %d, src_port %d\n",
15862 ntohl (mp->domain_id), ntohs (mp->src_port));
15864 vam->result_ready = 1;
15868 vl_api_ipfix_classify_stream_details_t_handler_json
15869 (vl_api_ipfix_classify_stream_details_t * mp)
15871 vat_main_t *vam = &vat_main;
15872 vat_json_node_t node;
15874 vat_json_init_object (&node);
15875 vat_json_object_add_uint (&node, "domain_id", ntohl (mp->domain_id));
15876 vat_json_object_add_uint (&node, "src_port", ntohs (mp->src_port));
15878 vat_json_print (vam->ofp, &node);
15879 vat_json_free (&node);
15881 vam->result_ready = 1;
15885 api_ipfix_classify_table_dump (vat_main_t * vam)
15887 vl_api_ipfix_classify_table_dump_t *mp;
15890 if (!vam->json_output)
15892 fformat (vam->ofp, "%15s%15s%20s\n", "table_id", "ip_version",
15893 "transport_protocol");
15896 /* Construct the API message */
15897 M (IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump);
15902 /* Use a control ping for synchronization */
15904 vl_api_control_ping_t *mp;
15905 M (CONTROL_PING, control_ping);
15912 vl_api_ipfix_classify_table_details_t_handler
15913 (vl_api_ipfix_classify_table_details_t * mp)
15915 vat_main_t *vam = &vat_main;
15916 fformat (vam->ofp, "%15d%15d%20d\n", ntohl (mp->table_id), mp->ip_version,
15917 mp->transport_protocol);
15921 vl_api_ipfix_classify_table_details_t_handler_json
15922 (vl_api_ipfix_classify_table_details_t * mp)
15924 vat_json_node_t *node = NULL;
15925 vat_main_t *vam = &vat_main;
15927 if (VAT_JSON_ARRAY != vam->json_tree.type)
15929 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
15930 vat_json_init_array (&vam->json_tree);
15933 node = vat_json_array_add (&vam->json_tree);
15934 vat_json_init_object (node);
15936 vat_json_object_add_uint (node, "table_id", ntohl (mp->table_id));
15937 vat_json_object_add_uint (node, "ip_version", mp->ip_version);
15938 vat_json_object_add_uint (node, "transport_protocol",
15939 mp->transport_protocol);
15943 api_sw_interface_span_enable_disable (vat_main_t * vam)
15945 unformat_input_t *i = vam->input;
15946 vl_api_sw_interface_span_enable_disable_t *mp;
15948 u32 src_sw_if_index = ~0;
15949 u32 dst_sw_if_index = ~0;
15952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
15954 if (unformat (i, "src %U", unformat_sw_if_index, vam, &src_sw_if_index))
15956 else if (unformat (i, "src_sw_if_index %d", &src_sw_if_index))
15960 (i, "dst %U", unformat_sw_if_index, vam, &dst_sw_if_index))
15962 else if (unformat (i, "dst_sw_if_index %d", &dst_sw_if_index))
15964 else if (unformat (i, "disable"))
15966 else if (unformat (i, "rx"))
15968 else if (unformat (i, "tx"))
15970 else if (unformat (i, "both"))
15976 M (SW_INTERFACE_SPAN_ENABLE_DISABLE, sw_interface_span_enable_disable);
15978 mp->sw_if_index_from = htonl (src_sw_if_index);
15979 mp->sw_if_index_to = htonl (dst_sw_if_index);
15989 vl_api_sw_interface_span_details_t_handler (vl_api_sw_interface_span_details_t
15992 vat_main_t *vam = &vat_main;
15993 u8 *sw_if_from_name = 0;
15994 u8 *sw_if_to_name = 0;
15995 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
15996 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
15997 char *states[] = { "none", "rx", "tx", "both" };
16001 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16003 if ((u32) p->value[0] == sw_if_index_from)
16005 sw_if_from_name = (u8 *)(p->key);
16009 if ((u32) p->value[0] == sw_if_index_to)
16011 sw_if_to_name = (u8 *)(p->key);
16012 if (sw_if_from_name)
16017 fformat (vam->ofp, "%20s => %20s (%s)\n",
16018 sw_if_from_name, sw_if_to_name, states[mp->state]);
16022 vl_api_sw_interface_span_details_t_handler_json
16023 (vl_api_sw_interface_span_details_t * mp)
16025 vat_main_t *vam = &vat_main;
16026 vat_json_node_t *node = NULL;
16027 u8 *sw_if_from_name = 0;
16028 u8 *sw_if_to_name = 0;
16029 u32 sw_if_index_from = ntohl (mp->sw_if_index_from);
16030 u32 sw_if_index_to = ntohl (mp->sw_if_index_to);
16034 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
16036 if ((u32) p->value[0] == sw_if_index_from)
16038 sw_if_from_name = (u8 *)(p->key);
16042 if ((u32) p->value[0] == sw_if_index_to)
16044 sw_if_to_name = (u8 *)(p->key);
16045 if (sw_if_from_name)
16051 if (VAT_JSON_ARRAY != vam->json_tree.type)
16053 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16054 vat_json_init_array (&vam->json_tree);
16056 node = vat_json_array_add (&vam->json_tree);
16058 vat_json_init_object (node);
16059 vat_json_object_add_uint (node, "src-if-index", sw_if_index_from);
16060 vat_json_object_add_string_copy (node, "src-if-name", sw_if_from_name);
16061 vat_json_object_add_uint (node, "dst-if-index", sw_if_index_to);
16062 vat_json_object_add_string_copy (node, "dst-if-name", sw_if_to_name);
16063 vat_json_object_add_uint (node, "state", mp->state);
16067 api_sw_interface_span_dump (vat_main_t * vam)
16069 vl_api_sw_interface_span_dump_t *mp;
16072 M (SW_INTERFACE_SPAN_DUMP, sw_interface_span_dump);
16075 /* Use a control ping for synchronization */
16077 vl_api_control_ping_t *mp;
16078 M (CONTROL_PING, control_ping);
16085 api_pg_create_interface (vat_main_t * vam)
16087 unformat_input_t *input = vam->input;
16088 vl_api_pg_create_interface_t *mp;
16092 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16094 if (unformat (input, "if_id %d", &if_id))
16101 errmsg ("missing pg interface index\n");
16105 /* Construct the API message */
16106 M (PG_CREATE_INTERFACE, pg_create_interface);
16108 mp->interface_id = ntohl (if_id);
16117 api_pg_capture (vat_main_t * vam)
16119 unformat_input_t *input = vam->input;
16120 vl_api_pg_capture_t *mp;
16126 u8 pcap_file_set = 0;
16128 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16130 if (unformat (input, "if_id %d", &if_id))
16132 else if (unformat (input, "pcap %s", &pcap_file))
16134 else if (unformat (input, "count %d", &count))
16136 else if (unformat (input, "disable"))
16143 errmsg ("missing pg interface index\n");
16146 if (pcap_file_set > 0)
16148 if (vec_len (pcap_file) > 255)
16150 errmsg ("pcap file name is too long\n");
16155 u32 name_len = vec_len (pcap_file);
16156 /* Construct the API message */
16157 M (PG_CAPTURE, pg_capture);
16159 mp->interface_id = ntohl (if_id);
16160 mp->is_enabled = enable;
16161 mp->count = ntohl (count);
16162 mp->pcap_name_length = ntohl (name_len);
16163 if (pcap_file_set != 0)
16165 clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
16167 vec_free (pcap_file);
16176 api_pg_enable_disable (vat_main_t * vam)
16178 unformat_input_t *input = vam->input;
16179 vl_api_pg_enable_disable_t *mp;
16183 u8 stream_name_set = 0;
16184 u8 *stream_name = 0;
16185 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16187 if (unformat (input, "stream %s", &stream_name))
16188 stream_name_set = 1;
16189 else if (unformat (input, "disable"))
16195 if (stream_name_set > 0)
16197 if (vec_len (stream_name) > 255)
16199 errmsg ("stream name too long\n");
16204 u32 name_len = vec_len (stream_name);
16205 /* Construct the API message */
16206 M (PG_ENABLE_DISABLE, pg_enable_disable);
16208 mp->is_enabled = enable;
16209 if (stream_name_set != 0)
16211 mp->stream_name_length = ntohl (name_len);
16212 clib_memcpy (mp->stream_name, stream_name, name_len);
16214 vec_free (stream_name);
16223 api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
16225 unformat_input_t *input = vam->input;
16226 vl_api_ip_source_and_port_range_check_add_del_t *mp;
16229 u16 *low_ports = 0;
16230 u16 *high_ports = 0;
16233 ip4_address_t ip4_addr;
16234 ip6_address_t ip6_addr;
16242 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16244 if (unformat (input, "%U/%d", unformat_ip4_address, &ip4_addr, &length))
16250 (input, "%U/%d", unformat_ip6_address, &ip6_addr, &length))
16255 else if (unformat (input, "vrf %d", &vrf_id))
16257 else if (unformat (input, "del"))
16259 else if (unformat (input, "port %d", &tmp))
16261 if (tmp == 0 || tmp > 65535)
16263 errmsg ("port %d out of range", tmp);
16267 this_hi = this_low + 1;
16268 vec_add1 (low_ports, this_low);
16269 vec_add1 (high_ports, this_hi);
16271 else if (unformat (input, "range %d - %d", &tmp, &tmp2))
16273 if ((tmp > tmp2) || (tmp == 0) || (tmp2 > 65535))
16275 errmsg ("incorrect range parameters\n");
16279 /* Note: in debug CLI +1 is added to high before
16280 passing to real fn that does "the work"
16281 (ip_source_and_port_range_check_add_del).
16282 This fn is a wrapper around the binary API fn a
16283 control plane will call, which expects this increment
16284 to have occurred. Hence letting the binary API control
16285 plane fn do the increment for consistency between VAT
16286 and other control planes.
16289 vec_add1 (low_ports, this_low);
16290 vec_add1 (high_ports, this_hi);
16296 if (prefix_set == 0)
16298 errmsg ("<address>/<mask> not specified\n");
16304 errmsg ("VRF ID required, not specified\n");
16311 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
16315 if (vec_len (low_ports) == 0)
16317 errmsg ("At least one port or port range required\n");
16321 M (IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL,
16322 ip_source_and_port_range_check_add_del);
16324 mp->is_add = is_add;
16329 clib_memcpy (mp->address, &ip6_addr, sizeof (ip6_addr));
16334 clib_memcpy (mp->address, &ip4_addr, sizeof (ip4_addr));
16337 mp->mask_length = length;
16338 mp->number_of_ranges = vec_len (low_ports);
16340 clib_memcpy (mp->low_ports, low_ports, vec_len (low_ports));
16341 vec_free (low_ports);
16343 clib_memcpy (mp->high_ports, high_ports, vec_len (high_ports));
16344 vec_free (high_ports);
16346 mp->vrf_id = ntohl (vrf_id);
16355 api_ip_source_and_port_range_check_interface_add_del (vat_main_t * vam)
16357 unformat_input_t *input = vam->input;
16358 vl_api_ip_source_and_port_range_check_interface_add_del_t *mp;
16360 u32 sw_if_index = ~0;
16362 u32 tcp_out_vrf_id = ~0, udp_out_vrf_id = ~0;
16363 u32 tcp_in_vrf_id = ~0, udp_in_vrf_id = ~0;
16366 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
16368 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
16370 else if (unformat (input, "sw_if_index %d", &sw_if_index))
16372 else if (unformat (input, "tcp-out-vrf %d", &tcp_out_vrf_id))
16374 else if (unformat (input, "udp-out-vrf %d", &udp_out_vrf_id))
16376 else if (unformat (input, "tcp-in-vrf %d", &tcp_in_vrf_id))
16378 else if (unformat (input, "udp-in-vrf %d", &udp_in_vrf_id))
16380 else if (unformat (input, "del"))
16386 if (sw_if_index == ~0)
16388 errmsg ("Interface required but not specified\n");
16394 errmsg ("VRF ID required but not specified\n");
16398 if (tcp_out_vrf_id == 0
16399 || udp_out_vrf_id == 0 || tcp_in_vrf_id == 0 || udp_in_vrf_id == 0)
16402 ("VRF ID should not be default. Should be distinct VRF for this purpose.\n");
16406 /* Construct the API message */
16407 M (IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL,
16408 ip_source_and_port_range_check_interface_add_del);
16410 mp->sw_if_index = ntohl (sw_if_index);
16411 mp->is_add = is_add;
16412 mp->tcp_out_vrf_id = ntohl (tcp_out_vrf_id);
16413 mp->udp_out_vrf_id = ntohl (udp_out_vrf_id);
16414 mp->tcp_in_vrf_id = ntohl (tcp_in_vrf_id);
16415 mp->udp_in_vrf_id = ntohl (udp_in_vrf_id);
16420 /* Wait for a reply... */
16425 api_ipsec_gre_add_del_tunnel (vat_main_t * vam)
16427 unformat_input_t *i = vam->input;
16428 vl_api_ipsec_gre_add_del_tunnel_t *mp;
16430 u32 local_sa_id = 0;
16431 u32 remote_sa_id = 0;
16432 ip4_address_t src_address;
16433 ip4_address_t dst_address;
16436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16438 if (unformat (i, "local_sa %d", &local_sa_id))
16440 else if (unformat (i, "remote_sa %d", &remote_sa_id))
16442 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
16444 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
16446 else if (unformat (i, "del"))
16450 clib_warning ("parse error '%U'", format_unformat_error, i);
16455 M (IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel);
16457 mp->local_sa_id = ntohl (local_sa_id);
16458 mp->remote_sa_id = ntohl (remote_sa_id);
16459 clib_memcpy (mp->src_address, &src_address, sizeof (src_address));
16460 clib_memcpy (mp->dst_address, &dst_address, sizeof (dst_address));
16461 mp->is_add = is_add;
16470 api_punt (vat_main_t * vam)
16472 unformat_input_t *i = vam->input;
16480 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16482 if (unformat (i, "ip %d", &ipv))
16484 else if (unformat (i, "protocol %d", &protocol))
16486 else if (unformat (i, "port %d", &port))
16488 else if (unformat (i, "del"))
16492 clib_warning ("parse error '%U'", format_unformat_error, i);
16499 mp->is_add = (u8) is_add;
16500 mp->ipv = (u8) ipv;
16501 mp->l4_protocol = (u8) protocol;
16502 mp->l4_port = htons ((u16) port);
16510 static void vl_api_ipsec_gre_tunnel_details_t_handler
16511 (vl_api_ipsec_gre_tunnel_details_t * mp)
16513 vat_main_t *vam = &vat_main;
16515 fformat (vam->ofp, "%11d%15U%15U%14d%14d\n",
16516 ntohl (mp->sw_if_index),
16517 format_ip4_address, &mp->src_address,
16518 format_ip4_address, &mp->dst_address,
16519 ntohl (mp->local_sa_id), ntohl (mp->remote_sa_id));
16522 static void vl_api_ipsec_gre_tunnel_details_t_handler_json
16523 (vl_api_ipsec_gre_tunnel_details_t * mp)
16525 vat_main_t *vam = &vat_main;
16526 vat_json_node_t *node = NULL;
16527 struct in_addr ip4;
16529 if (VAT_JSON_ARRAY != vam->json_tree.type)
16531 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16532 vat_json_init_array (&vam->json_tree);
16534 node = vat_json_array_add (&vam->json_tree);
16536 vat_json_init_object (node);
16537 vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
16538 clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
16539 vat_json_object_add_ip4 (node, "src_address", ip4);
16540 clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
16541 vat_json_object_add_ip4 (node, "dst_address", ip4);
16542 vat_json_object_add_uint (node, "local_sa_id", ntohl (mp->local_sa_id));
16543 vat_json_object_add_uint (node, "remote_sa_id", ntohl (mp->remote_sa_id));
16547 api_ipsec_gre_tunnel_dump (vat_main_t * vam)
16549 unformat_input_t *i = vam->input;
16550 vl_api_ipsec_gre_tunnel_dump_t *mp;
16553 u8 sw_if_index_set = 0;
16555 /* Parse args required to build the message */
16556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16558 if (unformat (i, "sw_if_index %d", &sw_if_index))
16559 sw_if_index_set = 1;
16564 if (sw_if_index_set == 0)
16569 if (!vam->json_output)
16571 fformat (vam->ofp, "%11s%15s%15s%14s%14s\n",
16572 "sw_if_index", "src_address", "dst_address",
16573 "local_sa_id", "remote_sa_id");
16576 /* Get list of gre-tunnel interfaces */
16577 M (IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump);
16579 mp->sw_if_index = htonl (sw_if_index);
16583 /* Use a control ping for synchronization */
16585 vl_api_control_ping_t *mp;
16586 M (CONTROL_PING, control_ping);
16593 api_delete_subif (vat_main_t * vam)
16595 unformat_input_t *i = vam->input;
16596 vl_api_delete_subif_t *mp;
16598 u32 sw_if_index = ~0;
16600 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16602 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16604 if (unformat (i, "sw_if_index %d", &sw_if_index))
16610 if (sw_if_index == ~0)
16612 errmsg ("missing sw_if_index\n");
16616 /* Construct the API message */
16617 M (DELETE_SUBIF, delete_subif);
16618 mp->sw_if_index = ntohl (sw_if_index);
16624 #define foreach_pbb_vtr_op \
16625 _("disable", L2_VTR_DISABLED) \
16626 _("pop", L2_VTR_POP_2) \
16627 _("push", L2_VTR_PUSH_2)
16630 api_l2_interface_pbb_tag_rewrite (vat_main_t * vam)
16632 unformat_input_t *i = vam->input;
16633 vl_api_l2_interface_pbb_tag_rewrite_t *mp;
16635 u32 sw_if_index = ~0, vtr_op = ~0;
16636 u16 outer_tag = ~0;
16637 u8 dmac[6], smac[6];
16638 u8 dmac_set = 0, smac_set = 0;
16643 /* Shut up coverity */
16644 memset (dmac, 0, sizeof (dmac));
16645 memset (smac, 0, sizeof (smac));
16647 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16649 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16651 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16653 else if (unformat (i, "vtr_op %d", &vtr_op))
16655 #define _(n,v) else if (unformat(i, n)) {vtr_op = v;}
16658 else if (unformat (i, "translate_pbb_stag"))
16660 if (unformat (i, "%d", &tmp))
16662 vtr_op = L2_VTR_TRANSLATE_2_1;
16668 ("translate_pbb_stag operation requires outer tag definition\n");
16672 else if (unformat (i, "dmac %U", unformat_ethernet_address, dmac))
16674 else if (unformat (i, "smac %U", unformat_ethernet_address, smac))
16676 else if (unformat (i, "sid %d", &sid))
16678 else if (unformat (i, "vlanid %d", &tmp))
16682 clib_warning ("parse error '%U'", format_unformat_error, i);
16687 if ((sw_if_index == ~0) || (vtr_op == ~0))
16689 errmsg ("missing sw_if_index or vtr operation\n");
16692 if (((vtr_op == L2_VTR_PUSH_2) || (vtr_op == L2_VTR_TRANSLATE_2_2))
16693 && ((dmac_set == 0) || (smac_set == 0) || (sid == ~0)))
16696 ("push and translate_qinq operations require dmac, smac, sid and optionally vlanid\n");
16700 M (L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite);
16701 mp->sw_if_index = ntohl (sw_if_index);
16702 mp->vtr_op = ntohl (vtr_op);
16703 mp->outer_tag = ntohs (outer_tag);
16704 clib_memcpy (mp->b_dmac, dmac, sizeof (dmac));
16705 clib_memcpy (mp->b_smac, smac, sizeof (smac));
16706 mp->b_vlanid = ntohs (vlanid);
16707 mp->i_sid = ntohl (sid);
16716 api_flow_classify_set_interface (vat_main_t * vam)
16718 unformat_input_t *i = vam->input;
16719 vl_api_flow_classify_set_interface_t *mp;
16722 int sw_if_index_set;
16723 u32 ip4_table_index = ~0;
16724 u32 ip6_table_index = ~0;
16727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16729 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16730 sw_if_index_set = 1;
16731 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16732 sw_if_index_set = 1;
16733 else if (unformat (i, "del"))
16735 else if (unformat (i, "ip4-table %d", &ip4_table_index))
16737 else if (unformat (i, "ip6-table %d", &ip6_table_index))
16741 clib_warning ("parse error '%U'", format_unformat_error, i);
16746 if (sw_if_index_set == 0)
16748 errmsg ("missing interface name or sw_if_index\n");
16752 M (FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface);
16754 mp->sw_if_index = ntohl (sw_if_index);
16755 mp->ip4_table_index = ntohl (ip4_table_index);
16756 mp->ip6_table_index = ntohl (ip6_table_index);
16757 mp->is_add = is_add;
16766 api_flow_classify_dump (vat_main_t * vam)
16768 unformat_input_t *i = vam->input;
16769 vl_api_flow_classify_dump_t *mp;
16771 u8 type = FLOW_CLASSIFY_N_TABLES;
16773 if (unformat (i, "type %U", unformat_flow_classify_table_type, &type))
16777 errmsg ("classify table type must be specified\n");
16781 if (!vam->json_output)
16783 fformat (vam->ofp, "%10s%20s\n", "Intfc idx", "Classify table");
16786 M (FLOW_CLASSIFY_DUMP, flow_classify_dump);
16791 /* Use a control ping for synchronization */
16793 vl_api_control_ping_t *mp;
16794 M (CONTROL_PING, control_ping);
16797 /* Wait for a reply... */
16805 api_feature_enable_disable (vat_main_t * vam)
16807 unformat_input_t *i = vam->input;
16808 vl_api_feature_enable_disable_t *mp;
16811 u8 *feature_name = 0;
16812 u32 sw_if_index = ~0;
16815 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16817 if (unformat (i, "arc_name %s", &arc_name))
16819 else if (unformat (i, "feature_name %s", &feature_name))
16821 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16823 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16825 else if (unformat (i, "disable"))
16833 errmsg ("missing arc name\n");
16836 if (vec_len (arc_name) > 63)
16838 errmsg ("arc name too long\n");
16841 if (feature_name == 0)
16843 errmsg ("missing feature name\n");
16846 if (vec_len (feature_name) > 63)
16848 errmsg ("feature name too long\n");
16851 if (sw_if_index == ~0)
16853 errmsg ("missing interface name or sw_if_index\n");
16857 /* Construct the API message */
16858 M (FEATURE_ENABLE_DISABLE, feature_enable_disable);
16859 mp->sw_if_index = ntohl (sw_if_index);
16860 mp->enable = enable;
16861 clib_memcpy (mp->arc_name, arc_name, vec_len (arc_name));
16862 clib_memcpy (mp->feature_name, feature_name, vec_len (feature_name));
16863 vec_free (arc_name);
16864 vec_free (feature_name);
16871 api_sw_interface_tag_add_del (vat_main_t * vam)
16873 unformat_input_t *i = vam->input;
16874 vl_api_sw_interface_tag_add_del_t *mp;
16876 u32 sw_if_index = ~0;
16880 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16882 if (unformat (i, "tag %s", &tag))
16884 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16886 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16888 else if (unformat (i, "del"))
16894 if (sw_if_index == ~0)
16896 errmsg ("missing interface name or sw_if_index\n");
16900 if (enable && (tag == 0))
16902 errmsg ("no tag specified\n");
16906 /* Construct the API message */
16907 M (SW_INTERFACE_TAG_ADD_DEL, sw_interface_tag_add_del);
16908 mp->sw_if_index = ntohl (sw_if_index);
16909 mp->is_add = enable;
16911 strncpy ((char *) mp->tag, (char *) tag, ARRAY_LEN (mp->tag) - 1);
16918 static void vl_api_l2_xconnect_details_t_handler
16919 (vl_api_l2_xconnect_details_t * mp)
16921 vat_main_t *vam = &vat_main;
16923 fformat (vam->ofp, "%15d%15d\n",
16924 ntohl (mp->rx_sw_if_index), ntohl (mp->tx_sw_if_index));
16927 static void vl_api_l2_xconnect_details_t_handler_json
16928 (vl_api_l2_xconnect_details_t * mp)
16930 vat_main_t *vam = &vat_main;
16931 vat_json_node_t *node = NULL;
16933 if (VAT_JSON_ARRAY != vam->json_tree.type)
16935 ASSERT (VAT_JSON_NONE == vam->json_tree.type);
16936 vat_json_init_array (&vam->json_tree);
16938 node = vat_json_array_add (&vam->json_tree);
16940 vat_json_init_object (node);
16941 vat_json_object_add_uint (node, "rx_sw_if_index",
16942 ntohl (mp->rx_sw_if_index));
16943 vat_json_object_add_uint (node, "tx_sw_if_index",
16944 ntohl (mp->tx_sw_if_index));
16948 api_l2_xconnect_dump (vat_main_t * vam)
16950 vl_api_l2_xconnect_dump_t *mp;
16953 if (!vam->json_output)
16955 fformat (vam->ofp, "%15s%15s\n", "rx_sw_if_index", "tx_sw_if_index");
16958 M (L2_XCONNECT_DUMP, l2_xconnect_dump);
16962 /* Use a control ping for synchronization */
16964 vl_api_control_ping_t *mp;
16965 M (CONTROL_PING, control_ping);
16972 api_sw_interface_set_mtu (vat_main_t * vam)
16974 unformat_input_t *i = vam->input;
16975 vl_api_sw_interface_set_mtu_t *mp;
16977 u32 sw_if_index = ~0;
16980 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
16982 if (unformat (i, "mtu %d", &mtu))
16984 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
16986 else if (unformat (i, "sw_if_index %d", &sw_if_index))
16992 if (sw_if_index == ~0)
16994 errmsg ("missing interface name or sw_if_index\n");
17000 errmsg ("no mtu specified\n");
17004 /* Construct the API message */
17005 M (SW_INTERFACE_SET_MTU, sw_interface_set_mtu);
17006 mp->sw_if_index = ntohl (sw_if_index);
17007 mp->mtu = ntohs ((u16) mtu);
17015 q_or_quit (vat_main_t * vam)
17017 longjmp (vam->jump_buf, 1);
17018 return 0; /* not so much */
17022 q (vat_main_t * vam)
17024 return q_or_quit (vam);
17028 quit (vat_main_t * vam)
17030 return q_or_quit (vam);
17034 comment (vat_main_t * vam)
17040 cmd_cmp (void *a1, void *a2)
17045 return strcmp ((char *) (c1[0]), (char *) (c2[0]));
17049 help (vat_main_t * vam)
17054 unformat_input_t *i = vam->input;
17057 if (unformat (i, "%s", &name))
17061 vec_add1 (name, 0);
17063 hs = hash_get_mem (vam->help_by_name, name);
17065 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
17067 fformat (vam->ofp, "No such msg / command '%s'\n", name);
17072 fformat (vam->ofp, "Help is available for the following:\n");
17075 hash_foreach_pair (p, vam->function_by_name,
17077 vec_add1 (cmds, (u8 *)(p->key));
17081 vec_sort_with_function (cmds, cmd_cmp);
17083 for (j = 0; j < vec_len (cmds); j++)
17084 fformat (vam->ofp, "%s\n", cmds[j]);
17091 set (vat_main_t * vam)
17093 u8 *name = 0, *value = 0;
17094 unformat_input_t *i = vam->input;
17096 if (unformat (i, "%s", &name))
17098 /* The input buffer is a vector, not a string. */
17099 value = vec_dup (i->buffer);
17100 vec_delete (value, i->index, 0);
17101 /* Almost certainly has a trailing newline */
17102 if (value[vec_len (value) - 1] == '\n')
17103 value[vec_len (value) - 1] = 0;
17104 /* Make sure it's a proper string, one way or the other */
17105 vec_add1 (value, 0);
17106 (void) clib_macro_set_value (&vam->macro_main,
17107 (char *) name, (char *) value);
17110 errmsg ("usage: set <name> <value>\n");
17118 unset (vat_main_t * vam)
17122 if (unformat (vam->input, "%s", &name))
17123 if (clib_macro_unset (&vam->macro_main, (char *) name) == 1)
17124 errmsg ("unset: %s wasn't set\n", name);
17137 macro_sort_cmp (void *a1, void *a2)
17139 macro_sort_t *s1 = a1;
17140 macro_sort_t *s2 = a2;
17142 return strcmp ((char *) (s1->name), (char *) (s2->name));
17146 dump_macro_table (vat_main_t * vam)
17148 macro_sort_t *sort_me = 0, *sm;
17153 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
17155 vec_add2 (sort_me, sm, 1);
17156 sm->name = (u8 *)(p->key);
17157 sm->value = (u8 *) (p->value[0]);
17161 vec_sort_with_function (sort_me, macro_sort_cmp);
17163 if (vec_len (sort_me))
17164 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
17166 fformat (vam->ofp, "The macro table is empty...\n");
17168 for (i = 0; i < vec_len (sort_me); i++)
17169 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name, sort_me[i].value);
17174 dump_node_table (vat_main_t * vam)
17177 vlib_node_t *node, *next_node;
17179 if (vec_len (vam->graph_nodes) == 0)
17181 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
17185 for (i = 0; i < vec_len (vam->graph_nodes); i++)
17187 node = vam->graph_nodes[i];
17188 fformat (vam->ofp, "[%d] %s\n", i, node->name);
17189 for (j = 0; j < vec_len (node->next_nodes); j++)
17191 if (node->next_nodes[j] != ~0)
17193 next_node = vam->graph_nodes[node->next_nodes[j]];
17194 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
17202 value_sort_cmp (void *a1, void *a2)
17204 name_sort_t *n1 = a1;
17205 name_sort_t *n2 = a2;
17207 if (n1->value < n2->value)
17209 if (n1->value > n2->value)
17216 dump_msg_api_table (vat_main_t * vam)
17218 api_main_t *am = &api_main;
17219 name_sort_t *nses = 0, *ns;
17224 hash_foreach_pair (hp, am->msg_index_by_name_and_crc,
17226 vec_add2 (nses, ns, 1);
17227 ns->name = (u8 *)(hp->key);
17228 ns->value = (u32) hp->value[0];
17232 vec_sort_with_function (nses, value_sort_cmp);
17234 for (i = 0; i < vec_len (nses); i++)
17235 fformat (vam->ofp, " [%d]: %s\n", nses[i].value, nses[i].name);
17241 get_msg_id (vat_main_t * vam)
17246 if (unformat (vam->input, "%s", &name_and_crc))
17248 message_index = vl_api_get_msg_index (name_and_crc);
17249 if (message_index == ~0)
17251 fformat (vam->ofp, " '%s' not found\n", name_and_crc);
17254 fformat (vam->ofp, " '%s' has message index %d\n",
17255 name_and_crc, message_index);
17258 errmsg ("name_and_crc required...\n");
17263 search_node_table (vat_main_t * vam)
17265 unformat_input_t *line_input = vam->input;
17268 vlib_node_t *node, *next_node;
17271 if (vam->graph_node_index_by_name == 0)
17273 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
17277 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
17279 if (unformat (line_input, "%s", &node_to_find))
17281 vec_add1 (node_to_find, 0);
17282 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
17285 fformat (vam->ofp, "%s not found...\n", node_to_find);
17288 node = vam->graph_nodes[p[0]];
17289 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
17290 for (j = 0; j < vec_len (node->next_nodes); j++)
17292 if (node->next_nodes[j] != ~0)
17294 next_node = vam->graph_nodes[node->next_nodes[j]];
17295 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
17302 clib_warning ("parse error '%U'", format_unformat_error,
17308 vec_free (node_to_find);
17317 script (vat_main_t * vam)
17320 char *save_current_file;
17321 unformat_input_t save_input;
17322 jmp_buf save_jump_buf;
17323 u32 save_line_number;
17325 FILE *new_fp, *save_ifp;
17327 if (unformat (vam->input, "%s", &s))
17329 new_fp = fopen ((char *) s, "r");
17332 errmsg ("Couldn't open script file %s\n", s);
17339 errmsg ("Missing script name\n");
17343 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
17344 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
17345 save_ifp = vam->ifp;
17346 save_line_number = vam->input_line_number;
17347 save_current_file = (char *) vam->current_file;
17349 vam->input_line_number = 0;
17351 vam->current_file = s;
17354 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
17355 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
17356 vam->ifp = save_ifp;
17357 vam->input_line_number = save_line_number;
17358 vam->current_file = (u8 *) save_current_file;
17365 echo (vat_main_t * vam)
17367 fformat (vam->ofp, "%v", vam->input->buffer);
17371 /* List of API message constructors, CLI names map to api_xxx */
17372 #define foreach_vpe_api_msg \
17373 _(create_loopback,"[mac <mac-addr>]") \
17374 _(sw_interface_dump,"") \
17375 _(sw_interface_set_flags, \
17376 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
17377 _(sw_interface_add_del_address, \
17378 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
17379 _(sw_interface_set_table, \
17380 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
17381 _(sw_interface_set_mpls_enable, \
17382 "<intfc> | sw_if_index [disable | dis]") \
17383 _(sw_interface_set_vpath, \
17384 "<intfc> | sw_if_index <id> enable | disable") \
17385 _(sw_interface_set_vxlan_bypass, \
17386 "<intfc> | sw_if_index <id> [ip4 | ip6] enable | disable") \
17387 _(sw_interface_set_l2_xconnect, \
17388 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17389 "enable | disable") \
17390 _(sw_interface_set_l2_bridge, \
17391 "<intfc> | sw_if_index <id> bd_id <bridge-domain-id>\n" \
17392 "[shg <split-horizon-group>] [bvi]\n" \
17393 "enable | disable") \
17394 _(sw_interface_set_dpdk_hqos_pipe, \
17395 "rx <intfc> | sw_if_index <id> subport <subport-id> pipe <pipe-id>\n" \
17396 "profile <profile-id>\n") \
17397 _(sw_interface_set_dpdk_hqos_subport, \
17398 "rx <intfc> | sw_if_index <id> subport <subport-id> [rate <n>]\n" \
17399 "[bktsize <n>] [tc0 <n>] [tc1 <n>] [tc2 <n>] [tc3 <n>] [period <n>]\n") \
17400 _(sw_interface_set_dpdk_hqos_tctbl, \
17401 "rx <intfc> | sw_if_index <id> entry <n> tc <n> queue <n>\n") \
17402 _(bridge_domain_add_del, \
17403 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
17404 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
17406 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi] [count <nn>]\n") \
17408 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
17410 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
17412 "tapname <name> mac <mac-addr> | random-mac [tag <string>]") \
17414 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
17416 "<vpp-if-name> | sw_if_index <id>") \
17417 _(sw_interface_tap_dump, "") \
17418 _(ip_add_del_route, \
17419 "<addr>/<mask> via <addr> [table-id <n>]\n" \
17420 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17421 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17422 "[multipath] [count <n>]") \
17423 _(mpls_route_add_del, \
17424 "<label> <eos> via <addr> [table-id <n>]\n" \
17425 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
17426 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
17427 "[multipath] [count <n>]") \
17428 _(mpls_ip_bind_unbind, \
17429 "<label> <addr/len>") \
17430 _(mpls_tunnel_add_del, \
17431 " via <addr> [table-id <n>]\n" \
17432 "sw_if_index <id>] [l2] [del]") \
17433 _(proxy_arp_add_del, \
17434 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
17435 _(proxy_arp_intfc_enable_disable, \
17436 "<intfc> | sw_if_index <id> enable | disable") \
17437 _(sw_interface_set_unnumbered, \
17438 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
17439 _(ip_neighbor_add_del, \
17440 "(<intfc> | sw_if_index <id>) dst <ip46-address> " \
17441 "[mac <mac-addr>] [vrf <vrf-id>] [is_static] [del]") \
17442 _(reset_vrf, "vrf <id> [ipv6]") \
17443 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
17444 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
17445 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
17446 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
17447 "[outer_vlan_id_any][inner_vlan_id_any]") \
17448 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
17449 _(reset_fib, "vrf <n> [ipv6]") \
17450 _(dhcp_proxy_config, \
17451 "svr <v46-address> src <v46-address>\n" \
17452 "insert-cid <n> [del]") \
17453 _(dhcp_proxy_config_2, \
17454 "svr <v46-address> src <v46-address>\n" \
17455 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
17456 _(dhcp_proxy_set_vss, \
17457 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
17458 _(dhcp_client_config, \
17459 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
17460 _(set_ip_flow_hash, \
17461 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
17462 _(sw_interface_ip6_enable_disable, \
17463 "<intfc> | sw_if_index <id> enable | disable") \
17464 _(sw_interface_ip6_set_link_local_address, \
17465 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
17466 _(sw_interface_ip6nd_ra_prefix, \
17467 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
17468 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
17469 "[nolink] [isno]") \
17470 _(sw_interface_ip6nd_ra_config, \
17471 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
17472 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
17473 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
17474 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
17475 _(l2_patch_add_del, \
17476 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
17477 "enable | disable") \
17478 _(sr_tunnel_add_del, \
17479 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
17480 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
17481 "[policy <policy_name>]") \
17482 _(sr_policy_add_del, \
17483 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
17484 _(sr_multicast_map_add_del, \
17485 "address [ip6 multicast address] sr-policy [policy name] [del]") \
17486 _(classify_add_del_table, \
17487 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
17488 " [del] mask <mask-value>\n" \
17489 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>\n" \
17490 " [current-data-flag <n>] [current-data-offset <nn>] [table <nn>]") \
17491 _(classify_add_del_session, \
17492 "[hit-next|l2-hit-next|acl-hit-next|policer-hit-next] <name|nn>\n" \
17493 " table-index <nn> skip_n <nn> match_n <nn> match [hex] [l2]\n" \
17494 " [l3 [ip4|ip6]] [action set-ip4-fib-id <nn>]\n" \
17495 " [action set-ip6-fib-id <nn> | action <n> metadata <nn>] [del]") \
17496 _(classify_set_interface_ip_table, \
17497 "<intfc> | sw_if_index <nn> table <nn>") \
17498 _(classify_set_interface_l2_tables, \
17499 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17500 " [other-table <nn>]") \
17501 _(get_node_index, "node <node-name") \
17502 _(add_node_next, "node <node-name> next <next-node-name>") \
17503 _(l2tpv3_create_tunnel, \
17504 "client_address <ip6-addr> our_address <ip6-addr>\n" \
17505 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
17506 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
17507 _(l2tpv3_set_tunnel_cookies, \
17508 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
17509 "[new_remote_cookie <nn>]\n") \
17510 _(l2tpv3_interface_enable_disable, \
17511 "<intfc> | sw_if_index <nn> enable | disable") \
17512 _(l2tpv3_set_lookup_key, \
17513 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
17514 _(sw_if_l2tpv3_tunnel_dump, "") \
17515 _(vxlan_add_del_tunnel, \
17516 "src <ip-addr> { dst <ip-addr> | group <mcast-ip-addr>\n" \
17517 "{ <intfc> | mcast_sw_if_index <nn> } }\n" \
17518 "vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
17519 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17520 _(gre_add_del_tunnel, \
17521 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [teb] [del]\n") \
17522 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17523 _(l2_fib_clear_table, "") \
17524 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
17525 _(l2_interface_vlan_tag_rewrite, \
17526 "<intfc> | sw_if_index <nn> \n" \
17527 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
17528 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
17529 _(create_vhost_user_if, \
17530 "socket <filename> [server] [renumber <dev_instance>] " \
17531 "[mac <mac_address>]") \
17532 _(modify_vhost_user_if, \
17533 "<intfc> | sw_if_index <nn> socket <filename>\n" \
17534 "[server] [renumber <dev_instance>]") \
17535 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
17536 _(sw_interface_vhost_user_dump, "") \
17537 _(show_version, "") \
17538 _(vxlan_gpe_add_del_tunnel, \
17539 "local <addr> remote <addr> vni <nn>\n" \
17540 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
17541 "[next-ethernet] [next-nsh]\n") \
17542 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
17543 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
17544 _(interface_name_renumber, \
17545 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
17546 _(input_acl_set_interface, \
17547 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17548 " [l2-table <nn>] [del]") \
17549 _(want_ip4_arp_events, "address <ip4-address> [del]") \
17550 _(want_ip6_nd_events, "address <ip6-address> [del]") \
17551 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
17552 _(ip_dump, "ipv4 | ipv6") \
17553 _(ipsec_spd_add_del, "spd_id <n> [del]") \
17554 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
17556 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
17557 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
17558 " integ_alg <alg> integ_key <hex>") \
17559 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
17560 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
17561 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
17562 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
17563 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
17564 _(ikev2_profile_add_del, "name <profile_name> [del]") \
17565 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
17566 "(auth_data 0x<data> | auth_data <data>)") \
17567 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
17568 "(id_data 0x<data> | id_data <data>) (local|remote)") \
17569 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
17570 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
17571 "(local|remote)") \
17572 _(ikev2_set_local_key, "file <absolute_file_path>") \
17573 _(delete_loopback,"sw_if_index <nn>") \
17574 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
17575 _(map_add_domain, \
17576 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
17577 "ip6-src <ip6addr> " \
17578 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
17579 _(map_del_domain, "index <n>") \
17580 _(map_add_del_rule, \
17581 "index <n> psid <n> dst <ip6addr> [del]") \
17582 _(map_domain_dump, "") \
17583 _(map_rule_dump, "index <map-domain>") \
17584 _(want_interface_events, "enable|disable") \
17585 _(want_stats,"enable|disable") \
17586 _(get_first_msg_id, "client <name>") \
17587 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
17588 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
17589 "fib-id <nn> [ip4][ip6][default]") \
17590 _(get_node_graph, " ") \
17591 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
17592 _(ioam_enable, "[trace] [pow] [ppc <encap|decap>]") \
17593 _(ioam_disable, "") \
17594 _(lisp_add_del_locator_set, "locator-set <locator_name> [iface <intf> |"\
17595 " sw_if_index <sw_if_index> p <priority> " \
17596 "w <weight>] [del]") \
17597 _(lisp_add_del_locator, "locator-set <locator_name> " \
17598 "iface <intf> | sw_if_index <sw_if_index> " \
17599 "p <priority> w <weight> [del]") \
17600 _(lisp_add_del_local_eid,"vni <vni> eid " \
17601 "<ipv4|ipv6>/<prefix> | <L2 address> " \
17602 "locator-set <locator_name> [del]" \
17603 "[key-id sha1|sha256 secret-key <secret-key>]")\
17604 _(lisp_gpe_add_del_fwd_entry, "rmt_eid <eid> [lcl_eid <eid>] vni <vni>" \
17605 "dp_table <table> loc-pair <lcl_loc> <rmt_loc> ... [del]") \
17606 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
17607 _(lisp_add_del_map_server, "<ip4|6-addr> [del]") \
17608 _(lisp_gpe_enable_disable, "enable|disable") \
17609 _(lisp_enable_disable, "enable|disable") \
17610 _(lisp_map_register_enable_disable, "enable|disable") \
17611 _(lisp_rloc_probe_enable_disable, "enable|disable") \
17612 _(lisp_gpe_add_del_iface, "up|down") \
17613 _(lisp_add_del_remote_mapping, "add|del vni <vni> eid <dest-eid> " \
17615 "rloc <locator> p <prio> " \
17616 "w <weight> [rloc <loc> ... ] " \
17617 "action <action> [del-all]") \
17618 _(lisp_add_del_adjacency, "add|del vni <vni> reid <remote-eid> leid " \
17620 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
17621 _(lisp_map_request_mode, "src-dst|dst-only") \
17622 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
17623 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
17624 _(lisp_locator_set_dump, "[local | remote]") \
17625 _(lisp_locator_dump, "ls_index <index> | ls_name <name>") \
17626 _(lisp_eid_table_dump, "[eid <ipv4|ipv6>/<prefix> | <mac>] [vni] " \
17627 "[local] | [remote]") \
17628 _(lisp_eid_table_vni_dump, "") \
17629 _(lisp_eid_table_map_dump, "l2|l3") \
17630 _(lisp_gpe_tunnel_dump, "") \
17631 _(lisp_map_resolver_dump, "") \
17632 _(lisp_map_server_dump, "") \
17633 _(lisp_adjacencies_get, "vni <vni>") \
17634 _(show_lisp_rloc_probe_state, "") \
17635 _(show_lisp_map_register_state, "") \
17636 _(show_lisp_status, "") \
17637 _(lisp_get_map_request_itr_rlocs, "") \
17638 _(show_lisp_pitr, "") \
17639 _(show_lisp_map_request_mode, "") \
17640 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
17641 _(af_packet_delete, "name <host interface name>") \
17642 _(policer_add_del, "name <policer name> <params> [del]") \
17643 _(policer_dump, "[name <policer name>]") \
17644 _(policer_classify_set_interface, \
17645 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
17646 " [l2-table <nn>] [del]") \
17647 _(policer_classify_dump, "type [ip4|ip6|l2]") \
17648 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
17649 "[master|slave]") \
17650 _(netmap_delete, "name <interface name>") \
17651 _(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
17652 _(mpls_fib_dump, "") \
17653 _(classify_table_ids, "") \
17654 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
17655 _(classify_table_info, "table_id <nn>") \
17656 _(classify_session_dump, "table_id <nn>") \
17657 _(set_ipfix_exporter, "collector_address <ip4> [collector_port <nn>] " \
17658 "src_address <ip4> [vrf_id <nn>] [path_mtu <nn>] " \
17659 "[template_interval <nn>] [udp_checksum]") \
17660 _(ipfix_exporter_dump, "") \
17661 _(set_ipfix_classify_stream, "[domain <domain-id>] [src_port <src-port>]") \
17662 _(ipfix_classify_stream_dump, "") \
17663 _(ipfix_classify_table_add_del, "table <table-index> ip4|ip6 [tcp|udp]")\
17664 _(ipfix_classify_table_dump, "") \
17665 _(sw_interface_span_enable_disable, "[src <intfc> | src_sw_if_index <id>] [disable | [[dst <intfc> | dst_sw_if_index <id>] [both|rx|tx]]]") \
17666 _(sw_interface_span_dump, "") \
17667 _(get_next_index, "node-name <node-name> next-node-name <node-name>") \
17668 _(pg_create_interface, "if_id <nn>") \
17669 _(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
17670 _(pg_enable_disable, "[stream <id>] disable") \
17671 _(ip_source_and_port_range_check_add_del, \
17672 "<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
17673 _(ip_source_and_port_range_check_interface_add_del, \
17674 "<intf> | sw_if_index <nn> [tcp-out-vrf <id>] [tcp-in-vrf <id>]" \
17675 "[udp-in-vrf <id>] [udp-out-vrf <id>]") \
17676 _(ipsec_gre_add_del_tunnel, \
17677 "src <addr> dst <addr> local_sa <sa-id> remote_sa <sa-id> [del]") \
17678 _(ipsec_gre_tunnel_dump, "[sw_if_index <nn>]") \
17679 _(delete_subif,"<intfc> | sw_if_index <nn>") \
17680 _(l2_interface_pbb_tag_rewrite, \
17681 "<intfc> | sw_if_index <nn> \n" \
17682 "[disable | push | pop | translate_pbb_stag <outer_tag>] \n" \
17683 "dmac <mac> smac <mac> sid <nn> [vlanid <nn>]") \
17684 _(punt, "protocol <l4-protocol> [ip <ver>] [port <l4-port>] [del]") \
17685 _(flow_classify_set_interface, \
17686 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>] [del]") \
17687 _(flow_classify_dump, "type [ip4|ip6]") \
17688 _(ip_fib_dump, "") \
17689 _(ip6_fib_dump, "") \
17690 _(feature_enable_disable, "arc_name <arc_name> " \
17691 "feature_name <feature_name> <intfc> | sw_if_index <nn> [disable]") \
17692 _(sw_interface_tag_add_del, "<intfc> | sw_if_index <nn> tag <text>" \
17694 _(l2_xconnect_dump, "") \
17695 _(sw_interface_set_mtu, "<intfc> | sw_if_index <nn> mtu <nn>") \
17696 _(ip_neighbor_dump, "[ip6] <intfc> | sw_if_index <nn>") \
17697 _(sw_interface_get_table, "<intfc> | sw_if_index <id> [ipv6]")
17699 /* List of command functions, CLI names map directly to functions */
17700 #define foreach_cli_function \
17701 _(comment, "usage: comment <ignore-rest-of-line>") \
17702 _(dump_interface_table, "usage: dump_interface_table") \
17703 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
17704 _(dump_ipv4_table, "usage: dump_ipv4_table") \
17705 _(dump_ipv6_table, "usage: dump_ipv6_table") \
17706 _(dump_stats_table, "usage: dump_stats_table") \
17707 _(dump_macro_table, "usage: dump_macro_table ") \
17708 _(dump_node_table, "usage: dump_node_table") \
17709 _(dump_msg_api_table, "usage: dump_msg_api_table") \
17710 _(get_msg_id, "usage: get_msg_id name_and_crc") \
17711 _(echo, "usage: echo <message>") \
17712 _(exec, "usage: exec <vpe-debug-CLI-command>") \
17713 _(exec_inband, "usage: exec_inband <vpe-debug-CLI-command>") \
17714 _(help, "usage: help") \
17715 _(q, "usage: quit") \
17716 _(quit, "usage: quit") \
17717 _(search_node_table, "usage: search_node_table <name>...") \
17718 _(set, "usage: set <variable-name> <value>") \
17719 _(script, "usage: script <file-name>") \
17720 _(unset, "usage: unset <variable-name>")
17723 static void vl_api_##n##_t_handler_uni \
17724 (vl_api_##n##_t * mp) \
17726 vat_main_t * vam = &vat_main; \
17727 if (vam->json_output) { \
17728 vl_api_##n##_t_handler_json(mp); \
17730 vl_api_##n##_t_handler(mp); \
17733 foreach_vpe_api_reply_msg;
17737 vat_api_hookup (vat_main_t * vam)
17740 vl_msg_api_set_handlers(VL_API_##N, #n, \
17741 vl_api_##n##_t_handler_uni, \
17743 vl_api_##n##_t_endian, \
17744 vl_api_##n##_t_print, \
17745 sizeof(vl_api_##n##_t), 1);
17746 foreach_vpe_api_reply_msg;
17749 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
17751 vam->sw_if_index_by_interface_name = hash_create_string (0, sizeof (uword));
17753 vam->function_by_name = hash_create_string (0, sizeof (uword));
17755 vam->help_by_name = hash_create_string (0, sizeof (uword));
17757 /* API messages we can send */
17758 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
17759 foreach_vpe_api_msg;
17763 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
17764 foreach_vpe_api_msg;
17767 /* CLI functions */
17768 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
17769 foreach_cli_function;
17773 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
17774 foreach_cli_function;
17779 * fd.io coding-style-patch-verification: ON
17782 * eval: (c-set-style "gnu")