2 *------------------------------------------------------------------
5 * Copyright (c) 2014 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
21 #include <vlibapi/api.h>
22 #include <vlibmemory/api.h>
23 #include <vlibsocket/api.h>
24 #include <vnet/ip/ip.h>
25 #include <vnet/sr/sr_packet.h>
26 #include <vnet/l2/l2_input.h>
27 #include <vnet/l2tp/l2tp.h>
28 #include <vnet/vxlan/vxlan.h>
29 #include <vnet/gre/gre.h>
30 #include <vnet/vxlan-gpe/vxlan_gpe.h>
31 #include <vnet/lisp-gpe/lisp_gpe.h>
33 #include <vpp-api/vpe_msg_enum.h>
34 #include <vnet/l2/l2_classify.h>
35 #include <vnet/l2/l2_vtr.h>
36 #include <vnet/classify/input_acl.h>
37 #include <vnet/mpls-gre/mpls.h>
39 #include <vnet/ipsec/ipsec.h>
40 #include <vnet/ipsec/ikev2.h>
44 #include <vnet/map/map.h>
45 #include <vnet/cop/cop.h>
46 #include <vnet/ip/ip6_hop_by_hop.h>
47 #include <vnet/policer/xlate.h>
49 #include "vat/json_format.h"
51 #define vl_typedefs /* define message structures */
52 #include <vpp-api/vpe_all_api_h.h>
55 /* declare message handlers for each api */
57 #define vl_endianfun /* define message structures */
58 #include <vpp-api/vpe_all_api_h.h>
61 /* instantiate all the print functions we know about */
62 #define vl_print(handle, ...)
64 #include <vpp-api/vpe_all_api_h.h>
67 uword unformat_sw_if_index (unformat_input_t * input, va_list * args)
69 vat_main_t * vam = va_arg (*args, vat_main_t *);
70 u32 * result = va_arg (*args, u32 *);
74 if (!unformat (input, "%s", &if_name))
77 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
84 /* Parse an IP4 address %d.%d.%d.%d. */
85 uword unformat_ip4_address (unformat_input_t * input, va_list * args)
87 u8 * result = va_arg (*args, u8 *);
90 if (! unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
93 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
106 unformat_ethernet_address (unformat_input_t * input, va_list * args)
108 u8 * result = va_arg (*args, u8 *);
111 if (! unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
112 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
116 for (i = 0; i < 6; i++)
117 if (a[i] >= (1 << 8))
120 for (i = 0; i < 6; i++)
126 /* Returns ethernet type as an int in host byte order. */
128 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
131 u16 * result = va_arg (*args, u16 *);
135 if (unformat (input, "0x%x", &type)
136 || unformat (input, "%d", &type))
138 if (type >= (1 << 16))
146 /* Parse an IP6 address. */
147 uword unformat_ip6_address (unformat_input_t * input, va_list * args)
149 ip6_address_t * result = va_arg (*args, ip6_address_t *);
151 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
152 uword c, n_colon, double_colon_index;
154 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
155 double_colon_index = ARRAY_LEN (hex_quads);
156 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
159 if (c >= '0' && c <= '9')
161 else if (c >= 'a' && c <= 'f')
162 hex_digit = c + 10 - 'a';
163 else if (c >= 'A' && c <= 'F')
164 hex_digit = c + 10 - 'A';
165 else if (c == ':' && n_colon < 2)
169 unformat_put_input (input);
173 /* Too many hex quads. */
174 if (n_hex_quads >= ARRAY_LEN (hex_quads))
179 hex_quad = (hex_quad << 4) | hex_digit;
181 /* Hex quad must fit in 16 bits. */
182 if (n_hex_digits >= 4)
189 /* Save position of :: */
192 /* More than one :: ? */
193 if (double_colon_index < ARRAY_LEN (hex_quads))
195 double_colon_index = n_hex_quads;
198 if (n_colon > 0 && n_hex_digits > 0)
200 hex_quads[n_hex_quads++] = hex_quad;
206 if (n_hex_digits > 0)
207 hex_quads[n_hex_quads++] = hex_quad;
212 /* Expand :: to appropriate number of zero hex quads. */
213 if (double_colon_index < ARRAY_LEN (hex_quads))
215 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
217 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
218 hex_quads[n_zero + i] = hex_quads[i];
220 for (i = 0; i < n_zero; i++)
221 hex_quads[double_colon_index + i] = 0;
223 n_hex_quads = ARRAY_LEN (hex_quads);
226 /* Too few hex quads given. */
227 if (n_hex_quads < ARRAY_LEN (hex_quads))
230 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
231 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
238 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
241 u32 * r = va_arg (*args, u32 *);
244 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
245 foreach_ipsec_policy_action
256 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
259 u32 * r = va_arg (*args, u32 *);
262 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
263 foreach_ipsec_crypto_alg
274 format_ipsec_crypto_alg (u8 * s, va_list * args)
277 u32 i = va_arg (*args, u32);
282 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
283 foreach_ipsec_crypto_alg
286 return format (s, "unknown");
288 return format (s, "%s", t);
290 return format (s, "Unimplemented");
295 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
298 u32 * r = va_arg (*args, u32 *);
301 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
302 foreach_ipsec_integ_alg
313 format_ipsec_integ_alg (u8 * s, va_list * args)
316 u32 i = va_arg (*args, u32);
321 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
322 foreach_ipsec_integ_alg
325 return format (s, "unknown");
327 return format (s, "%s", t);
329 return format (s, "Unsupported");
334 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
337 u32 * r = va_arg (*args, u32 *);
340 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
341 foreach_ikev2_auth_method
352 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
355 u32 * r = va_arg (*args, u32 *);
358 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
359 foreach_ikev2_id_type
370 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
372 u8 * r = va_arg (*args, u8 *);
374 if (unformat (input, "kbps"))
375 *r = SSE2_QOS_RATE_KBPS;
376 else if (unformat(input, "pps"))
377 *r = SSE2_QOS_RATE_PPS;
384 unformat_policer_round_type (unformat_input_t * input, va_list * args)
386 u8 * r = va_arg (*args, u8 *);
388 if (unformat(input, "closest"))
389 *r = SSE2_QOS_ROUND_TO_CLOSEST;
390 else if (unformat (input, "up"))
391 *r = SSE2_QOS_ROUND_TO_UP;
392 else if (unformat (input, "down"))
393 *r = SSE2_QOS_ROUND_TO_DOWN;
400 unformat_policer_type (unformat_input_t * input, va_list * args)
402 u8 * r = va_arg (*args, u8 *);
404 if (unformat (input, "1r2c"))
405 *r = SSE2_QOS_POLICER_TYPE_1R2C;
406 else if (unformat (input, "1r3c"))
407 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
408 else if (unformat (input, "2r3c-2698"))
409 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
410 else if (unformat (input, "2r3c-4115"))
411 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
412 else if (unformat (input, "2r3c-mef5cf1"))
413 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
419 u8 * format_ip4_address (u8 * s, va_list * args)
421 u8 * a = va_arg (*args, u8 *);
422 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
425 u8 * format_ip6_address (u8 * s, va_list * args)
427 ip6_address_t * a = va_arg (*args, ip6_address_t *);
428 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
430 i_max_n_zero = ARRAY_LEN (a->as_u16);
432 i_first_zero = i_max_n_zero;
434 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
436 u32 is_zero = a->as_u16[i] == 0;
437 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
443 if ((! is_zero && n_zeros > max_n_zeros)
444 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
446 i_max_n_zero = i_first_zero;
447 max_n_zeros = n_zeros;
448 i_first_zero = ARRAY_LEN (a->as_u16);
453 last_double_colon = 0;
454 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
456 if (i == i_max_n_zero && max_n_zeros > 1)
458 s = format (s, "::");
459 i += max_n_zeros - 1;
460 last_double_colon = 1;
464 s = format (s, "%s%x",
465 (last_double_colon || i == 0) ? "" : ":",
466 clib_net_to_host_u16 (a->as_u16[i]));
467 last_double_colon = 0;
474 /* Format an IP46 address. */
475 u8 * format_ip46_address (u8 * s, va_list * args)
477 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
478 ip46_type_t type = va_arg (*args, ip46_type_t);
484 is_ip4 = ip46_address_is_ip4(ip46);
495 format(s, "%U", format_ip4_address, &ip46->ip4):
496 format(s, "%U", format_ip6_address, &ip46->ip6);
499 u8 * format_ethernet_address (u8 * s, va_list * args)
501 u8 * a = va_arg (*args, u8 *);
503 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
504 a[0], a[1], a[2], a[3], a[4], a[5]);
507 void increment_v4_address (ip4_address_t * a)
511 v = ntohl(a->as_u32) + 1;
512 a->as_u32 = ntohl(v);
515 void increment_v6_address (ip6_address_t * a)
519 v0 = clib_net_to_host_u64 (a->as_u64[0]);
520 v1 = clib_net_to_host_u64 (a->as_u64[1]);
525 a->as_u64[0] = clib_net_to_host_u64 (v0);
526 a->as_u64[1] = clib_net_to_host_u64 (v1);
530 static void vl_api_create_loopback_reply_t_handler
531 (vl_api_create_loopback_reply_t * mp)
533 vat_main_t * vam = &vat_main;
534 i32 retval = ntohl(mp->retval);
536 vam->retval = retval;
537 vam->regenerate_interface_table = 1;
538 vam->sw_if_index = ntohl (mp->sw_if_index);
539 vam->result_ready = 1;
542 static void vl_api_create_loopback_reply_t_handler_json
543 (vl_api_create_loopback_reply_t * mp)
545 vat_main_t * vam = &vat_main;
546 vat_json_node_t node;
548 vat_json_init_object(&node);
549 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
550 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
552 vat_json_print(vam->ofp, &node);
553 vat_json_free(&node);
554 vam->retval = ntohl(mp->retval);
555 vam->result_ready = 1;
558 static void vl_api_af_packet_create_reply_t_handler
559 (vl_api_af_packet_create_reply_t * mp)
561 vat_main_t * vam = &vat_main;
562 i32 retval = ntohl(mp->retval);
564 vam->retval = retval;
565 vam->regenerate_interface_table = 1;
566 vam->sw_if_index = ntohl (mp->sw_if_index);
567 vam->result_ready = 1;
570 static void vl_api_af_packet_create_reply_t_handler_json
571 (vl_api_af_packet_create_reply_t * mp)
573 vat_main_t * vam = &vat_main;
574 vat_json_node_t node;
576 vat_json_init_object(&node);
577 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
578 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
580 vat_json_print(vam->ofp, &node);
581 vat_json_free(&node);
583 vam->retval = ntohl(mp->retval);
584 vam->result_ready = 1;
587 static void vl_api_create_vlan_subif_reply_t_handler
588 (vl_api_create_vlan_subif_reply_t * mp)
590 vat_main_t * vam = &vat_main;
591 i32 retval = ntohl(mp->retval);
593 vam->retval = retval;
594 vam->regenerate_interface_table = 1;
595 vam->sw_if_index = ntohl (mp->sw_if_index);
596 vam->result_ready = 1;
599 static void vl_api_create_vlan_subif_reply_t_handler_json
600 (vl_api_create_vlan_subif_reply_t * mp)
602 vat_main_t * vam = &vat_main;
603 vat_json_node_t node;
605 vat_json_init_object(&node);
606 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
607 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
609 vat_json_print(vam->ofp, &node);
610 vat_json_free(&node);
612 vam->retval = ntohl(mp->retval);
613 vam->result_ready = 1;
616 static void vl_api_create_subif_reply_t_handler
617 (vl_api_create_subif_reply_t * mp)
619 vat_main_t * vam = &vat_main;
620 i32 retval = ntohl(mp->retval);
622 vam->retval = retval;
623 vam->regenerate_interface_table = 1;
624 vam->sw_if_index = ntohl (mp->sw_if_index);
625 vam->result_ready = 1;
628 static void vl_api_create_subif_reply_t_handler_json
629 (vl_api_create_subif_reply_t * mp)
631 vat_main_t * vam = &vat_main;
632 vat_json_node_t node;
634 vat_json_init_object(&node);
635 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
636 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
638 vat_json_print(vam->ofp, &node);
639 vat_json_free(&node);
641 vam->retval = ntohl(mp->retval);
642 vam->result_ready = 1;
645 static void vl_api_interface_name_renumber_reply_t_handler
646 (vl_api_interface_name_renumber_reply_t * mp)
648 vat_main_t * vam = &vat_main;
649 i32 retval = ntohl(mp->retval);
651 vam->retval = retval;
652 vam->regenerate_interface_table = 1;
653 vam->result_ready = 1;
656 static void vl_api_interface_name_renumber_reply_t_handler_json
657 (vl_api_interface_name_renumber_reply_t * mp)
659 vat_main_t * vam = &vat_main;
660 vat_json_node_t node;
662 vat_json_init_object(&node);
663 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
665 vat_json_print(vam->ofp, &node);
666 vat_json_free(&node);
668 vam->retval = ntohl(mp->retval);
669 vam->result_ready = 1;
673 * Special-case: build the interface table, maintain
674 * the next loopback sw_if_index vbl.
676 static void vl_api_sw_interface_details_t_handler
677 (vl_api_sw_interface_details_t * mp)
679 vat_main_t * vam = &vat_main;
680 u8 * s = format (0, "%s%c", mp->interface_name, 0);
682 hash_set_mem (vam->sw_if_index_by_interface_name, s,
683 ntohl(mp->sw_if_index));
685 /* In sub interface case, fill the sub interface table entry */
686 if (mp->sw_if_index != mp->sup_sw_if_index) {
687 sw_interface_subif_t * sub = NULL;
689 vec_add2(vam->sw_if_subif_table, sub, 1);
691 vec_validate(sub->interface_name, strlen((char *)s) + 1);
692 strncpy((char *)sub->interface_name, (char *)s,
693 vec_len(sub->interface_name));
694 sub->sw_if_index = ntohl(mp->sw_if_index);
695 sub->sub_id = ntohl(mp->sub_id);
697 sub->sub_dot1ad = mp->sub_dot1ad;
698 sub->sub_number_of_tags = mp->sub_number_of_tags;
699 sub->sub_outer_vlan_id = ntohs(mp->sub_outer_vlan_id);
700 sub->sub_inner_vlan_id = ntohs(mp->sub_inner_vlan_id);
701 sub->sub_exact_match = mp->sub_exact_match;
702 sub->sub_default = mp->sub_default;
703 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
704 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
706 /* vlan tag rewrite */
707 sub->vtr_op = ntohl(mp->vtr_op);
708 sub->vtr_push_dot1q = ntohl(mp->vtr_push_dot1q);
709 sub->vtr_tag1 = ntohl(mp->vtr_tag1);
710 sub->vtr_tag2 = ntohl(mp->vtr_tag2);
714 static void vl_api_sw_interface_details_t_handler_json
715 (vl_api_sw_interface_details_t * mp)
717 vat_main_t * vam = &vat_main;
718 vat_json_node_t *node = NULL;
720 if (VAT_JSON_ARRAY != vam->json_tree.type) {
721 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
722 vat_json_init_array(&vam->json_tree);
724 node = vat_json_array_add(&vam->json_tree);
726 vat_json_init_object(node);
727 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
728 vat_json_object_add_uint(node, "sup_sw_if_index", ntohl(mp->sup_sw_if_index));
729 vat_json_object_add_uint(node, "l2_address_length", ntohl(mp->l2_address_length));
730 vat_json_object_add_bytes(node, "l2_address", mp->l2_address, sizeof(mp->l2_address));
731 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
732 vat_json_object_add_uint(node, "admin_up_down", mp->admin_up_down);
733 vat_json_object_add_uint(node, "link_up_down", mp->link_up_down);
734 vat_json_object_add_uint(node, "link_duplex", mp->link_duplex);
735 vat_json_object_add_uint(node, "link_speed", mp->link_speed);
736 vat_json_object_add_uint(node, "mtu", ntohs(mp->link_mtu));
737 vat_json_object_add_uint(node, "sub_id", ntohl(mp->sub_id));
738 vat_json_object_add_uint(node, "sub_dot1ad", mp->sub_dot1ad);
739 vat_json_object_add_uint(node, "sub_number_of_tags", mp->sub_number_of_tags);
740 vat_json_object_add_uint(node, "sub_outer_vlan_id", ntohs(mp->sub_outer_vlan_id));
741 vat_json_object_add_uint(node, "sub_inner_vlan_id", ntohs(mp->sub_inner_vlan_id));
742 vat_json_object_add_uint(node, "sub_exact_match", mp->sub_exact_match);
743 vat_json_object_add_uint(node, "sub_default", mp->sub_default);
744 vat_json_object_add_uint(node, "sub_outer_vlan_id_any", mp->sub_outer_vlan_id_any);
745 vat_json_object_add_uint(node, "sub_inner_vlan_id_any", mp->sub_inner_vlan_id_any);
746 vat_json_object_add_uint(node, "vtr_op", ntohl(mp->vtr_op));
747 vat_json_object_add_uint(node, "vtr_push_dot1q", ntohl(mp->vtr_push_dot1q));
748 vat_json_object_add_uint(node, "vtr_tag1", ntohl(mp->vtr_tag1));
749 vat_json_object_add_uint(node, "vtr_tag2", ntohl(mp->vtr_tag2));
752 static void vl_api_sw_interface_set_flags_t_handler
753 (vl_api_sw_interface_set_flags_t * mp)
755 vat_main_t * vam = &vat_main;
756 if (vam->interface_event_display)
757 errmsg ("interface flags: sw_if_index %d %s %s\n",
758 ntohl(mp->sw_if_index),
759 mp->admin_up_down ? "admin-up" : "admin-down",
760 mp->link_up_down ? "link-up" : "link-down");
763 static void vl_api_sw_interface_set_flags_t_handler_json
764 (vl_api_sw_interface_set_flags_t * mp)
766 /* JSON output not supported */
769 static void vl_api_cli_reply_t_handler
770 (vl_api_cli_reply_t * mp)
772 vat_main_t * vam = &vat_main;
773 i32 retval = ntohl(mp->retval);
775 vam->retval = retval;
776 vam->shmem_result = (u8 *) mp->reply_in_shmem;
777 vam->result_ready = 1;
780 static void vl_api_cli_reply_t_handler_json
781 (vl_api_cli_reply_t * mp)
783 vat_main_t * vam = &vat_main;
784 vat_json_node_t node;
785 api_main_t * am = &api_main;
789 vat_json_init_object(&node);
790 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
791 vat_json_object_add_uint(&node, "reply_in_shmem",
792 ntohl(mp->reply_in_shmem));
793 /* Toss the shared-memory original... */
794 pthread_mutex_lock (&am->vlib_rp->mutex);
795 oldheap = svm_push_data_heap (am->vlib_rp);
797 reply = (u8 *)(mp->reply_in_shmem);
800 svm_pop_heap (oldheap);
801 pthread_mutex_unlock (&am->vlib_rp->mutex);
803 vat_json_print(vam->ofp, &node);
804 vat_json_free(&node);
806 vam->retval = ntohl(mp->retval);
807 vam->result_ready = 1;
810 static void vl_api_classify_add_del_table_reply_t_handler
811 (vl_api_classify_add_del_table_reply_t * mp)
813 vat_main_t * vam = &vat_main;
814 i32 retval = ntohl(mp->retval);
815 if (vam->async_mode) {
816 vam->async_errors += (retval < 0);
818 vam->retval = retval;
820 ((mp->new_table_index != 0xFFFFFFFF) ||
821 (mp->skip_n_vectors != 0xFFFFFFFF) ||
822 (mp->match_n_vectors != 0xFFFFFFFF)))
824 * Note: this is just barely thread-safe, depends on
825 * the main thread spinning waiting for an answer...
827 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
828 ntohl(mp->new_table_index),
829 ntohl(mp->skip_n_vectors), ntohl(mp->match_n_vectors));
830 vam->result_ready = 1;
834 static void vl_api_classify_add_del_table_reply_t_handler_json
835 (vl_api_classify_add_del_table_reply_t * mp)
837 vat_main_t * vam = &vat_main;
838 vat_json_node_t node;
840 vat_json_init_object(&node);
841 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
842 vat_json_object_add_uint(&node, "new_table_index", ntohl(mp->new_table_index));
843 vat_json_object_add_uint(&node, "skip_n_vectors", ntohl(mp->skip_n_vectors));
844 vat_json_object_add_uint(&node, "match_n_vectors", ntohl(mp->match_n_vectors));
846 vat_json_print(vam->ofp, &node);
847 vat_json_free(&node);
849 vam->retval = ntohl(mp->retval);
850 vam->result_ready = 1;
853 static void vl_api_get_node_index_reply_t_handler
854 (vl_api_get_node_index_reply_t * mp)
856 vat_main_t * vam = &vat_main;
857 i32 retval = ntohl(mp->retval);
858 if (vam->async_mode) {
859 vam->async_errors += (retval < 0);
861 vam->retval = retval;
863 errmsg ("node index %d\n", ntohl(mp->node_index));
864 vam->result_ready = 1;
868 static void vl_api_get_node_index_reply_t_handler_json
869 (vl_api_get_node_index_reply_t * mp)
871 vat_main_t * vam = &vat_main;
872 vat_json_node_t node;
874 vat_json_init_object(&node);
875 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
876 vat_json_object_add_uint(&node, "node_index", ntohl(mp->node_index));
878 vat_json_print(vam->ofp, &node);
879 vat_json_free(&node);
881 vam->retval = ntohl(mp->retval);
882 vam->result_ready = 1;
885 static void vl_api_add_node_next_reply_t_handler
886 (vl_api_add_node_next_reply_t * mp)
888 vat_main_t * vam = &vat_main;
889 i32 retval = ntohl(mp->retval);
890 if (vam->async_mode) {
891 vam->async_errors += (retval < 0);
893 vam->retval = retval;
895 errmsg ("next index %d\n", ntohl(mp->next_index));
896 vam->result_ready = 1;
900 static void vl_api_add_node_next_reply_t_handler_json
901 (vl_api_add_node_next_reply_t * mp)
903 vat_main_t * vam = &vat_main;
904 vat_json_node_t node;
906 vat_json_init_object(&node);
907 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
908 vat_json_object_add_uint(&node, "next_index", ntohl(mp->next_index));
910 vat_json_print(vam->ofp, &node);
911 vat_json_free(&node);
913 vam->retval = ntohl(mp->retval);
914 vam->result_ready = 1;
917 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
918 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
920 vat_main_t * vam = &vat_main;
921 i32 retval = ntohl(mp->retval);
922 u32 sw_if_index = ntohl(mp->tunnel_sw_if_index);
924 if (retval >= 0 && sw_if_index != (u32)~0) {
925 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
927 vam->retval = retval;
928 vam->result_ready = 1;
931 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
932 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
934 vat_main_t * vam = &vat_main;
935 vat_json_node_t node;
937 vat_json_init_object(&node);
938 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
939 vat_json_object_add_uint(&node, "tunnel_sw_if_index", ntohl(mp->tunnel_sw_if_index));
941 vat_json_print(vam->ofp, &node);
942 vat_json_free(&node);
944 vam->retval = ntohl(mp->retval);
945 vam->result_ready = 1;
949 static void vl_api_show_version_reply_t_handler
950 (vl_api_show_version_reply_t * mp)
952 vat_main_t * vam = &vat_main;
953 i32 retval = ntohl(mp->retval);
956 errmsg (" program: %s\n", mp->program);
957 errmsg (" version: %s\n", mp->version);
958 errmsg (" build date: %s\n", mp->build_date);
959 errmsg ("build directory: %s\n", mp->build_directory);
961 vam->retval = retval;
962 vam->result_ready = 1;
965 static void vl_api_show_version_reply_t_handler_json
966 (vl_api_show_version_reply_t * mp)
968 vat_main_t * vam = &vat_main;
969 vat_json_node_t node;
971 vat_json_init_object(&node);
972 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
973 vat_json_object_add_string_copy(&node, "program", mp->program);
974 vat_json_object_add_string_copy(&node, "version", mp->version);
975 vat_json_object_add_string_copy(&node, "build_date", mp->build_date);
976 vat_json_object_add_string_copy(&node, "build_directory", mp->build_directory);
978 vat_json_print(vam->ofp, &node);
979 vat_json_free(&node);
981 vam->retval = ntohl(mp->retval);
982 vam->result_ready = 1;
985 static void vl_api_ip4_arp_event_t_handler
986 (vl_api_ip4_arp_event_t * mp)
988 vat_main_t * vam = &vat_main;
989 errmsg ("arp event: address %U new mac %U sw_if_index %d\n",
990 format_ip4_address, &mp->address,
991 format_ethernet_address, mp->new_mac, mp->sw_if_index);
994 static void vl_api_ip4_arp_event_t_handler_json
995 (vl_api_ip4_arp_event_t * mp)
997 /* JSON output not supported */
1001 * Special-case: build the bridge domain table, maintain
1002 * the next bd id vbl.
1004 static void vl_api_bridge_domain_details_t_handler
1005 (vl_api_bridge_domain_details_t * mp)
1007 vat_main_t * vam = &vat_main;
1008 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
1010 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
1011 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
1013 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
1014 ntohl (mp->bd_id), mp->learn, mp->forward,
1015 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
1018 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
1022 static void vl_api_bridge_domain_details_t_handler_json
1023 (vl_api_bridge_domain_details_t * mp)
1025 vat_main_t * vam = &vat_main;
1026 vat_json_node_t *node, *array = NULL;
1028 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1029 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1030 vat_json_init_array(&vam->json_tree);
1032 node = vat_json_array_add(&vam->json_tree);
1034 vat_json_init_object(node);
1035 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
1036 vat_json_object_add_uint(node, "flood", mp->flood);
1037 vat_json_object_add_uint(node, "forward", mp->forward);
1038 vat_json_object_add_uint(node, "learn", mp->learn);
1039 vat_json_object_add_uint(node, "bvi_sw_if_index", ntohl(mp->bvi_sw_if_index));
1040 vat_json_object_add_uint(node, "n_sw_ifs", ntohl(mp->n_sw_ifs));
1041 array = vat_json_object_add(node, "sw_if");
1042 vat_json_init_array(array);
1046 * Special-case: build the bridge domain sw if table.
1048 static void vl_api_bridge_domain_sw_if_details_t_handler
1049 (vl_api_bridge_domain_sw_if_details_t * mp)
1051 vat_main_t * vam = &vat_main;
1053 u8 * sw_if_name = 0;
1056 sw_if_index = ntohl (mp->sw_if_index);
1057 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1059 if ((u32) p->value[0] == sw_if_index) {
1060 sw_if_name = (u8 *)(p->key);
1065 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1066 mp->shg, sw_if_name ? (char *)sw_if_name :
1067 "sw_if_index not found!");
1070 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1071 (vl_api_bridge_domain_sw_if_details_t * mp)
1073 vat_main_t * vam = &vat_main;
1074 vat_json_node_t *node = NULL;
1075 uword last_index = 0;
1077 ASSERT(VAT_JSON_ARRAY == vam->json_tree.type);
1078 ASSERT(vec_len(vam->json_tree.array) >= 1);
1079 last_index = vec_len(vam->json_tree.array) - 1;
1080 node = &vam->json_tree.array[last_index];
1081 node = vat_json_object_get_element(node, "sw_if");
1082 ASSERT(NULL != node);
1083 node = vat_json_array_add(node);
1085 vat_json_init_object(node);
1086 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
1087 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
1088 vat_json_object_add_uint(node, "shg", mp->shg);
1091 static void vl_api_control_ping_reply_t_handler
1092 (vl_api_control_ping_reply_t * mp)
1094 vat_main_t * vam = &vat_main;
1095 i32 retval = ntohl(mp->retval);
1096 if (vam->async_mode) {
1097 vam->async_errors += (retval < 0);
1099 vam->retval = retval;
1100 vam->result_ready = 1;
1104 static void vl_api_control_ping_reply_t_handler_json
1105 (vl_api_control_ping_reply_t * mp)
1107 vat_main_t * vam = &vat_main;
1108 i32 retval = ntohl(mp->retval);
1110 if (VAT_JSON_NONE != vam->json_tree.type) {
1111 vat_json_print(vam->ofp, &vam->json_tree);
1112 vat_json_free(&vam->json_tree);
1113 vam->json_tree.type = VAT_JSON_NONE;
1116 vat_json_init_array(&vam->json_tree);
1117 vat_json_print(vam->ofp, &vam->json_tree);
1118 vam->json_tree.type = VAT_JSON_NONE;
1121 vam->retval = retval;
1122 vam->result_ready = 1;
1125 static void vl_api_l2_flags_reply_t_handler
1126 (vl_api_l2_flags_reply_t * mp)
1128 vat_main_t * vam = &vat_main;
1129 i32 retval = ntohl(mp->retval);
1130 if (vam->async_mode) {
1131 vam->async_errors += (retval < 0);
1133 vam->retval = retval;
1134 vam->result_ready = 1;
1138 static void vl_api_l2_flags_reply_t_handler_json
1139 (vl_api_l2_flags_reply_t * mp)
1141 vat_main_t * vam = &vat_main;
1142 vat_json_node_t node;
1144 vat_json_init_object(&node);
1145 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1146 vat_json_object_add_uint(&node, "resulting_feature_bitmap", ntohl(mp->resulting_feature_bitmap));
1148 vat_json_print(vam->ofp, &node);
1149 vat_json_free(&node);
1151 vam->retval = ntohl(mp->retval);
1152 vam->result_ready = 1;
1155 static void vl_api_bridge_flags_reply_t_handler
1156 (vl_api_bridge_flags_reply_t * mp)
1158 vat_main_t * vam = &vat_main;
1159 i32 retval = ntohl(mp->retval);
1160 if (vam->async_mode) {
1161 vam->async_errors += (retval < 0);
1163 vam->retval = retval;
1164 vam->result_ready = 1;
1168 static void vl_api_bridge_flags_reply_t_handler_json
1169 (vl_api_bridge_flags_reply_t * mp)
1171 vat_main_t * vam = &vat_main;
1172 vat_json_node_t node;
1174 vat_json_init_object(&node);
1175 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1176 vat_json_object_add_uint(&node, "resulting_feature_bitmap", ntohl(mp->resulting_feature_bitmap));
1178 vat_json_print(vam->ofp, &node);
1179 vat_json_free(&node);
1181 vam->retval = ntohl(mp->retval);
1182 vam->result_ready = 1;
1185 static void vl_api_tap_connect_reply_t_handler
1186 (vl_api_tap_connect_reply_t * mp)
1188 vat_main_t * vam = &vat_main;
1189 i32 retval = ntohl(mp->retval);
1190 if (vam->async_mode) {
1191 vam->async_errors += (retval < 0);
1193 vam->retval = retval;
1194 vam->sw_if_index = ntohl (mp->sw_if_index);
1195 vam->result_ready = 1;
1200 static void vl_api_tap_connect_reply_t_handler_json
1201 (vl_api_tap_connect_reply_t * mp)
1203 vat_main_t * vam = &vat_main;
1204 vat_json_node_t node;
1206 vat_json_init_object(&node);
1207 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1208 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1210 vat_json_print(vam->ofp, &node);
1211 vat_json_free(&node);
1213 vam->retval = ntohl(mp->retval);
1214 vam->result_ready = 1;
1218 static void vl_api_tap_modify_reply_t_handler
1219 (vl_api_tap_modify_reply_t * mp)
1221 vat_main_t * vam = &vat_main;
1222 i32 retval = ntohl(mp->retval);
1223 if (vam->async_mode) {
1224 vam->async_errors += (retval < 0);
1226 vam->retval = retval;
1227 vam->sw_if_index = ntohl (mp->sw_if_index);
1228 vam->result_ready = 1;
1232 static void vl_api_tap_modify_reply_t_handler_json
1233 (vl_api_tap_modify_reply_t * mp)
1235 vat_main_t * vam = &vat_main;
1236 vat_json_node_t node;
1238 vat_json_init_object(&node);
1239 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1240 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1242 vat_json_print(vam->ofp, &node);
1243 vat_json_free(&node);
1245 vam->retval = ntohl(mp->retval);
1246 vam->result_ready = 1;
1249 static void vl_api_tap_delete_reply_t_handler
1250 (vl_api_tap_delete_reply_t * mp)
1252 vat_main_t * vam = &vat_main;
1253 i32 retval = ntohl(mp->retval);
1254 if (vam->async_mode) {
1255 vam->async_errors += (retval < 0);
1257 vam->retval = retval;
1258 vam->result_ready = 1;
1262 static void vl_api_tap_delete_reply_t_handler_json
1263 (vl_api_tap_delete_reply_t * mp)
1265 vat_main_t * vam = &vat_main;
1266 vat_json_node_t node;
1268 vat_json_init_object(&node);
1269 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1271 vat_json_print(vam->ofp, &node);
1272 vat_json_free(&node);
1274 vam->retval = ntohl(mp->retval);
1275 vam->result_ready = 1;
1278 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1279 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1281 vat_main_t * vam = &vat_main;
1282 i32 retval = ntohl(mp->retval);
1283 if (vam->async_mode) {
1284 vam->async_errors += (retval < 0);
1286 vam->retval = retval;
1287 vam->result_ready = 1;
1291 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1292 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1294 vat_main_t * vam = &vat_main;
1295 vat_json_node_t node;
1297 vat_json_init_object(&node);
1298 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1299 vat_json_object_add_uint(&node, "tunnel_sw_if_index", ntohl(mp->tunnel_sw_if_index));
1301 vat_json_print(vam->ofp, &node);
1302 vat_json_free(&node);
1304 vam->retval = ntohl(mp->retval);
1305 vam->result_ready = 1;
1308 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1309 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1311 vat_main_t * vam = &vat_main;
1312 i32 retval = ntohl(mp->retval);
1313 if (vam->async_mode) {
1314 vam->async_errors += (retval < 0);
1316 vam->retval = retval;
1317 vam->sw_if_index = ntohl (mp->sw_if_index);
1318 vam->result_ready = 1;
1322 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1323 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1325 vat_main_t * vam = &vat_main;
1326 vat_json_node_t node;
1328 vat_json_init_object(&node);
1329 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1330 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1332 vat_json_print(vam->ofp, &node);
1333 vat_json_free(&node);
1335 vam->retval = ntohl(mp->retval);
1336 vam->result_ready = 1;
1339 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1340 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1342 vat_main_t * vam = &vat_main;
1343 i32 retval = ntohl(mp->retval);
1344 if (vam->async_mode) {
1345 vam->async_errors += (retval < 0);
1347 vam->retval = retval;
1348 vam->sw_if_index = ntohl (mp->sw_if_index);
1349 vam->result_ready = 1;
1353 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1354 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1356 vat_main_t * vam = &vat_main;
1357 vat_json_node_t node;
1359 vat_json_init_object(&node);
1360 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1361 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1363 vat_json_print(vam->ofp, &node);
1364 vat_json_free(&node);
1366 vam->retval = ntohl(mp->retval);
1367 vam->result_ready = 1;
1370 static void vl_api_gre_add_del_tunnel_reply_t_handler
1371 (vl_api_gre_add_del_tunnel_reply_t * mp)
1373 vat_main_t * vam = &vat_main;
1374 i32 retval = ntohl(mp->retval);
1375 if (vam->async_mode) {
1376 vam->async_errors += (retval < 0);
1378 vam->retval = retval;
1379 vam->sw_if_index = ntohl (mp->sw_if_index);
1380 vam->result_ready = 1;
1384 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1385 (vl_api_gre_add_del_tunnel_reply_t * mp)
1387 vat_main_t * vam = &vat_main;
1388 vat_json_node_t node;
1390 vat_json_init_object(&node);
1391 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1392 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1394 vat_json_print(vam->ofp, &node);
1395 vat_json_free(&node);
1397 vam->retval = ntohl(mp->retval);
1398 vam->result_ready = 1;
1401 static void vl_api_create_vhost_user_if_reply_t_handler
1402 (vl_api_create_vhost_user_if_reply_t * mp)
1404 vat_main_t * vam = &vat_main;
1405 i32 retval = ntohl(mp->retval);
1406 if (vam->async_mode) {
1407 vam->async_errors += (retval < 0);
1409 vam->retval = retval;
1410 vam->sw_if_index = ntohl (mp->sw_if_index);
1411 vam->result_ready = 1;
1415 static void vl_api_create_vhost_user_if_reply_t_handler_json
1416 (vl_api_create_vhost_user_if_reply_t * mp)
1418 vat_main_t * vam = &vat_main;
1419 vat_json_node_t node;
1421 vat_json_init_object(&node);
1422 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1423 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1425 vat_json_print(vam->ofp, &node);
1426 vat_json_free(&node);
1428 vam->retval = ntohl(mp->retval);
1429 vam->result_ready = 1;
1432 static void vl_api_ip_address_details_t_handler
1433 (vl_api_ip_address_details_t * mp)
1435 vat_main_t * vam = &vat_main;
1436 static ip_address_details_t empty_ip_address_details = {{0}};
1437 ip_address_details_t * address = NULL;
1438 ip_details_t * current_ip_details = NULL;
1439 ip_details_t * details = NULL;
1441 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1443 if (!details || vam->current_sw_if_index >= vec_len(details)
1444 || !details[vam->current_sw_if_index].present) {
1445 errmsg ("ip address details arrived but not stored\n");
1446 errmsg ("ip_dump should be called first\n");
1450 current_ip_details = vec_elt_at_index(details,
1451 vam->current_sw_if_index);
1453 #define addresses (current_ip_details->addr)
1455 vec_validate_init_empty(addresses, vec_len(addresses),
1456 empty_ip_address_details);
1458 address = vec_elt_at_index(addresses, vec_len(addresses) - 1);
1460 clib_memcpy(&address->ip, &mp->ip, sizeof(address->ip));
1461 address->prefix_length = mp->prefix_length;
1465 static void vl_api_ip_address_details_t_handler_json
1466 (vl_api_ip_address_details_t * mp)
1468 vat_main_t * vam = &vat_main;
1469 vat_json_node_t *node = NULL;
1470 struct in6_addr ip6;
1473 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1474 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1475 vat_json_init_array(&vam->json_tree);
1477 node = vat_json_array_add(&vam->json_tree);
1479 vat_json_init_object(node);
1481 clib_memcpy(&ip6, mp->ip, sizeof(ip6));
1482 vat_json_object_add_ip6(node, "ip", ip6);
1484 clib_memcpy(&ip4, mp->ip, sizeof(ip4));
1485 vat_json_object_add_ip4(node, "ip", ip4);
1487 vat_json_object_add_uint(node, "prefix_length", mp->prefix_length);
1490 static void vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1492 vat_main_t * vam = &vat_main;
1493 static ip_details_t empty_ip_details = {0};
1494 ip_details_t * ip = NULL;
1495 u32 sw_if_index = ~0;
1497 sw_if_index = ntohl(mp->sw_if_index);
1499 vec_validate_init_empty(vam->ip_details_by_sw_if_index[vam->is_ipv6],
1500 sw_if_index, empty_ip_details);
1502 ip = vec_elt_at_index(vam->ip_details_by_sw_if_index[vam->is_ipv6],
1508 static void vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1510 vat_main_t * vam = &vat_main;
1512 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1513 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1514 vat_json_init_array(&vam->json_tree);
1516 vat_json_array_add_uint(&vam->json_tree, clib_net_to_host_u32(mp->sw_if_index));
1519 static void vl_api_map_domain_details_t_handler_json
1520 (vl_api_map_domain_details_t * mp)
1522 vat_json_node_t * node = NULL;
1523 vat_main_t * vam = &vat_main;
1524 struct in6_addr ip6;
1527 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1528 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1529 vat_json_init_array(&vam->json_tree);
1532 node = vat_json_array_add(&vam->json_tree);
1533 vat_json_init_object(node);
1535 vat_json_object_add_uint(node, "domain_index", clib_net_to_host_u32(mp->domain_index));
1536 clib_memcpy(&ip6, mp->ip6_prefix, sizeof(ip6));
1537 vat_json_object_add_ip6(node, "ip6_prefix", ip6);
1538 clib_memcpy(&ip4, mp->ip4_prefix, sizeof(ip4));
1539 vat_json_object_add_ip4(node, "ip4_prefix", ip4);
1540 clib_memcpy(&ip6, mp->ip6_src, sizeof(ip6));
1541 vat_json_object_add_ip6(node, "ip6_src", ip6);
1542 vat_json_object_add_int(node, "ip6_prefix_len", mp->ip6_prefix_len);
1543 vat_json_object_add_int(node, "ip4_prefix_len", mp->ip4_prefix_len);
1544 vat_json_object_add_int(node, "ip6_src_len", mp->ip6_src_len);
1545 vat_json_object_add_int(node, "ea_bits_len", mp->ea_bits_len);
1546 vat_json_object_add_int(node, "psid_offset", mp->psid_offset);
1547 vat_json_object_add_int(node, "psid_length", mp->psid_length);
1548 vat_json_object_add_uint(node, "flags", mp->flags);
1549 vat_json_object_add_uint(node, "mtu", clib_net_to_host_u16(mp->mtu));
1550 vat_json_object_add_int(node, "is_translation", mp->is_translation);
1553 static void vl_api_map_domain_details_t_handler
1554 (vl_api_map_domain_details_t * mp)
1556 vat_main_t * vam = &vat_main;
1558 if (mp->is_translation) {
1559 fformat(vam->ofp, "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1560 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1561 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1562 format_ip6_address, mp->ip6_src, mp->ip6_src_len, clib_net_to_host_u32(mp->domain_index));
1564 fformat(vam->ofp, "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1565 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1566 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1567 format_ip6_address, mp->ip6_src, clib_net_to_host_u32(mp->domain_index));
1569 fformat(vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1570 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu, mp->is_translation? "map-t":"");
1573 static void vl_api_map_rule_details_t_handler_json
1574 (vl_api_map_rule_details_t * mp)
1576 struct in6_addr ip6;
1577 vat_json_node_t * node = NULL;
1578 vat_main_t * vam = &vat_main;
1580 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1581 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1582 vat_json_init_array(&vam->json_tree);
1585 node = vat_json_array_add(&vam->json_tree);
1586 vat_json_init_object(node);
1588 vat_json_object_add_uint(node, "psid", clib_net_to_host_u16(mp->psid));
1589 clib_memcpy(&ip6, mp->ip6_dst, sizeof(ip6));
1590 vat_json_object_add_ip6(node, "ip6_dst", ip6);
1593 static void vl_api_map_rule_details_t_handler
1594 (vl_api_map_rule_details_t * mp)
1596 vat_main_t * vam = &vat_main;
1597 fformat(vam->ofp, " %d (psid) %U (ip6-dst)\n", clib_net_to_host_u16(mp->psid),
1598 format_ip6_address, mp->ip6_dst);
1601 static void vl_api_dhcp_compl_event_t_handler
1602 (vl_api_dhcp_compl_event_t * mp)
1604 vat_main_t * vam = &vat_main;
1605 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1606 "router_addr %U host_mac %U\n",
1607 mp->pid, mp->is_ipv6 ? "ipv6":"ipv4", mp->hostname,
1608 format_ip4_address, &mp->host_address,
1609 format_ip4_address, &mp->router_address,
1610 format_ethernet_address, mp->host_mac);
1613 static void vl_api_dhcp_compl_event_t_handler_json
1614 (vl_api_dhcp_compl_event_t * mp)
1616 /* JSON output not supported */
1619 static void set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1622 vat_main_t * vam = &vat_main;
1623 static u64 default_counter = 0;
1625 vec_validate_init_empty(vam->simple_interface_counters, vnet_counter_type, NULL);
1626 vec_validate_init_empty(vam->simple_interface_counters[vnet_counter_type],
1627 sw_if_index, default_counter);
1628 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1631 static void set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1632 interface_counter_t counter)
1634 vat_main_t * vam = &vat_main;
1635 static interface_counter_t default_counter = {0, };
1637 vec_validate_init_empty(vam->combined_interface_counters, vnet_counter_type, NULL);
1638 vec_validate_init_empty(vam->combined_interface_counters[vnet_counter_type],
1639 sw_if_index, default_counter);
1640 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1643 static void vl_api_vnet_interface_counters_t_handler
1644 (vl_api_vnet_interface_counters_t *mp)
1649 static void vl_api_vnet_interface_counters_t_handler_json
1650 (vl_api_vnet_interface_counters_t *mp)
1652 interface_counter_t counter;
1657 u32 first_sw_if_index;
1660 count = ntohl(mp->count);
1661 first_sw_if_index = ntohl(mp->first_sw_if_index);
1663 if (!mp->is_combined) {
1664 v_packets = (u64*)&mp->data;
1665 for (i = 0; i < count; i++) {
1666 packets = clib_net_to_host_u64(clib_mem_unaligned(v_packets, u64));
1667 set_simple_interface_counter(mp->vnet_counter_type,
1668 first_sw_if_index + i, packets);
1672 v = (vlib_counter_t*)&mp->data;
1673 for (i = 0; i < count; i++) {
1674 counter.packets = clib_net_to_host_u64(
1675 clib_mem_unaligned(&v->packets, u64));
1676 counter.bytes = clib_net_to_host_u64(
1677 clib_mem_unaligned(&v->bytes, u64));
1678 set_combined_interface_counter(mp->vnet_counter_type,
1679 first_sw_if_index + i, counter);
1685 static u32 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1687 vat_main_t * vam = &vat_main;
1690 for (i = 0; i < vec_len(vam->ip4_fib_counters_vrf_id_by_index); i++) {
1691 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id) {
1698 static u32 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1700 vat_main_t * vam = &vat_main;
1703 for (i = 0; i < vec_len(vam->ip6_fib_counters_vrf_id_by_index); i++) {
1704 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id) {
1711 static void vl_api_vnet_ip4_fib_counters_t_handler
1712 (vl_api_vnet_ip4_fib_counters_t *mp)
1717 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1718 (vl_api_vnet_ip4_fib_counters_t *mp)
1720 vat_main_t * vam = &vat_main;
1721 vl_api_ip4_fib_counter_t *v;
1722 ip4_fib_counter_t *counter;
1729 vrf_id = ntohl(mp->vrf_id);
1730 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id(vrf_id);
1731 if (~0 == vrf_index) {
1732 vrf_index = vec_len(vam->ip4_fib_counters_vrf_id_by_index);
1733 vec_validate(vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
1734 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1735 vec_validate(vam->ip4_fib_counters, vrf_index);
1736 vam->ip4_fib_counters[vrf_index] = NULL;
1739 vec_free(vam->ip4_fib_counters[vrf_index]);
1740 v = (vl_api_ip4_fib_counter_t*)&mp->c;
1741 count = ntohl(mp->count);
1742 for (i = 0; i < count; i++) {
1743 vec_validate(vam->ip4_fib_counters[vrf_index], i);
1744 counter = &vam->ip4_fib_counters[vrf_index][i];
1745 clib_memcpy(&ip4, &v->address, sizeof(ip4));
1746 counter->address = ip4;
1747 counter->address_length = v->address_length;
1748 counter->packets = clib_net_to_host_u64(v->packets);
1749 counter->bytes = clib_net_to_host_u64(v->bytes);
1754 static void vl_api_vnet_ip6_fib_counters_t_handler
1755 (vl_api_vnet_ip6_fib_counters_t *mp)
1760 static void vl_api_vnet_ip6_fib_counters_t_handler_json
1761 (vl_api_vnet_ip6_fib_counters_t *mp)
1763 vat_main_t * vam = &vat_main;
1764 vl_api_ip6_fib_counter_t *v;
1765 ip6_fib_counter_t *counter;
1766 struct in6_addr ip6;
1772 vrf_id = ntohl(mp->vrf_id);
1773 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id(vrf_id);
1774 if (~0 == vrf_index) {
1775 vrf_index = vec_len(vam->ip6_fib_counters_vrf_id_by_index);
1776 vec_validate(vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
1777 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1778 vec_validate(vam->ip6_fib_counters, vrf_index);
1779 vam->ip6_fib_counters[vrf_index] = NULL;
1782 vec_free(vam->ip6_fib_counters[vrf_index]);
1783 v = (vl_api_ip6_fib_counter_t*)&mp->c;
1784 count = ntohl(mp->count);
1785 for (i = 0; i < count; i++) {
1786 vec_validate(vam->ip6_fib_counters[vrf_index], i);
1787 counter = &vam->ip6_fib_counters[vrf_index][i];
1788 clib_memcpy(&ip6, &v->address, sizeof(ip6));
1789 counter->address = ip6;
1790 counter->address_length = v->address_length;
1791 counter->packets = clib_net_to_host_u64(v->packets);
1792 counter->bytes = clib_net_to_host_u64(v->bytes);
1797 static void vl_api_get_first_msg_id_reply_t_handler
1798 (vl_api_get_first_msg_id_reply_t * mp)
1800 vat_main_t * vam = &vat_main;
1801 i32 retval = ntohl(mp->retval);
1803 if (vam->async_mode) {
1804 vam->async_errors += (retval < 0);
1806 vam->retval = retval;
1807 vam->result_ready = 1;
1810 errmsg ("first message id %d\n", ntohs(mp->first_msg_id));
1814 static void vl_api_get_first_msg_id_reply_t_handler_json
1815 (vl_api_get_first_msg_id_reply_t * mp)
1817 vat_main_t * vam = &vat_main;
1818 vat_json_node_t node;
1820 vat_json_init_object(&node);
1821 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1822 vat_json_object_add_uint(&node, "first_msg_id",
1823 (uint) ntohs(mp->first_msg_id));
1825 vat_json_print(vam->ofp, &node);
1826 vat_json_free(&node);
1828 vam->retval = ntohl(mp->retval);
1829 vam->result_ready = 1;
1832 static void vl_api_get_node_graph_reply_t_handler
1833 (vl_api_get_node_graph_reply_t * mp)
1835 vat_main_t * vam = &vat_main;
1836 api_main_t * am = &api_main;
1837 i32 retval = ntohl(mp->retval);
1838 u8 * pvt_copy, * reply;
1843 if (vam->async_mode) {
1844 vam->async_errors += (retval < 0);
1846 vam->retval = retval;
1847 vam->result_ready = 1;
1850 /* "Should never happen..." */
1854 reply = (u8 *)(mp->reply_in_shmem);
1855 pvt_copy = vec_dup (reply);
1857 /* Toss the shared-memory original... */
1858 pthread_mutex_lock (&am->vlib_rp->mutex);
1859 oldheap = svm_push_data_heap (am->vlib_rp);
1863 svm_pop_heap (oldheap);
1864 pthread_mutex_unlock (&am->vlib_rp->mutex);
1866 if (vam->graph_nodes) {
1867 hash_free (vam->graph_node_index_by_name);
1869 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
1870 node = vam->graph_nodes[i];
1871 vec_free (node->name);
1872 vec_free (node->next_nodes);
1875 vec_free(vam->graph_nodes);
1878 vam->graph_node_index_by_name = hash_create_string (0, sizeof(uword));
1879 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
1880 vec_free (pvt_copy);
1882 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
1883 node = vam->graph_nodes[i];
1884 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
1888 static void vl_api_get_node_graph_reply_t_handler_json
1889 (vl_api_get_node_graph_reply_t * mp)
1891 vat_main_t * vam = &vat_main;
1892 api_main_t * am = &api_main;
1894 vat_json_node_t node;
1897 /* $$$$ make this real? */
1898 vat_json_init_object(&node);
1899 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1900 vat_json_object_add_uint(&node, "reply_in_shmem", mp->reply_in_shmem);
1902 reply = (u8 *)(mp->reply_in_shmem);
1904 /* Toss the shared-memory original... */
1905 pthread_mutex_lock (&am->vlib_rp->mutex);
1906 oldheap = svm_push_data_heap (am->vlib_rp);
1910 svm_pop_heap (oldheap);
1911 pthread_mutex_unlock (&am->vlib_rp->mutex);
1913 vat_json_print(vam->ofp, &node);
1914 vat_json_free(&node);
1916 vam->retval = ntohl(mp->retval);
1917 vam->result_ready = 1;
1921 vl_api_lisp_locator_set_details_t_handler (
1922 vl_api_lisp_locator_set_details_t *mp)
1924 vat_main_t *vam = &vat_main;
1925 u8 * tmp_str = NULL;
1928 fformat(vam->ofp, "%=20s%=16d%=16d%=16d\n",
1929 mp->locator_set_name,
1930 ntohl(mp->sw_if_index),
1934 tmp_str = format(0,"%U/%d",
1935 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
1939 fformat(vam->ofp, "%=20s%=16s%=16d%=16d\n",
1940 mp->locator_set_name,
1949 vl_api_lisp_locator_set_details_t_handler_json (
1950 vl_api_lisp_locator_set_details_t *mp)
1952 vat_main_t *vam = &vat_main;
1953 vat_json_node_t *node = NULL;
1954 struct in6_addr ip6;
1957 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1958 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1959 vat_json_init_array(&vam->json_tree);
1961 node = vat_json_array_add(&vam->json_tree);
1963 vat_json_init_object(node);
1964 vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
1966 vat_json_object_add_uint(node, "locator", ntohl(mp->sw_if_index));
1969 clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
1970 vat_json_object_add_ip6(node, "locator", ip6);
1972 clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
1973 vat_json_object_add_ip4(node, "locator", ip4);
1975 vat_json_object_add_uint(node, "prefix-length", mp->prefix_len);
1977 vat_json_object_add_uint(node, "priority", mp->priority);
1978 vat_json_object_add_uint(node, "weight", mp->weight);
1982 vl_api_lisp_local_eid_table_details_t_handler (
1983 vl_api_lisp_local_eid_table_details_t *mp)
1985 vat_main_t *vam = &vat_main;
1987 u8 * (*format_eid)(u8 *, va_list *) = 0;
1989 switch (mp->eid_type)
1991 case 0: format_eid = format_ip4_address; break;
1992 case 1: format_eid = format_ip6_address; break;
1993 case 2: format_eid = format_ethernet_address; break;
1995 errmsg ("unknown EID type %d!", mp->eid_type);
1999 prefix = format(0, "[%d] %U/%d",
2000 clib_net_to_host_u32 (mp->vni),
2001 format_eid, mp->eid, mp->eid_prefix_len);
2003 fformat(vam->ofp, "%=20s%=30s\n",
2004 mp->locator_set_name, prefix);
2010 vl_api_lisp_local_eid_table_details_t_handler_json (
2011 vl_api_lisp_local_eid_table_details_t *mp)
2013 vat_main_t *vam = &vat_main;
2014 vat_json_node_t *node = NULL;
2015 struct in6_addr ip6;
2019 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2020 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2021 vat_json_init_array(&vam->json_tree);
2023 node = vat_json_array_add(&vam->json_tree);
2025 vat_json_init_object(node);
2026 vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
2027 switch (mp->eid_type)
2030 clib_memcpy(&ip4, mp->eid, sizeof(ip4));
2031 vat_json_object_add_ip4(node, "eid-address", ip4);
2034 clib_memcpy(&ip6, mp->eid, sizeof(ip6));
2035 vat_json_object_add_ip6(node, "eid-address", ip6);
2038 s = format (0, "%U", format_ethernet_address, mp->eid);
2040 vat_json_object_add_string_copy(node, "eid-address", s);
2044 errmsg ("unknown EID type %d!", mp->eid_type);
2047 vat_json_object_add_uint(node, "vni", clib_net_to_host_u32 (mp->vni));
2048 vat_json_object_add_uint(node, "eid-prefix-len", mp->eid_prefix_len);
2052 format_decap_next (u8 * s, va_list * args)
2054 u32 next_index = va_arg (*args, u32);
2058 case LISP_GPE_INPUT_NEXT_DROP:
2059 return format (s, "drop");
2060 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
2061 return format (s, "ip4");
2062 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
2063 return format (s, "ip6");
2065 return format (s, "unknown %d", next_index);
2071 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *mp)
2073 vat_main_t *vam = &vat_main;
2075 u8 *flag_str = NULL;
2077 iid_str = format(0, "%d (0x%x)", ntohl(mp->iid), ntohl(mp->iid));
2079 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
2080 foreach_lisp_gpe_flag_bit;
2083 fformat(vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2084 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2086 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2088 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2090 ntohl(mp->encap_fib_id),
2091 ntohl(mp->decap_fib_id),
2092 format_decap_next, ntohl(mp->dcap_next),
2104 vl_api_lisp_gpe_tunnel_details_t_handler_json (
2105 vl_api_lisp_gpe_tunnel_details_t *mp)
2107 vat_main_t *vam = &vat_main;
2108 vat_json_node_t *node = NULL;
2109 struct in6_addr ip6;
2113 next_decap_str = format(0, "%U", format_decap_next, htonl(mp->dcap_next));
2115 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2116 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2117 vat_json_init_array(&vam->json_tree);
2119 node = vat_json_array_add(&vam->json_tree);
2121 vat_json_init_object(node);
2122 vat_json_object_add_uint(node, "tunel", mp->tunnels);
2124 clib_memcpy(&ip6, mp->source_ip, sizeof(ip6));
2125 vat_json_object_add_ip6(node, "source address", ip6);
2126 clib_memcpy(&ip6, mp->destination_ip, sizeof(ip6));
2127 vat_json_object_add_ip6(node, "destination address", ip6);
2129 clib_memcpy(&ip4, mp->source_ip, sizeof(ip4));
2130 vat_json_object_add_ip4(node, "source address", ip4);
2131 clib_memcpy(&ip4, mp->destination_ip, sizeof(ip4));
2132 vat_json_object_add_ip4(node, "destination address", ip4);
2134 vat_json_object_add_uint(node, "fib encap", ntohl(mp->encap_fib_id));
2135 vat_json_object_add_uint(node, "fib decap", ntohl(mp->decap_fib_id));
2136 vat_json_object_add_string_copy(node, "decap next", next_decap_str);
2137 vat_json_object_add_uint(node, "lisp version", mp->ver_res >> 6);
2138 vat_json_object_add_uint(node, "flags", mp->flags);
2139 vat_json_object_add_uint(node, "next protocol", mp->next_protocol);
2140 vat_json_object_add_uint(node, "ver_res", mp->ver_res);
2141 vat_json_object_add_uint(node, "res", mp->res);
2142 vat_json_object_add_uint(node, "iid", ntohl(mp->iid));
2144 vec_free(next_decap_str);
2148 vl_api_lisp_map_resolver_details_t_handler (
2149 vl_api_lisp_map_resolver_details_t *mp)
2151 vat_main_t *vam = &vat_main;
2153 fformat(vam->ofp, "%=20U\n",
2154 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2159 vl_api_lisp_map_resolver_details_t_handler_json (
2160 vl_api_lisp_map_resolver_details_t *mp)
2162 vat_main_t *vam = &vat_main;
2163 vat_json_node_t *node = NULL;
2164 struct in6_addr ip6;
2167 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2168 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2169 vat_json_init_array(&vam->json_tree);
2171 node = vat_json_array_add(&vam->json_tree);
2173 vat_json_init_object(node);
2175 clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
2176 vat_json_object_add_ip6(node, "map resolver", ip6);
2178 clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
2179 vat_json_object_add_ip4(node, "map resolver", ip4);
2184 vl_api_lisp_enable_disable_status_details_t_handler
2185 (vl_api_lisp_enable_disable_status_details_t *mp)
2187 vat_main_t *vam = &vat_main;
2189 fformat(vam->ofp, "feature: %s\ngpe: %s\n",
2190 mp->feature_status ? "enabled" : "disabled",
2191 mp->gpe_status ? "enabled" : "disabled");
2195 vl_api_lisp_enable_disable_status_details_t_handler_json
2196 (vl_api_lisp_enable_disable_status_details_t *mp)
2198 vat_main_t *vam = &vat_main;
2199 vat_json_node_t *node = NULL;
2200 u8 * gpe_status = NULL;
2201 u8 * feature_status = NULL;
2203 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2204 feature_status = format (0, "%s",
2205 mp->feature_status ? "enabled" : "disabled");
2206 vec_add1 (gpe_status, 0);
2207 vec_add1 (feature_status, 0);
2209 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2210 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2211 vat_json_init_array(&vam->json_tree);
2213 node = vat_json_array_add(&vam->json_tree);
2215 vat_json_init_object(node);
2216 vat_json_object_add_string_copy(node, "gpe_status", gpe_status);
2217 vat_json_object_add_string_copy(node, "feature_status", feature_status);
2219 vec_free (gpe_status);
2220 vec_free (feature_status);
2224 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler (
2225 vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2227 vat_main_t * vam = &vat_main;
2228 i32 retval = ntohl(mp->retval);
2231 fformat(vam->ofp, "%=20s\n",
2232 mp->locator_set_name);
2235 vam->retval = retval;
2236 vam->result_ready = 1;
2240 vl_api_lisp_get_map_request_itr_rlocs_reply_t_handler_json (
2241 vl_api_lisp_get_map_request_itr_rlocs_reply_t * mp)
2243 vat_main_t * vam = &vat_main;
2244 vat_json_node_t * node = NULL;
2246 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2247 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2248 vat_json_init_array(&vam->json_tree);
2250 node = vat_json_array_add(&vam->json_tree);
2252 vat_json_init_object(node);
2253 vat_json_object_add_string_copy(node, "itr-rlocs", mp->locator_set_name);
2255 vat_json_print(vam->ofp, node);
2256 vat_json_free(node);
2258 vam->retval = ntohl(mp->retval);
2259 vam->result_ready = 1;
2262 static u8 * format_policer_type (u8 * s, va_list * va)
2264 u32 i = va_arg (*va, u32);
2266 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2267 s = format (s, "1r2c");
2268 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2269 s = format (s, "1r3c");
2270 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2271 s = format (s, "2r3c-2698");
2272 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2273 s = format (s, "2r3c-4115");
2274 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2275 s = format (s, "2r3c-mef5cf1");
2277 s = format (s, "ILLEGAL");
2281 static u8 * format_policer_rate_type (u8 * s, va_list * va)
2283 u32 i = va_arg (*va, u32);
2285 if (i == SSE2_QOS_RATE_KBPS)
2286 s = format (s, "kbps");
2287 else if (i == SSE2_QOS_RATE_PPS)
2288 s = format(s, "pps");
2290 s = format (s, "ILLEGAL");
2294 static u8 * format_policer_round_type (u8 * s, va_list * va)
2296 u32 i = va_arg (*va, u32);
2298 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2299 s = format(s, "closest");
2300 else if (i == SSE2_QOS_ROUND_TO_UP)
2301 s = format (s, "up");
2302 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2303 s = format (s, "down");
2305 s = format (s, "ILLEGAL");
2309 static void vl_api_policer_details_t_handler
2310 (vl_api_policer_details_t * mp)
2312 vat_main_t * vam = &vat_main;
2314 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2315 "rate type %U, round type %U, %s rate, %s color-aware, "
2316 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2317 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu\n",
2319 format_policer_type, mp->type,
2324 format_policer_rate_type, mp->rate_type,
2325 format_policer_round_type, mp->round_type,
2326 mp->single_rate ? "single" : "dual",
2327 mp->color_aware ? "is" : "not",
2328 ntohl(mp->cir_tokens_per_period),
2329 ntohl(mp->pir_tokens_per_period),
2331 ntohl(mp->current_limit),
2332 ntohl(mp->current_bucket),
2333 ntohl(mp->extended_limit),
2334 ntohl(mp->extended_bucket),
2335 clib_net_to_host_u64(mp->last_update_time));
2338 static void vl_api_policer_details_t_handler_json
2339 (vl_api_policer_details_t * mp)
2341 vat_main_t * vam = &vat_main;
2342 vat_json_node_t *node;
2343 u8 *rate_type_str, *round_type_str, *type_str;
2345 rate_type_str = format(0, "%U", format_policer_rate_type, mp->rate_type);
2346 round_type_str = format(0, "%U", format_policer_round_type, mp->round_type);
2347 type_str = format(0, "%U", format_policer_type, mp->type);
2349 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2350 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2351 vat_json_init_array(&vam->json_tree);
2353 node = vat_json_array_add(&vam->json_tree);
2355 vat_json_init_object(node);
2356 vat_json_object_add_string_copy(node, "name", mp->name);
2357 vat_json_object_add_uint(node, "cir", ntohl(mp->cir));
2358 vat_json_object_add_uint(node, "eir", ntohl(mp->eir));
2359 vat_json_object_add_uint(node, "cb", ntohl(mp->cb));
2360 vat_json_object_add_uint(node, "eb", ntohl(mp->eb));
2361 vat_json_object_add_string_copy(node, "rate_type", rate_type_str);
2362 vat_json_object_add_string_copy(node, "round_type", round_type_str);
2363 vat_json_object_add_string_copy(node, "type", type_str);
2364 vat_json_object_add_uint(node, "single_rate", mp->single_rate);
2365 vat_json_object_add_uint(node, "color_aware", mp->color_aware);
2366 vat_json_object_add_uint(node, "scale", ntohl(mp->scale));
2367 vat_json_object_add_uint(node, "cir_tokens_per_period",
2368 ntohl(mp->cir_tokens_per_period));
2369 vat_json_object_add_uint(node, "eir_tokens_per_period",
2370 ntohl(mp->pir_tokens_per_period));
2371 vat_json_object_add_uint(node, "current_limit", ntohl(mp->current_limit));
2372 vat_json_object_add_uint(node, "current_bucket", ntohl(mp->current_bucket));
2373 vat_json_object_add_uint(node, "extended_limit", ntohl(mp->extended_limit));
2374 vat_json_object_add_uint(node, "extended_bucket",
2375 ntohl(mp->extended_bucket));
2376 vat_json_object_add_uint(node, "last_update_time",
2377 ntohl(mp->last_update_time));
2379 vec_free(rate_type_str);
2380 vec_free(round_type_str);
2384 static void vl_api_classify_table_ids_reply_t_handler (vl_api_classify_table_ids_reply_t * mp)
2386 vat_main_t * vam = &vat_main;
2387 int i, count = ntohl(mp->count);
2390 fformat (vam->ofp, "classify table ids (%d) : ", count);
2391 for (i = 0; i < count; i++)
2393 fformat (vam->ofp, "%d", ntohl(mp->ids[i]));
2394 fformat (vam->ofp, (i<count-1)?",":"\n");
2396 vam->retval = ntohl(mp->retval);
2397 vam->result_ready = 1;
2400 static void vl_api_classify_table_ids_reply_t_handler_json (vl_api_classify_table_ids_reply_t * mp)
2402 vat_main_t * vam = &vat_main;
2403 int i, count = ntohl(mp->count);
2406 vat_json_node_t node;
2408 vat_json_init_object(&node);
2409 for (i = 0; i < count; i++)
2411 vat_json_object_add_uint(&node, "table_id", ntohl(mp->ids[i]));
2413 vat_json_print(vam->ofp, &node);
2414 vat_json_free(&node);
2416 vam->retval = ntohl(mp->retval);
2417 vam->result_ready = 1;
2420 static void vl_api_classify_table_by_interface_reply_t_handler (vl_api_classify_table_by_interface_reply_t * mp)
2422 vat_main_t * vam = &vat_main;
2425 table_id = ntohl(mp->l2_table_id);
2427 fformat (vam->ofp, "l2 table id : %d\n", table_id);
2429 fformat (vam->ofp, "l2 table id : No input ACL tables configured\n");
2430 table_id = ntohl(mp->ip4_table_id);
2432 fformat (vam->ofp, "ip4 table id : %d\n", table_id);
2434 fformat (vam->ofp, "ip4 table id : No input ACL tables configured\n");
2435 table_id = ntohl(mp->ip6_table_id);
2437 fformat (vam->ofp, "ip6 table id : %d\n", table_id);
2439 fformat (vam->ofp, "ip6 table id : No input ACL tables configured\n");
2440 vam->retval = ntohl(mp->retval);
2441 vam->result_ready = 1;
2444 static void vl_api_classify_table_by_interface_reply_t_handler_json (vl_api_classify_table_by_interface_reply_t * mp)
2446 vat_main_t * vam = &vat_main;
2447 vat_json_node_t node;
2449 vat_json_init_object(&node);
2451 vat_json_object_add_int(&node, "l2_table_id", ntohl(mp->l2_table_id));
2452 vat_json_object_add_int(&node, "ip4_table_id", ntohl(mp->ip4_table_id));
2453 vat_json_object_add_int(&node, "ip6_table_id", ntohl(mp->ip6_table_id));
2455 vat_json_print(vam->ofp, &node);
2456 vat_json_free(&node);
2458 vam->retval = ntohl(mp->retval);
2459 vam->result_ready = 1;
2462 /* Format hex dump. */
2463 u8 * format_hex_bytes (u8 * s, va_list * va)
2465 u8 * bytes = va_arg (*va, u8 *);
2466 int n_bytes = va_arg (*va, int);
2469 /* Print short or long form depending on byte count. */
2470 uword short_form = n_bytes <= 32;
2471 uword indent = format_get_indent (s);
2476 for (i = 0; i < n_bytes; i++)
2478 if (! short_form && (i % 32) == 0)
2479 s = format (s, "%08x: ", i);
2480 s = format (s, "%02x", bytes[i]);
2481 if (! short_form && ((i + 1) % 32) == 0 && (i + 1) < n_bytes)
2482 s = format (s, "\n%U", format_white_space, indent);
2488 static void vl_api_classify_table_info_reply_t_handler (vl_api_classify_table_info_reply_t * mp)
2490 vat_main_t * vam = &vat_main;
2491 i32 retval = ntohl(mp->retval);
2493 fformat (vam->ofp, "classify table info :\n");
2494 fformat (vam->ofp, "sessions: %d nexttbl: %d nextnode: %d\n", ntohl(mp->active_sessions), ntohl(mp->next_table_index), ntohl(mp->miss_next_index));
2495 fformat (vam->ofp, "nbuckets: %d skip: %d match: %d\n", ntohl(mp->nbuckets), ntohl(mp->skip_n_vectors), ntohl(mp->match_n_vectors));
2496 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->mask, ntohl(mp->mask_length));
2498 vam->retval = retval;
2499 vam->result_ready = 1;
2502 static void vl_api_classify_table_info_reply_t_handler_json (vl_api_classify_table_info_reply_t * mp)
2504 vat_main_t * vam = &vat_main;
2505 vat_json_node_t node;
2507 i32 retval = ntohl(mp->retval);
2509 vat_json_init_object(&node);
2511 vat_json_object_add_int(&node, "sessions", ntohl(mp->active_sessions));
2512 vat_json_object_add_int(&node, "nexttbl", ntohl(mp->next_table_index));
2513 vat_json_object_add_int(&node, "nextnode", ntohl(mp->miss_next_index));
2514 vat_json_object_add_int(&node, "nbuckets", ntohl(mp->nbuckets));
2515 vat_json_object_add_int(&node, "skip", ntohl(mp->skip_n_vectors));
2516 vat_json_object_add_int(&node, "match", ntohl(mp->match_n_vectors));
2517 u8 * s = format (0, "%U%c",format_hex_bytes, mp->mask, ntohl(mp->mask_length), 0);
2518 vat_json_object_add_string_copy(&node, "mask", s);
2520 vat_json_print(vam->ofp, &node);
2521 vat_json_free(&node);
2523 vam->retval = ntohl(mp->retval);
2524 vam->result_ready = 1;
2527 static void vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t * mp)
2529 vat_main_t * vam = &vat_main;
2531 fformat (vam->ofp, "next_index: %d advance: %d opaque: %d ", ntohl(mp->hit_next_index), ntohl(mp->advance), ntohl(mp->opaque_index));
2532 fformat (vam->ofp, "mask: %U\n", format_hex_bytes, mp->match, ntohl(mp->match_length));
2535 static void vl_api_classify_session_details_t_handler_json (vl_api_classify_session_details_t * mp)
2537 vat_main_t * vam = &vat_main;
2538 vat_json_node_t *node = NULL;
2540 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2541 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2542 vat_json_init_array(&vam->json_tree);
2544 node = vat_json_array_add(&vam->json_tree);
2546 vat_json_init_object(node);
2547 vat_json_object_add_int(node, "next_index", ntohl(mp->hit_next_index));
2548 vat_json_object_add_int(node, "advance", ntohl(mp->advance));
2549 vat_json_object_add_int(node, "opaque", ntohl(mp->opaque_index));
2550 u8 * s = format (0, "%U%c",format_hex_bytes, mp->match, ntohl(mp->match_length), 0);
2551 vat_json_object_add_string_copy(node, "match", s);
2554 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
2555 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
2556 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
2557 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
2560 * Generate boilerplate reply handlers, which
2561 * dig the return value out of the xxx_reply_t API message,
2562 * stick it into vam->retval, and set vam->result_ready
2564 * Could also do this by pointing N message decode slots at
2565 * a single function, but that could break in subtle ways.
2568 #define foreach_standard_reply_retval_handler \
2569 _(sw_interface_set_flags_reply) \
2570 _(sw_interface_add_del_address_reply) \
2571 _(sw_interface_set_table_reply) \
2572 _(sw_interface_set_vpath_reply) \
2573 _(sw_interface_set_l2_bridge_reply) \
2574 _(bridge_domain_add_del_reply) \
2575 _(sw_interface_set_l2_xconnect_reply) \
2576 _(l2fib_add_del_reply) \
2577 _(ip_add_del_route_reply) \
2578 _(proxy_arp_add_del_reply) \
2579 _(proxy_arp_intfc_enable_disable_reply) \
2580 _(mpls_add_del_encap_reply) \
2581 _(mpls_add_del_decap_reply) \
2582 _(mpls_ethernet_add_del_tunnel_2_reply) \
2583 _(sw_interface_set_unnumbered_reply) \
2584 _(ip_neighbor_add_del_reply) \
2585 _(reset_vrf_reply) \
2586 _(oam_add_del_reply) \
2587 _(reset_fib_reply) \
2588 _(dhcp_proxy_config_reply) \
2589 _(dhcp_proxy_config_2_reply) \
2590 _(dhcp_proxy_set_vss_reply) \
2591 _(dhcp_client_config_reply) \
2592 _(set_ip_flow_hash_reply) \
2593 _(sw_interface_ip6_enable_disable_reply) \
2594 _(sw_interface_ip6_set_link_local_address_reply) \
2595 _(sw_interface_ip6nd_ra_prefix_reply) \
2596 _(sw_interface_ip6nd_ra_config_reply) \
2597 _(set_arp_neighbor_limit_reply) \
2598 _(l2_patch_add_del_reply) \
2599 _(sr_tunnel_add_del_reply) \
2600 _(sr_policy_add_del_reply) \
2601 _(sr_multicast_map_add_del_reply) \
2602 _(classify_add_del_session_reply) \
2603 _(classify_set_interface_ip_table_reply) \
2604 _(classify_set_interface_l2_tables_reply) \
2605 _(l2tpv3_set_tunnel_cookies_reply) \
2606 _(l2tpv3_interface_enable_disable_reply) \
2607 _(l2tpv3_set_lookup_key_reply) \
2608 _(l2_fib_clear_table_reply) \
2609 _(l2_interface_efp_filter_reply) \
2610 _(l2_interface_vlan_tag_rewrite_reply) \
2611 _(modify_vhost_user_if_reply) \
2612 _(delete_vhost_user_if_reply) \
2613 _(want_ip4_arp_events_reply) \
2614 _(input_acl_set_interface_reply) \
2615 _(ipsec_spd_add_del_reply) \
2616 _(ipsec_interface_add_del_spd_reply) \
2617 _(ipsec_spd_add_del_entry_reply) \
2618 _(ipsec_sad_add_del_entry_reply) \
2619 _(ipsec_sa_set_key_reply) \
2620 _(ikev2_profile_add_del_reply) \
2621 _(ikev2_profile_set_auth_reply) \
2622 _(ikev2_profile_set_id_reply) \
2623 _(ikev2_profile_set_ts_reply) \
2624 _(ikev2_set_local_key_reply) \
2625 _(delete_loopback_reply) \
2626 _(bd_ip_mac_add_del_reply) \
2627 _(map_del_domain_reply) \
2628 _(map_add_del_rule_reply) \
2629 _(want_interface_events_reply) \
2630 _(want_stats_reply) \
2631 _(cop_interface_enable_disable_reply) \
2632 _(cop_whitelist_enable_disable_reply) \
2633 _(sw_interface_clear_stats_reply) \
2634 _(trace_profile_add_reply) \
2635 _(trace_profile_apply_reply) \
2636 _(trace_profile_del_reply) \
2637 _(lisp_add_del_locator_set_reply) \
2638 _(lisp_add_del_locator_reply) \
2639 _(lisp_add_del_local_eid_reply) \
2640 _(lisp_add_del_remote_mapping_reply) \
2641 _(lisp_add_del_adjacency_reply) \
2642 _(lisp_gpe_add_del_fwd_entry_reply) \
2643 _(lisp_add_del_map_resolver_reply) \
2644 _(lisp_gpe_enable_disable_reply) \
2645 _(lisp_gpe_add_del_iface_reply) \
2646 _(lisp_enable_disable_reply) \
2647 _(lisp_pitr_set_locator_set_reply) \
2648 _(lisp_add_del_map_request_itr_rlocs_reply) \
2649 _(lisp_eid_table_add_del_map_reply) \
2650 _(vxlan_gpe_add_del_tunnel_reply) \
2651 _(af_packet_delete_reply) \
2652 _(policer_add_del_reply) \
2653 _(netmap_create_reply) \
2654 _(netmap_delete_reply)
2657 static void vl_api_##n##_t_handler \
2658 (vl_api_##n##_t * mp) \
2660 vat_main_t * vam = &vat_main; \
2661 i32 retval = ntohl(mp->retval); \
2662 if (vam->async_mode) { \
2663 vam->async_errors += (retval < 0); \
2665 vam->retval = retval; \
2666 vam->result_ready = 1; \
2669 foreach_standard_reply_retval_handler;
2673 static void vl_api_##n##_t_handler_json \
2674 (vl_api_##n##_t * mp) \
2676 vat_main_t * vam = &vat_main; \
2677 vat_json_node_t node; \
2678 vat_json_init_object(&node); \
2679 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
2680 vat_json_print(vam->ofp, &node); \
2681 vam->retval = ntohl(mp->retval); \
2682 vam->result_ready = 1; \
2684 foreach_standard_reply_retval_handler;
2688 * Table of message reply handlers, must include boilerplate handlers
2692 #define foreach_vpe_api_reply_msg \
2693 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
2694 _(SW_INTERFACE_DETAILS, sw_interface_details) \
2695 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
2696 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
2697 _(CONTROL_PING_REPLY, control_ping_reply) \
2698 _(CLI_REPLY, cli_reply) \
2699 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
2700 sw_interface_add_del_address_reply) \
2701 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
2702 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
2703 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
2704 sw_interface_set_l2_xconnect_reply) \
2705 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
2706 sw_interface_set_l2_bridge_reply) \
2707 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
2708 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
2709 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
2710 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
2711 _(L2_FLAGS_REPLY, l2_flags_reply) \
2712 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
2713 _(TAP_CONNECT_REPLY, tap_connect_reply) \
2714 _(TAP_MODIFY_REPLY, tap_modify_reply) \
2715 _(TAP_DELETE_REPLY, tap_delete_reply) \
2716 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
2717 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
2718 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
2719 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
2720 proxy_arp_intfc_enable_disable_reply) \
2721 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
2722 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
2723 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
2724 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
2725 mpls_ethernet_add_del_tunnel_reply) \
2726 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
2727 mpls_ethernet_add_del_tunnel_2_reply) \
2728 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
2729 sw_interface_set_unnumbered_reply) \
2730 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
2731 _(RESET_VRF_REPLY, reset_vrf_reply) \
2732 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
2733 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2734 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
2735 _(RESET_FIB_REPLY, reset_fib_reply) \
2736 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
2737 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
2738 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
2739 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
2740 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2741 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2742 sw_interface_ip6_enable_disable_reply) \
2743 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
2744 sw_interface_ip6_set_link_local_address_reply) \
2745 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
2746 sw_interface_ip6nd_ra_prefix_reply) \
2747 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
2748 sw_interface_ip6nd_ra_config_reply) \
2749 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
2750 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2751 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
2752 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
2753 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
2754 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
2755 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
2756 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
2757 classify_set_interface_ip_table_reply) \
2758 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
2759 classify_set_interface_l2_tables_reply) \
2760 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2761 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2762 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
2763 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
2764 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
2765 l2tpv3_interface_enable_disable_reply) \
2766 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
2767 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
2768 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
2769 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
2770 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
2771 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
2772 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2773 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2774 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2775 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
2776 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
2777 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
2778 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
2779 _(SHOW_VERSION_REPLY, show_version_reply) \
2780 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
2781 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
2782 _(VXLAN_GPE_TUNNEL_DETAILS, vxlan_gpe_tunnel_details) \
2783 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2784 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
2785 _(IP4_ARP_EVENT, ip4_arp_event) \
2786 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
2787 _(IP_ADDRESS_DETAILS, ip_address_details) \
2788 _(IP_DETAILS, ip_details) \
2789 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
2790 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
2791 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
2792 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
2793 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
2794 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
2795 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
2796 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
2797 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
2798 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
2799 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
2800 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
2801 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
2802 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
2803 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
2804 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
2805 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
2806 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
2807 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
2808 _(MAP_DOMAIN_DETAILS, map_domain_details) \
2809 _(MAP_RULE_DETAILS, map_rule_details) \
2810 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
2811 _(WANT_STATS_REPLY, want_stats_reply) \
2812 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
2813 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
2814 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
2815 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
2816 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
2817 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
2818 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
2819 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
2820 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
2821 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
2822 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
2823 _(LISP_ADD_DEL_REMOTE_MAPPING_REPLY, lisp_add_del_remote_mapping_reply) \
2824 _(LISP_ADD_DEL_ADJACENCY_REPLY, lisp_add_del_adjacency_reply) \
2825 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
2826 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
2827 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
2828 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
2829 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
2830 _(LISP_EID_TABLE_ADD_DEL_MAP_REPLY, lisp_eid_table_add_del_map_reply) \
2831 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
2832 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
2833 _(LISP_LOCAL_EID_TABLE_DETAILS, lisp_local_eid_table_details) \
2834 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
2835 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
2836 _(LISP_ENABLE_DISABLE_STATUS_DETAILS, \
2837 lisp_enable_disable_status_details) \
2838 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY, \
2839 lisp_add_del_map_request_itr_rlocs_reply) \
2840 _(LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY, \
2841 lisp_get_map_request_itr_rlocs_reply) \
2842 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
2843 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
2844 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
2845 _(POLICER_DETAILS, policer_details) \
2846 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
2847 _(NETMAP_DELETE_REPLY, netmap_delete_reply) \
2848 _(MPLS_GRE_TUNNEL_DETAILS, mpls_gre_tunnel_details) \
2849 _(MPLS_ETH_TUNNEL_DETAILS, mpls_eth_tunnel_details) \
2850 _(MPLS_FIB_ENCAP_DETAILS, mpls_fib_encap_details) \
2851 _(MPLS_FIB_DECAP_DETAILS, mpls_fib_decap_details) \
2852 _(CLASSIFY_TABLE_IDS_REPLY, classify_table_ids_reply) \
2853 _(CLASSIFY_TABLE_BY_INTERFACE_REPLY, classify_table_by_interface_reply) \
2854 _(CLASSIFY_TABLE_INFO_REPLY, classify_table_info_reply) \
2855 _(CLASSIFY_SESSION_DETAILS, classify_session_details)
2857 /* M: construct, but don't yet send a message */
2861 vam->result_ready = 0; \
2862 mp = vl_msg_api_alloc(sizeof(*mp)); \
2863 memset (mp, 0, sizeof (*mp)); \
2864 mp->_vl_msg_id = ntohs (VL_API_##T); \
2865 mp->client_index = vam->my_client_index; \
2870 vam->result_ready = 0; \
2871 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
2872 memset (mp, 0, sizeof (*mp)); \
2873 mp->_vl_msg_id = ntohs (VL_API_##T); \
2874 mp->client_index = vam->my_client_index; \
2878 /* S: send a message */
2879 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
2881 /* W: wait for results, with timeout */
2884 timeout = vat_time_now (vam) + 1.0; \
2886 while (vat_time_now (vam) < timeout) { \
2887 if (vam->result_ready == 1) { \
2888 return (vam->retval); \
2894 /* W2: wait for results, with timeout */
2897 timeout = vat_time_now (vam) + 1.0; \
2899 while (vat_time_now (vam) < timeout) { \
2900 if (vam->result_ready == 1) { \
2902 return (vam->retval); \
2914 #define STR_VTR_OP_CASE(op) \
2915 case L2_VTR_ ## op: \
2918 static const char *str_vtr_op(u32 vtr_op)
2921 STR_VTR_OP_CASE(DISABLED);
2922 STR_VTR_OP_CASE(PUSH_1);
2923 STR_VTR_OP_CASE(PUSH_2);
2924 STR_VTR_OP_CASE(POP_1);
2925 STR_VTR_OP_CASE(POP_2);
2926 STR_VTR_OP_CASE(TRANSLATE_1_1);
2927 STR_VTR_OP_CASE(TRANSLATE_1_2);
2928 STR_VTR_OP_CASE(TRANSLATE_2_1);
2929 STR_VTR_OP_CASE(TRANSLATE_2_2);
2935 static int dump_sub_interface_table (vat_main_t * vam)
2937 const sw_interface_subif_t * sub = NULL;
2939 if (vam->json_output) {
2940 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2945 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
2946 "Interface", "sw_if_index",
2947 "sub id", "dot1ad", "tags", "outer id",
2948 "inner id", "exact", "default",
2949 "outer any", "inner any");
2951 vec_foreach (sub, vam->sw_if_subif_table) {
2953 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
2954 sub->interface_name,
2956 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
2957 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
2958 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
2959 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
2960 if (sub->vtr_op != L2_VTR_DISABLED) {
2962 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
2963 "tag1: %d tag2: %d ]\n",
2964 str_vtr_op(sub->vtr_op), sub->vtr_push_dot1q,
2965 sub->vtr_tag1, sub->vtr_tag2);
2972 static int name_sort_cmp (void * a1, void * a2)
2974 name_sort_t * n1 = a1;
2975 name_sort_t * n2 = a2;
2977 return strcmp ((char *)n1->name, (char *)n2->name);
2980 static int dump_interface_table (vat_main_t * vam)
2983 name_sort_t * nses = 0, * ns;
2985 if (vam->json_output) {
2986 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2990 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2992 vec_add2 (nses, ns, 1);
2993 ns->name = (u8 *)(p->key);
2994 ns->value = (u32) p->value[0];
2997 vec_sort_with_function (nses, name_sort_cmp);
2999 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
3000 vec_foreach (ns, nses) {
3001 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
3007 static int dump_ip_table (vat_main_t * vam, int is_ipv6)
3009 const ip_details_t * det = NULL;
3010 const ip_address_details_t * address = NULL;
3021 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6]) {
3023 if (!det->present) {
3031 "Address", "Prefix length");
3035 vec_foreach (address, det->addr) {
3038 is_ipv6 ? format_ip6_address : format_ip4_address,
3040 address->prefix_length);
3047 static int dump_ipv4_table (vat_main_t * vam)
3049 if (vam->json_output) {
3050 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
3054 return dump_ip_table (vam, 0);
3057 static int dump_ipv6_table (vat_main_t * vam)
3059 if (vam->json_output) {
3060 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
3064 return dump_ip_table (vam, 1);
3067 static char* counter_type_to_str (u8 counter_type, u8 is_combined)
3070 switch(counter_type) {
3071 case VNET_INTERFACE_COUNTER_DROP:
3073 case VNET_INTERFACE_COUNTER_PUNT:
3075 case VNET_INTERFACE_COUNTER_IP4:
3077 case VNET_INTERFACE_COUNTER_IP6:
3079 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
3081 case VNET_INTERFACE_COUNTER_RX_MISS:
3083 case VNET_INTERFACE_COUNTER_RX_ERROR:
3085 case VNET_INTERFACE_COUNTER_TX_ERROR:
3088 return "INVALID-COUNTER-TYPE";
3091 switch(counter_type) {
3092 case VNET_INTERFACE_COUNTER_RX:
3094 case VNET_INTERFACE_COUNTER_TX:
3097 return "INVALID-COUNTER-TYPE";
3102 static int dump_stats_table (vat_main_t * vam)
3104 vat_json_node_t node;
3105 vat_json_node_t *msg_array;
3106 vat_json_node_t *msg;
3107 vat_json_node_t *counter_array;
3108 vat_json_node_t *counter;
3109 interface_counter_t c;
3111 ip4_fib_counter_t *c4;
3112 ip6_fib_counter_t *c6;
3115 if (!vam->json_output) {
3116 clib_warning ("dump_stats_table supported only in JSON format");
3120 vat_json_init_object(&node);
3122 /* interface counters */
3123 msg_array = vat_json_object_add(&node, "interface_counters");
3124 vat_json_init_array(msg_array);
3125 for (i = 0; i < vec_len(vam->simple_interface_counters); i++) {
3126 msg = vat_json_array_add(msg_array);
3127 vat_json_init_object(msg);
3128 vat_json_object_add_string_copy(msg, "vnet_counter_type",
3129 (u8*)counter_type_to_str(i, 0));
3130 vat_json_object_add_int(msg, "is_combined", 0);
3131 counter_array = vat_json_object_add(msg, "data");
3132 vat_json_init_array(counter_array);
3133 for (j = 0; j < vec_len(vam->simple_interface_counters[i]); j++) {
3134 packets = vam->simple_interface_counters[i][j];
3135 vat_json_array_add_uint(counter_array, packets);
3138 for (i = 0; i < vec_len(vam->combined_interface_counters); i++) {
3139 msg = vat_json_array_add(msg_array);
3140 vat_json_init_object(msg);
3141 vat_json_object_add_string_copy(msg, "vnet_counter_type",
3142 (u8*)counter_type_to_str(i, 1));
3143 vat_json_object_add_int(msg, "is_combined", 1);
3144 counter_array = vat_json_object_add(msg, "data");
3145 vat_json_init_array(counter_array);
3146 for (j = 0; j < vec_len(vam->combined_interface_counters[i]); j++) {
3147 c = vam->combined_interface_counters[i][j];
3148 counter = vat_json_array_add(counter_array);
3149 vat_json_init_object(counter);
3150 vat_json_object_add_uint(counter, "packets", c.packets);
3151 vat_json_object_add_uint(counter, "bytes", c.bytes);
3155 /* ip4 fib counters */
3156 msg_array = vat_json_object_add(&node, "ip4_fib_counters");
3157 vat_json_init_array(msg_array);
3158 for (i = 0; i < vec_len(vam->ip4_fib_counters); i++) {
3159 msg = vat_json_array_add(msg_array);
3160 vat_json_init_object(msg);
3161 vat_json_object_add_uint(msg, "vrf_id", vam->ip4_fib_counters_vrf_id_by_index[i]);
3162 counter_array = vat_json_object_add(msg, "c");
3163 vat_json_init_array(counter_array);
3164 for (j = 0; j < vec_len(vam->ip4_fib_counters[i]); j++) {
3165 counter = vat_json_array_add(counter_array);
3166 vat_json_init_object(counter);
3167 c4 = &vam->ip4_fib_counters[i][j];
3168 vat_json_object_add_ip4(counter, "address", c4->address);
3169 vat_json_object_add_uint(counter, "address_length", c4->address_length);
3170 vat_json_object_add_uint(counter, "packets", c4->packets);
3171 vat_json_object_add_uint(counter, "bytes", c4->bytes);
3175 /* ip6 fib counters */
3176 msg_array = vat_json_object_add(&node, "ip6_fib_counters");
3177 vat_json_init_array(msg_array);
3178 for (i = 0; i < vec_len(vam->ip6_fib_counters); i++) {
3179 msg = vat_json_array_add(msg_array);
3180 vat_json_init_object(msg);
3181 vat_json_object_add_uint(msg, "vrf_id", vam->ip6_fib_counters_vrf_id_by_index[i]);
3182 counter_array = vat_json_object_add(msg, "c");
3183 vat_json_init_array(counter_array);
3184 for (j = 0; j < vec_len(vam->ip6_fib_counters[i]); j++) {
3185 counter = vat_json_array_add(counter_array);
3186 vat_json_init_object(counter);
3187 c6 = &vam->ip6_fib_counters[i][j];
3188 vat_json_object_add_ip6(counter, "address", c6->address);
3189 vat_json_object_add_uint(counter, "address_length", c6->address_length);
3190 vat_json_object_add_uint(counter, "packets", c6->packets);
3191 vat_json_object_add_uint(counter, "bytes", c6->bytes);
3195 vat_json_print(vam->ofp, &node);
3196 vat_json_free(&node);
3201 int exec (vat_main_t * vam)
3203 api_main_t * am = &api_main;
3204 vl_api_cli_request_t *mp;
3208 unformat_input_t * i = vam->input;
3210 if (vec_len(i->buffer) == 0)
3213 if (vam->exec_mode == 0 && unformat (i, "mode")) {
3217 if (vam->exec_mode == 1 &&
3218 (unformat (i, "exit") || unformat (i, "quit"))) {
3224 M(CLI_REQUEST, cli_request);
3227 * Copy cmd into shared memory.
3228 * In order for the CLI command to work, it
3229 * must be a vector ending in \n, not a C-string ending
3232 pthread_mutex_lock (&am->vlib_rp->mutex);
3233 oldheap = svm_push_data_heap (am->vlib_rp);
3235 vec_validate (cmd, vec_len(vam->input->buffer)-1);
3236 clib_memcpy (cmd, vam->input->buffer, vec_len(vam->input->buffer));
3238 svm_pop_heap (oldheap);
3239 pthread_mutex_unlock (&am->vlib_rp->mutex);
3241 mp->cmd_in_shmem = (u64) cmd;
3243 timeout = vat_time_now (vam) + 10.0;
3245 while (vat_time_now (vam) < timeout) {
3246 if (vam->result_ready == 1) {
3248 if (vam->shmem_result != NULL)
3249 fformat (vam->ofp, "%s", vam->shmem_result);
3250 pthread_mutex_lock (&am->vlib_rp->mutex);
3251 oldheap = svm_push_data_heap (am->vlib_rp);
3253 free_me = (u8 *)vam->shmem_result;
3256 svm_pop_heap (oldheap);
3257 pthread_mutex_unlock (&am->vlib_rp->mutex);
3264 static int api_create_loopback (vat_main_t * vam)
3266 unformat_input_t * i = vam->input;
3267 vl_api_create_loopback_t *mp;
3272 memset (mac_address, 0, sizeof (mac_address));
3274 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3276 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
3282 /* Construct the API message */
3283 M(CREATE_LOOPBACK, create_loopback);
3285 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
3290 static int api_delete_loopback (vat_main_t * vam)
3292 unformat_input_t * i = vam->input;
3293 vl_api_delete_loopback_t *mp;
3295 u32 sw_if_index = ~0;
3297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3299 if (unformat (i, "sw_if_index %d", &sw_if_index))
3305 if (sw_if_index == ~0)
3307 errmsg ("missing sw_if_index\n");
3311 /* Construct the API message */
3312 M(DELETE_LOOPBACK, delete_loopback);
3313 mp->sw_if_index = ntohl (sw_if_index);
3318 static int api_want_stats (vat_main_t * vam)
3320 unformat_input_t * i = vam->input;
3321 vl_api_want_stats_t * mp;
3325 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3327 if (unformat (i, "enable"))
3329 else if (unformat (i, "disable"))
3337 errmsg ("missing enable|disable\n");
3341 M(WANT_STATS, want_stats);
3342 mp->enable_disable = enable;
3347 static int api_want_interface_events (vat_main_t * vam)
3349 unformat_input_t * i = vam->input;
3350 vl_api_want_interface_events_t * mp;
3354 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3356 if (unformat (i, "enable"))
3358 else if (unformat (i, "disable"))
3366 errmsg ("missing enable|disable\n");
3370 M(WANT_INTERFACE_EVENTS, want_interface_events);
3371 mp->enable_disable = enable;
3373 vam->interface_event_display = enable;
3379 /* Note: non-static, called once to set up the initial intfc table */
3380 int api_sw_interface_dump (vat_main_t * vam)
3382 vl_api_sw_interface_dump_t *mp;
3385 name_sort_t * nses = 0, * ns;
3386 sw_interface_subif_t * sub = NULL;
3388 /* Toss the old name table */
3389 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3391 vec_add2 (nses, ns, 1);
3392 ns->name = (u8 *)(p->key);
3393 ns->value = (u32) p->value[0];
3396 hash_free (vam->sw_if_index_by_interface_name);
3398 vec_foreach (ns, nses)
3399 vec_free (ns->name);
3403 vec_foreach (sub, vam->sw_if_subif_table) {
3404 vec_free (sub->interface_name);
3406 vec_free (vam->sw_if_subif_table);
3408 /* recreate the interface name hash table */
3409 vam->sw_if_index_by_interface_name
3410 = hash_create_string (0, sizeof(uword));
3412 /* Get list of ethernets */
3413 M(SW_INTERFACE_DUMP, sw_interface_dump);
3414 mp->name_filter_valid = 1;
3415 strncpy ((char *) mp->name_filter, "Ether", sizeof(mp->name_filter)-1);
3418 /* and local / loopback interfaces */
3419 M(SW_INTERFACE_DUMP, sw_interface_dump);
3420 mp->name_filter_valid = 1;
3421 strncpy ((char *) mp->name_filter, "lo", sizeof(mp->name_filter)-1);
3425 /* and vxlan-gpe tunnel interfaces */
3426 M(SW_INTERFACE_DUMP, sw_interface_dump);
3427 mp->name_filter_valid = 1;
3428 strncpy ((char *) mp->name_filter, "vxlan_gpe", sizeof(mp->name_filter)-1);
3431 /* and vxlan tunnel interfaces */
3432 M(SW_INTERFACE_DUMP, sw_interface_dump);
3433 mp->name_filter_valid = 1;
3434 strncpy ((char *) mp->name_filter, "vxlan", sizeof(mp->name_filter)-1);
3437 /* and host (af_packet) interfaces */
3438 M(SW_INTERFACE_DUMP, sw_interface_dump);
3439 mp->name_filter_valid = 1;
3440 strncpy ((char *) mp->name_filter, "host", sizeof(mp->name_filter)-1);
3443 /* and l2tpv3 tunnel interfaces */
3444 M(SW_INTERFACE_DUMP, sw_interface_dump);
3445 mp->name_filter_valid = 1;
3446 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel", sizeof(mp->name_filter)-1);
3449 /* and GRE tunnel interfaces */
3450 M(SW_INTERFACE_DUMP, sw_interface_dump);
3451 mp->name_filter_valid = 1;
3452 strncpy ((char *) mp->name_filter, "gre", sizeof(mp->name_filter)-1);
3455 /* Use a control ping for synchronization */
3457 vl_api_control_ping_t * mp;
3458 M(CONTROL_PING, control_ping);
3464 static int api_sw_interface_set_flags (vat_main_t * vam)
3466 unformat_input_t * i = vam->input;
3467 vl_api_sw_interface_set_flags_t *mp;
3470 u8 sw_if_index_set = 0;
3471 u8 admin_up = 0, link_up = 0;
3473 /* Parse args required to build the message */
3474 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3475 if (unformat (i, "admin-up"))
3477 else if (unformat (i, "admin-down"))
3479 else if (unformat (i, "link-up"))
3481 else if (unformat (i, "link-down"))
3483 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3484 sw_if_index_set = 1;
3485 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3486 sw_if_index_set = 1;
3491 if (sw_if_index_set == 0) {
3492 errmsg ("missing interface name or sw_if_index\n");
3496 /* Construct the API message */
3497 M(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
3498 mp->sw_if_index = ntohl (sw_if_index);
3499 mp->admin_up_down = admin_up;
3500 mp->link_up_down = link_up;
3505 /* Wait for a reply, return the good/bad news... */
3509 static int api_sw_interface_clear_stats (vat_main_t * vam)
3511 unformat_input_t * i = vam->input;
3512 vl_api_sw_interface_clear_stats_t *mp;
3515 u8 sw_if_index_set = 0;
3517 /* Parse args required to build the message */
3518 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3519 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3520 sw_if_index_set = 1;
3521 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3522 sw_if_index_set = 1;
3527 /* Construct the API message */
3528 M(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
3530 if (sw_if_index_set == 1)
3531 mp->sw_if_index = ntohl (sw_if_index);
3533 mp->sw_if_index = ~0;
3538 /* Wait for a reply, return the good/bad news... */
3542 static int api_sw_interface_add_del_address (vat_main_t * vam)
3544 unformat_input_t * i = vam->input;
3545 vl_api_sw_interface_add_del_address_t *mp;
3548 u8 sw_if_index_set = 0;
3549 u8 is_add = 1, del_all = 0;
3550 u32 address_length = 0;
3551 u8 v4_address_set = 0;
3552 u8 v6_address_set = 0;
3553 ip4_address_t v4address;
3554 ip6_address_t v6address;
3556 /* Parse args required to build the message */
3557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3558 if (unformat (i, "del-all"))
3560 else if (unformat (i, "del"))
3562 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3563 sw_if_index_set = 1;
3564 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3565 sw_if_index_set = 1;
3566 else if (unformat (i, "%U/%d",
3567 unformat_ip4_address, &v4address,
3570 else if (unformat (i, "%U/%d",
3571 unformat_ip6_address, &v6address,
3578 if (sw_if_index_set == 0) {
3579 errmsg ("missing interface name or sw_if_index\n");
3582 if (v4_address_set && v6_address_set) {
3583 errmsg ("both v4 and v6 addresses set\n");
3586 if (!v4_address_set && !v6_address_set && !del_all) {
3587 errmsg ("no addresses set\n");
3591 /* Construct the API message */
3592 M(SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
3594 mp->sw_if_index = ntohl (sw_if_index);
3595 mp->is_add = is_add;
3596 mp->del_all = del_all;
3597 if (v6_address_set) {
3599 clib_memcpy (mp->address, &v6address, sizeof (v6address));
3601 clib_memcpy (mp->address, &v4address, sizeof (v4address));
3603 mp->address_length = address_length;
3608 /* Wait for a reply, return good/bad news */
3612 static int api_sw_interface_set_table (vat_main_t * vam)
3614 unformat_input_t * i = vam->input;
3615 vl_api_sw_interface_set_table_t *mp;
3617 u32 sw_if_index, vrf_id = 0;
3618 u8 sw_if_index_set = 0;
3621 /* Parse args required to build the message */
3622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3623 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3624 sw_if_index_set = 1;
3625 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3626 sw_if_index_set = 1;
3627 else if (unformat (i, "vrf %d", &vrf_id))
3629 else if (unformat (i, "ipv6"))
3635 if (sw_if_index_set == 0) {
3636 errmsg ("missing interface name or sw_if_index\n");
3640 /* Construct the API message */
3641 M(SW_INTERFACE_SET_TABLE, sw_interface_set_table);
3643 mp->sw_if_index = ntohl (sw_if_index);
3644 mp->is_ipv6 = is_ipv6;
3645 mp->vrf_id = ntohl (vrf_id);
3650 /* Wait for a reply... */
3654 static int api_sw_interface_set_vpath (vat_main_t * vam)
3656 unformat_input_t * i = vam->input;
3657 vl_api_sw_interface_set_vpath_t *mp;
3659 u32 sw_if_index = 0;
3660 u8 sw_if_index_set = 0;
3663 /* Parse args required to build the message */
3664 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3665 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3666 sw_if_index_set = 1;
3667 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3668 sw_if_index_set = 1;
3669 else if (unformat (i, "enable"))
3671 else if (unformat (i, "disable"))
3677 if (sw_if_index_set == 0) {
3678 errmsg ("missing interface name or sw_if_index\n");
3682 /* Construct the API message */
3683 M(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
3685 mp->sw_if_index = ntohl (sw_if_index);
3686 mp->enable = is_enable;
3691 /* Wait for a reply... */
3695 static int api_sw_interface_set_l2_xconnect (vat_main_t * vam)
3697 unformat_input_t * i = vam->input;
3698 vl_api_sw_interface_set_l2_xconnect_t *mp;
3701 u8 rx_sw_if_index_set = 0;
3703 u8 tx_sw_if_index_set = 0;
3706 /* Parse args required to build the message */
3707 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3708 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
3709 rx_sw_if_index_set = 1;
3710 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
3711 tx_sw_if_index_set = 1;
3712 else if (unformat (i, "rx")) {
3713 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3714 if (unformat (i, "%U", unformat_sw_if_index, vam,
3716 rx_sw_if_index_set = 1;
3719 } else if (unformat (i, "tx")) {
3720 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3721 if (unformat (i, "%U", unformat_sw_if_index, vam,
3723 tx_sw_if_index_set = 1;
3726 } else if (unformat (i, "enable"))
3728 else if (unformat (i, "disable"))
3734 if (rx_sw_if_index_set == 0) {
3735 errmsg ("missing rx interface name or rx_sw_if_index\n");
3739 if (enable && (tx_sw_if_index_set == 0)) {
3740 errmsg ("missing tx interface name or tx_sw_if_index\n");
3744 M(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
3746 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3747 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
3748 mp->enable = enable;
3755 static int api_sw_interface_set_l2_bridge (vat_main_t * vam)
3757 unformat_input_t * i = vam->input;
3758 vl_api_sw_interface_set_l2_bridge_t *mp;
3761 u8 rx_sw_if_index_set = 0;
3768 /* Parse args required to build the message */
3769 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3770 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
3771 rx_sw_if_index_set = 1;
3772 else if (unformat (i, "bd_id %d", &bd_id))
3774 else if (unformat (i, "%U", unformat_sw_if_index, vam,
3776 rx_sw_if_index_set = 1;
3777 else if (unformat (i, "shg %d", &shg))
3779 else if (unformat (i, "bvi"))
3781 else if (unformat (i, "enable"))
3783 else if (unformat (i, "disable"))
3789 if (rx_sw_if_index_set == 0) {
3790 errmsg ("missing rx interface name or sw_if_index\n");
3794 if (enable && (bd_id_set == 0)) {
3795 errmsg ("missing bridge domain\n");
3799 M(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
3801 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3802 mp->bd_id = ntohl(bd_id);
3805 mp->enable = enable;
3812 static int api_bridge_domain_dump (vat_main_t * vam)
3814 unformat_input_t * i = vam->input;
3815 vl_api_bridge_domain_dump_t *mp;
3819 /* Parse args required to build the message */
3820 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3821 if (unformat (i, "bd_id %d", &bd_id))
3827 M(BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
3828 mp->bd_id = ntohl(bd_id);
3831 /* Use a control ping for synchronization */
3833 vl_api_control_ping_t * mp;
3834 M(CONTROL_PING, control_ping);
3843 static int api_bridge_domain_add_del (vat_main_t * vam)
3845 unformat_input_t * i = vam->input;
3846 vl_api_bridge_domain_add_del_t *mp;
3850 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
3852 /* Parse args required to build the message */
3853 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3854 if (unformat (i, "bd_id %d", &bd_id))
3856 else if (unformat (i, "flood %d", &flood))
3858 else if (unformat (i, "uu-flood %d", &uu_flood))
3860 else if (unformat (i, "forward %d", &forward))
3862 else if (unformat (i, "learn %d", &learn))
3864 else if (unformat (i, "arp-term %d", &arp_term))
3866 else if (unformat (i, "del")) {
3868 flood = uu_flood = forward = learn = 0;
3875 errmsg ("missing bridge domain\n");
3879 M(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
3881 mp->bd_id = ntohl(bd_id);
3883 mp->uu_flood = uu_flood;
3884 mp->forward = forward;
3886 mp->arp_term = arp_term;
3887 mp->is_add = is_add;
3894 static int api_l2fib_add_del (vat_main_t * vam)
3896 unformat_input_t * i = vam->input;
3897 vl_api_l2fib_add_del_t *mp;
3904 u8 sw_if_index_set = 0;
3909 /* Parse args required to build the message */
3910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3911 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
3913 else if (unformat (i, "bd_id %d", &bd_id))
3915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3916 sw_if_index_set = 1;
3917 else if (unformat (i, "sw_if")) {
3918 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3919 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3920 sw_if_index_set = 1;
3923 } else if (unformat (i, "static"))
3925 else if (unformat (i, "filter")) {
3928 } else if (unformat (i, "del"))
3935 errmsg ("missing mac address\n");
3939 if (bd_id_set == 0) {
3940 errmsg ("missing bridge domain\n");
3944 if (is_add && (sw_if_index_set == 0)) {
3945 errmsg ("missing interface name or sw_if_index\n");
3949 M(L2FIB_ADD_DEL, l2fib_add_del);
3952 mp->bd_id = ntohl(bd_id);
3953 mp->is_add = is_add;
3956 mp->sw_if_index = ntohl(sw_if_index);
3957 mp->static_mac = static_mac;
3958 mp->filter_mac = filter_mac;
3966 static int api_l2_flags (vat_main_t * vam)
3968 unformat_input_t * i = vam->input;
3969 vl_api_l2_flags_t *mp;
3972 u32 feature_bitmap = 0;
3973 u8 sw_if_index_set = 0;
3975 /* Parse args required to build the message */
3976 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3977 if (unformat (i, "sw_if_index %d", &sw_if_index))
3978 sw_if_index_set = 1;
3979 else if (unformat (i, "sw_if")) {
3980 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3981 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3982 sw_if_index_set = 1;
3985 } else if (unformat (i, "learn"))
3986 feature_bitmap |= L2INPUT_FEAT_LEARN;
3987 else if (unformat (i, "forward"))
3988 feature_bitmap |= L2INPUT_FEAT_FWD;
3989 else if (unformat (i, "flood"))
3990 feature_bitmap |= L2INPUT_FEAT_FLOOD;
3991 else if (unformat (i, "uu-flood"))
3992 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
3997 if (sw_if_index_set == 0) {
3998 errmsg ("missing interface name or sw_if_index\n");
4002 M(L2_FLAGS, l2_flags);
4004 mp->sw_if_index = ntohl(sw_if_index);
4005 mp->feature_bitmap = ntohl(feature_bitmap);
4012 static int api_bridge_flags (vat_main_t * vam)
4014 unformat_input_t * i = vam->input;
4015 vl_api_bridge_flags_t *mp;
4022 /* Parse args required to build the message */
4023 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4024 if (unformat (i, "bd_id %d", &bd_id))
4026 else if (unformat (i, "learn"))
4028 else if (unformat (i, "forward"))
4030 else if (unformat (i, "flood"))
4032 else if (unformat (i, "uu-flood"))
4033 flags |= L2_UU_FLOOD;
4034 else if (unformat (i, "arp-term"))
4035 flags |= L2_ARP_TERM;
4036 else if (unformat (i, "off"))
4038 else if (unformat (i, "disable"))
4044 if (bd_id_set == 0) {
4045 errmsg ("missing bridge domain\n");
4049 M(BRIDGE_FLAGS, bridge_flags);
4051 mp->bd_id = ntohl(bd_id);
4052 mp->feature_bitmap = ntohl(flags);
4053 mp->is_set = is_set;
4060 static int api_bd_ip_mac_add_del (vat_main_t * vam)
4062 unformat_input_t * i = vam->input;
4063 vl_api_bd_ip_mac_add_del_t *mp;
4071 ip4_address_t v4addr;
4072 ip6_address_t v6addr;
4076 /* Parse args required to build the message */
4077 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4078 if (unformat (i, "bd_id %d", &bd_id)) {
4080 } else if (unformat (i, "%U", unformat_ip4_address, &v4addr)) {
4082 } else if (unformat (i, "%U", unformat_ip6_address, &v6addr)) {
4085 } else if (unformat (i, "%U", unformat_ethernet_address, macaddr)) {
4087 } else if (unformat (i, "del"))
4093 if (bd_id_set == 0) {
4094 errmsg ("missing bridge domain\n");
4096 } else if (ip_set == 0) {
4097 errmsg ("missing IP address\n");
4099 } else if (mac_set == 0) {
4100 errmsg ("missing MAC address\n");
4104 M(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
4106 mp->bd_id = ntohl(bd_id);
4107 mp->is_ipv6 = is_ipv6;
4108 mp->is_add = is_add;
4110 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
4111 else clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
4112 clib_memcpy (mp->mac_address, macaddr, 6);
4118 static int api_tap_connect (vat_main_t * vam)
4120 unformat_input_t * i = vam->input;
4121 vl_api_tap_connect_t *mp;
4128 memset (mac_address, 0, sizeof (mac_address));
4130 /* Parse args required to build the message */
4131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4132 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4135 else if (unformat (i, "random-mac"))
4137 else if (unformat (i, "tapname %s", &tap_name))
4143 if (name_set == 0) {
4144 errmsg ("missing tap name\n");
4147 if (vec_len (tap_name) > 63) {
4148 errmsg ("tap name too long\n");
4150 vec_add1 (tap_name, 0);
4152 /* Construct the API message */
4153 M(TAP_CONNECT, tap_connect);
4155 mp->use_random_mac = random_mac;
4156 clib_memcpy (mp->mac_address, mac_address, 6);
4157 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
4158 vec_free (tap_name);
4163 /* Wait for a reply... */
4167 static int api_tap_modify (vat_main_t * vam)
4169 unformat_input_t * i = vam->input;
4170 vl_api_tap_modify_t *mp;
4176 u32 sw_if_index = ~0;
4177 u8 sw_if_index_set = 0;
4179 memset (mac_address, 0, sizeof (mac_address));
4181 /* Parse args required to build the message */
4182 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4183 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4184 sw_if_index_set = 1;
4185 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4186 sw_if_index_set = 1;
4187 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4190 else if (unformat (i, "random-mac"))
4192 else if (unformat (i, "tapname %s", &tap_name))
4198 if (sw_if_index_set == 0) {
4199 errmsg ("missing vpp interface name");
4202 if (name_set == 0) {
4203 errmsg ("missing tap name\n");
4206 if (vec_len (tap_name) > 63) {
4207 errmsg ("tap name too long\n");
4209 vec_add1 (tap_name, 0);
4211 /* Construct the API message */
4212 M(TAP_MODIFY, tap_modify);
4214 mp->use_random_mac = random_mac;
4215 mp->sw_if_index = ntohl(sw_if_index);
4216 clib_memcpy (mp->mac_address, mac_address, 6);
4217 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
4218 vec_free (tap_name);
4223 /* Wait for a reply... */
4227 static int api_tap_delete (vat_main_t * vam)
4229 unformat_input_t * i = vam->input;
4230 vl_api_tap_delete_t *mp;
4232 u32 sw_if_index = ~0;
4233 u8 sw_if_index_set = 0;
4235 /* Parse args required to build the message */
4236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4237 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4238 sw_if_index_set = 1;
4239 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4240 sw_if_index_set = 1;
4245 if (sw_if_index_set == 0) {
4246 errmsg ("missing vpp interface name");
4250 /* Construct the API message */
4251 M(TAP_DELETE, tap_delete);
4253 mp->sw_if_index = ntohl(sw_if_index);
4258 /* Wait for a reply... */
4262 static int api_ip_add_del_route (vat_main_t * vam)
4264 unformat_input_t * i = vam->input;
4265 vl_api_ip_add_del_route_t *mp;
4267 u32 sw_if_index = 0, vrf_id = 0;
4268 u8 sw_if_index_set = 0;
4270 u8 is_local = 0, is_drop = 0;
4271 u8 create_vrf_if_needed = 0;
4273 u8 next_hop_weight = 1;
4275 u8 is_multipath = 0;
4277 u8 address_length_set = 0;
4278 u32 lookup_in_vrf = 0;
4279 u32 resolve_attempts = 0;
4280 u32 dst_address_length = 0;
4281 u8 next_hop_set = 0;
4282 ip4_address_t v4_dst_address, v4_next_hop_address;
4283 ip6_address_t v6_dst_address, v6_next_hop_address;
4287 u32 random_add_del = 0;
4288 u32 * random_vector = 0;
4289 uword * random_hash;
4290 u32 random_seed = 0xdeaddabe;
4291 u32 classify_table_index = ~0;
4294 /* Parse args required to build the message */
4295 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4296 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4297 sw_if_index_set = 1;
4298 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4299 sw_if_index_set = 1;
4300 else if (unformat (i, "%U", unformat_ip4_address,
4305 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address)) {
4309 else if (unformat (i, "/%d", &dst_address_length)) {
4310 address_length_set = 1;
4313 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
4314 &v4_next_hop_address)) {
4317 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
4318 &v6_next_hop_address)) {
4321 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4323 else if (unformat (i, "weight %d", &next_hop_weight))
4325 else if (unformat (i, "drop")) {
4327 } else if (unformat (i, "local")) {
4329 } else if (unformat (i, "classify %d", &classify_table_index)) {
4331 } else if (unformat (i, "del"))
4333 else if (unformat (i, "add"))
4335 else if (unformat (i, "not-last"))
4337 else if (unformat (i, "multipath"))
4339 else if (unformat (i, "vrf %d", &vrf_id))
4341 else if (unformat (i, "create-vrf"))
4342 create_vrf_if_needed = 1;
4343 else if (unformat (i, "count %d", &count))
4345 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
4347 else if (unformat (i, "random"))
4349 else if (unformat (i, "seed %d", &random_seed))
4352 clib_warning ("parse error '%U'", format_unformat_error, i);
4357 if (resolve_attempts > 0 && sw_if_index_set == 0) {
4358 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
4362 if (!next_hop_set && !is_drop && !is_local && !is_classify) {
4363 errmsg ("next hop / local / drop / classify not set\n");
4367 if (address_set == 0) {
4368 errmsg ("missing addresses\n");
4372 if (address_length_set == 0) {
4373 errmsg ("missing address length\n");
4377 /* Generate a pile of unique, random routes */
4378 if (random_add_del) {
4379 u32 this_random_address;
4380 random_hash = hash_create (count, sizeof(uword));
4382 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
4383 for (j = 0; j <= count; j++) {
4385 this_random_address = random_u32 (&random_seed);
4386 this_random_address =
4387 clib_host_to_net_u32 (this_random_address);
4388 } while (hash_get (random_hash, this_random_address));
4389 vec_add1 (random_vector, this_random_address);
4390 hash_set (random_hash, this_random_address, 1);
4392 hash_free (random_hash);
4393 v4_dst_address.as_u32 = random_vector[0];
4397 /* Turn on async mode */
4398 vam->async_mode = 1;
4399 vam->async_errors = 0;
4400 before = vat_time_now(vam);
4403 for (j = 0; j < count; j++) {
4404 /* Construct the API message */
4405 M(IP_ADD_DEL_ROUTE, ip_add_del_route);
4407 mp->next_hop_sw_if_index = ntohl (sw_if_index);
4408 mp->vrf_id = ntohl (vrf_id);
4409 if (resolve_attempts > 0) {
4410 mp->resolve_attempts = ntohl (resolve_attempts);
4411 mp->resolve_if_needed = 1;
4413 mp->create_vrf_if_needed = create_vrf_if_needed;
4415 mp->is_add = is_add;
4416 mp->is_drop = is_drop;
4417 mp->is_ipv6 = is_ipv6;
4418 mp->is_local = is_local;
4419 mp->is_classify = is_classify;
4420 mp->is_multipath = is_multipath;
4421 mp->not_last = not_last;
4422 mp->next_hop_weight = next_hop_weight;
4423 mp->dst_address_length = dst_address_length;
4424 mp->lookup_in_vrf = ntohl(lookup_in_vrf);
4425 mp->classify_table_index = ntohl(classify_table_index);
4428 clib_memcpy (mp->dst_address, &v6_dst_address, sizeof (v6_dst_address));
4430 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
4431 sizeof (v6_next_hop_address));
4432 increment_v6_address (&v6_dst_address);
4434 clib_memcpy (mp->dst_address, &v4_dst_address, sizeof (v4_dst_address));
4436 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
4437 sizeof (v4_next_hop_address));
4439 v4_dst_address.as_u32 = random_vector[j+1];
4441 increment_v4_address (&v4_dst_address);
4447 /* When testing multiple add/del ops, use a control-ping to sync */
4449 vl_api_control_ping_t * mp;
4452 /* Shut off async mode */
4453 vam->async_mode = 0;
4455 M(CONTROL_PING, control_ping);
4458 timeout = vat_time_now(vam) + 1.0;
4459 while (vat_time_now (vam) < timeout)
4460 if (vam->result_ready == 1)
4465 if (vam->retval == -99)
4466 errmsg ("timeout\n");
4468 if (vam->async_errors > 0) {
4469 errmsg ("%d asynchronous errors\n", vam->async_errors);
4472 vam->async_errors = 0;
4473 after = vat_time_now(vam);
4475 fformat(vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4476 count, after - before, count / (after - before));
4478 /* Wait for a reply... */
4482 /* Return the good/bad news */
4483 return (vam->retval);
4486 static int api_proxy_arp_add_del (vat_main_t * vam)
4488 unformat_input_t * i = vam->input;
4489 vl_api_proxy_arp_add_del_t *mp;
4493 ip4_address_t lo, hi;
4496 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4497 if (unformat (i, "vrf %d", &vrf_id))
4499 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
4500 unformat_ip4_address, &hi))
4502 else if (unformat (i, "del"))
4505 clib_warning ("parse error '%U'", format_unformat_error, i);
4510 if (range_set == 0) {
4511 errmsg ("address range not set\n");
4515 M(PROXY_ARP_ADD_DEL, proxy_arp_add_del);
4517 mp->vrf_id = ntohl(vrf_id);
4518 mp->is_add = is_add;
4519 clib_memcpy(mp->low_address, &lo, sizeof (mp->low_address));
4520 clib_memcpy(mp->hi_address, &hi, sizeof (mp->hi_address));
4527 static int api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
4529 unformat_input_t * i = vam->input;
4530 vl_api_proxy_arp_intfc_enable_disable_t *mp;
4534 u8 sw_if_index_set = 0;
4536 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4537 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4538 sw_if_index_set = 1;
4539 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4540 sw_if_index_set = 1;
4541 else if (unformat (i, "enable"))
4543 else if (unformat (i, "disable"))
4546 clib_warning ("parse error '%U'", format_unformat_error, i);
4551 if (sw_if_index_set == 0) {
4552 errmsg ("missing interface name or sw_if_index\n");
4556 M(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
4558 mp->sw_if_index = ntohl(sw_if_index);
4559 mp->enable_disable = enable;
4566 static int api_mpls_add_del_decap (vat_main_t * vam)
4568 unformat_input_t * i = vam->input;
4569 vl_api_mpls_add_del_decap_t *mp;
4578 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4579 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4581 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
4583 else if (unformat (i, "label %d", &label))
4585 else if (unformat (i, "next-index %d", &next_index))
4587 else if (unformat (i, "del"))
4589 else if (unformat (i, "s-bit-clear"))
4592 clib_warning ("parse error '%U'", format_unformat_error, i);
4597 M(MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
4599 mp->rx_vrf_id = ntohl(rx_vrf_id);
4600 mp->tx_vrf_id = ntohl(tx_vrf_id);
4601 mp->label = ntohl(label);
4602 mp->next_index = ntohl(next_index);
4604 mp->is_add = is_add;
4611 static int api_mpls_add_del_encap (vat_main_t * vam)
4613 unformat_input_t * i = vam->input;
4614 vl_api_mpls_add_del_encap_t *mp;
4619 ip4_address_t dst_address;
4622 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4623 if (unformat (i, "vrf %d", &vrf_id))
4625 else if (unformat (i, "label %d", &label))
4626 vec_add1 (labels, ntohl(label));
4627 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4629 else if (unformat (i, "del"))
4632 clib_warning ("parse error '%U'", format_unformat_error, i);
4637 if (vec_len (labels) == 0) {
4638 errmsg ("missing encap label stack\n");
4642 M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
4643 sizeof (u32) * vec_len (labels));
4645 mp->vrf_id = ntohl(vrf_id);
4646 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4647 mp->is_add = is_add;
4648 mp->nlabels = vec_len (labels);
4649 clib_memcpy(mp->labels, labels, sizeof(u32)*mp->nlabels);
4658 static int api_mpls_gre_add_del_tunnel (vat_main_t * vam)
4660 unformat_input_t * i = vam->input;
4661 vl_api_mpls_gre_add_del_tunnel_t *mp;
4663 u32 inner_vrf_id = 0;
4664 u32 outer_vrf_id = 0;
4665 ip4_address_t src_address;
4666 ip4_address_t dst_address;
4667 ip4_address_t intfc_address;
4669 u8 intfc_address_length = 0;
4673 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4674 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4676 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4678 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
4680 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4682 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4683 &intfc_address, &tmp))
4684 intfc_address_length = tmp;
4685 else if (unformat (i, "l2-only"))
4687 else if (unformat (i, "del"))
4690 clib_warning ("parse error '%U'", format_unformat_error, i);
4695 M(MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
4697 mp->inner_vrf_id = ntohl(inner_vrf_id);
4698 mp->outer_vrf_id = ntohl(outer_vrf_id);
4699 clib_memcpy(mp->src_address, &src_address, sizeof (src_address));
4700 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4701 clib_memcpy(mp->intfc_address, &intfc_address, sizeof (intfc_address));
4702 mp->intfc_address_length = intfc_address_length;
4703 mp->l2_only = l2_only;
4704 mp->is_add = is_add;
4711 static int api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
4713 unformat_input_t * i = vam->input;
4714 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
4716 u32 inner_vrf_id = 0;
4717 ip4_address_t intfc_address;
4718 u8 dst_mac_address[6];
4721 u8 intfc_address_length = 0;
4725 int tx_sw_if_index_set = 0;
4727 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4728 if (unformat (i, "vrf %d", &inner_vrf_id))
4730 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4731 &intfc_address, &tmp))
4732 intfc_address_length = tmp;
4733 else if (unformat (i, "%U",
4734 unformat_sw_if_index, vam, &tx_sw_if_index))
4735 tx_sw_if_index_set = 1;
4736 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4737 tx_sw_if_index_set = 1;
4738 else if (unformat (i, "dst %U", unformat_ethernet_address,
4741 else if (unformat (i, "l2-only"))
4743 else if (unformat (i, "del"))
4746 clib_warning ("parse error '%U'", format_unformat_error, i);
4752 errmsg ("dst (mac address) not set\n");
4755 if (!tx_sw_if_index_set) {
4756 errmsg ("tx-intfc not set\n");
4760 M(MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
4762 mp->vrf_id = ntohl(inner_vrf_id);
4763 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
4764 mp->adj_address_length = intfc_address_length;
4765 clib_memcpy (mp->dst_mac_address, dst_mac_address, sizeof (dst_mac_address));
4766 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
4767 mp->l2_only = l2_only;
4768 mp->is_add = is_add;
4775 static int api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
4777 unformat_input_t * i = vam->input;
4778 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
4780 u32 inner_vrf_id = 0;
4781 u32 outer_vrf_id = 0;
4782 ip4_address_t adj_address;
4783 int adj_address_set = 0;
4784 ip4_address_t next_hop_address;
4785 int next_hop_address_set = 0;
4787 u8 adj_address_length = 0;
4790 u32 resolve_attempts = 5;
4791 u8 resolve_if_needed = 1;
4793 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4794 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4796 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4798 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4799 &adj_address, &tmp)) {
4800 adj_address_length = tmp;
4801 adj_address_set = 1;
4803 else if (unformat (i, "next-hop %U", unformat_ip4_address,
4805 next_hop_address_set = 1;
4806 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4808 else if (unformat (i, "resolve-if-needed %d", &tmp))
4809 resolve_if_needed = tmp;
4810 else if (unformat (i, "l2-only"))
4812 else if (unformat (i, "del"))
4815 clib_warning ("parse error '%U'", format_unformat_error, i);
4820 if (!adj_address_set) {
4821 errmsg ("adjacency address/mask not set\n");
4824 if (!next_hop_address_set) {
4825 errmsg ("ip4 next hop address (in outer fib) not set\n");
4829 M(MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
4831 mp->inner_vrf_id = ntohl(inner_vrf_id);
4832 mp->outer_vrf_id = ntohl(outer_vrf_id);
4833 mp->resolve_attempts = ntohl(resolve_attempts);
4834 mp->resolve_if_needed = resolve_if_needed;
4835 mp->is_add = is_add;
4836 mp->l2_only = l2_only;
4837 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
4838 mp->adj_address_length = adj_address_length;
4839 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
4840 sizeof (next_hop_address));
4847 static int api_sw_interface_set_unnumbered (vat_main_t * vam)
4849 unformat_input_t * i = vam->input;
4850 vl_api_sw_interface_set_unnumbered_t *mp;
4855 u8 sw_if_index_set = 0;
4857 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4858 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4859 sw_if_index_set = 1;
4860 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4861 sw_if_index_set = 1;
4862 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4864 else if (unformat (i, "del"))
4867 clib_warning ("parse error '%U'", format_unformat_error, i);
4872 if (sw_if_index_set == 0) {
4873 errmsg ("missing interface name or sw_if_index\n");
4877 M(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
4879 mp->sw_if_index = ntohl(sw_if_index);
4880 mp->unnumbered_sw_if_index = ntohl(unnum_sw_index);
4881 mp->is_add = is_add;
4888 static int api_ip_neighbor_add_del (vat_main_t * vam)
4890 unformat_input_t * i = vam->input;
4891 vl_api_ip_neighbor_add_del_t *mp;
4894 u8 sw_if_index_set = 0;
4900 u8 v4_address_set = 0;
4901 u8 v6_address_set = 0;
4902 ip4_address_t v4address;
4903 ip6_address_t v6address;
4905 memset (mac_address, 0, sizeof (mac_address));
4907 /* Parse args required to build the message */
4908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4909 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4912 else if (unformat (i, "del"))
4914 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4915 sw_if_index_set = 1;
4916 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4917 sw_if_index_set = 1;
4918 else if (unformat (i, "is_static"))
4920 else if (unformat (i, "vrf %d", &vrf_id))
4922 else if (unformat (i, "dst %U",
4923 unformat_ip4_address, &v4address))
4925 else if (unformat (i, "dst %U",
4926 unformat_ip6_address, &v6address))
4929 clib_warning ("parse error '%U'", format_unformat_error, i);
4934 if (sw_if_index_set == 0) {
4935 errmsg ("missing interface name or sw_if_index\n");
4938 if (v4_address_set && v6_address_set) {
4939 errmsg ("both v4 and v6 addresses set\n");
4942 if (!v4_address_set && !v6_address_set) {
4943 errmsg ("no addresses set\n");
4947 /* Construct the API message */
4948 M(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
4950 mp->sw_if_index = ntohl (sw_if_index);
4951 mp->is_add = is_add;
4952 mp->vrf_id = ntohl (vrf_id);
4953 mp->is_static = is_static;
4955 clib_memcpy (mp->mac_address, mac_address, 6);
4956 if (v6_address_set) {
4958 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
4960 /* mp->is_ipv6 = 0; via memset in M macro above */
4961 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
4967 /* Wait for a reply, return good/bad news */
4974 static int api_reset_vrf (vat_main_t * vam)
4976 unformat_input_t * i = vam->input;
4977 vl_api_reset_vrf_t *mp;
4983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4984 if (unformat (i, "vrf %d", &vrf_id))
4986 else if (unformat (i, "ipv6"))
4989 clib_warning ("parse error '%U'", format_unformat_error, i);
4994 if (vrf_id_set == 0) {
4995 errmsg ("missing vrf id\n");
4999 M(RESET_VRF, reset_vrf);
5001 mp->vrf_id = ntohl(vrf_id);
5002 mp->is_ipv6 = is_ipv6;
5009 static int api_create_vlan_subif (vat_main_t * vam)
5011 unformat_input_t * i = vam->input;
5012 vl_api_create_vlan_subif_t *mp;
5015 u8 sw_if_index_set = 0;
5019 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5020 if (unformat (i, "sw_if_index %d", &sw_if_index))
5021 sw_if_index_set = 1;
5022 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5023 sw_if_index_set = 1;
5024 else if (unformat (i, "vlan %d", &vlan_id))
5027 clib_warning ("parse error '%U'", format_unformat_error, i);
5032 if (sw_if_index_set == 0) {
5033 errmsg ("missing interface name or sw_if_index\n");
5037 if (vlan_id_set == 0) {
5038 errmsg ("missing vlan_id\n");
5041 M(CREATE_VLAN_SUBIF, create_vlan_subif);
5043 mp->sw_if_index = ntohl(sw_if_index);
5044 mp->vlan_id = ntohl(vlan_id);
5051 #define foreach_create_subif_bit \
5058 _(outer_vlan_id_any) \
5059 _(inner_vlan_id_any)
5061 static int api_create_subif (vat_main_t * vam)
5063 unformat_input_t * i = vam->input;
5064 vl_api_create_subif_t *mp;
5067 u8 sw_if_index_set = 0;
5074 u32 exact_match = 0;
5075 u32 default_sub = 0;
5076 u32 outer_vlan_id_any = 0;
5077 u32 inner_vlan_id_any = 0;
5079 u16 outer_vlan_id = 0;
5080 u16 inner_vlan_id = 0;
5082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5083 if (unformat (i, "sw_if_index %d", &sw_if_index))
5084 sw_if_index_set = 1;
5085 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5086 sw_if_index_set = 1;
5087 else if (unformat (i, "sub_id %d", &sub_id))
5089 else if (unformat (i, "outer_vlan_id %d", &tmp))
5090 outer_vlan_id = tmp;
5091 else if (unformat (i, "inner_vlan_id %d", &tmp))
5092 inner_vlan_id = tmp;
5094 #define _(a) else if (unformat (i, #a)) a = 1 ;
5095 foreach_create_subif_bit
5099 clib_warning ("parse error '%U'", format_unformat_error, i);
5104 if (sw_if_index_set == 0) {
5105 errmsg ("missing interface name or sw_if_index\n");
5109 if (sub_id_set == 0) {
5110 errmsg ("missing sub_id\n");
5113 M(CREATE_SUBIF, create_subif);
5115 mp->sw_if_index = ntohl(sw_if_index);
5116 mp->sub_id = ntohl(sub_id);
5118 #define _(a) mp->a = a;
5119 foreach_create_subif_bit;
5122 mp->outer_vlan_id = ntohs (outer_vlan_id);
5123 mp->inner_vlan_id = ntohs (inner_vlan_id);
5130 static int api_oam_add_del (vat_main_t * vam)
5132 unformat_input_t * i = vam->input;
5133 vl_api_oam_add_del_t *mp;
5137 ip4_address_t src, dst;
5141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5142 if (unformat (i, "vrf %d", &vrf_id))
5144 else if (unformat (i, "src %U", unformat_ip4_address, &src))
5146 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
5148 else if (unformat (i, "del"))
5151 clib_warning ("parse error '%U'", format_unformat_error, i);
5157 errmsg ("missing src addr\n");
5162 errmsg ("missing dst addr\n");
5166 M(OAM_ADD_DEL, oam_add_del);
5168 mp->vrf_id = ntohl(vrf_id);
5169 mp->is_add = is_add;
5170 clib_memcpy(mp->src_address, &src, sizeof (mp->src_address));
5171 clib_memcpy(mp->dst_address, &dst, sizeof (mp->dst_address));
5178 static int api_reset_fib (vat_main_t * vam)
5180 unformat_input_t * i = vam->input;
5181 vl_api_reset_fib_t *mp;
5187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5188 if (unformat (i, "vrf %d", &vrf_id))
5190 else if (unformat (i, "ipv6"))
5193 clib_warning ("parse error '%U'", format_unformat_error, i);
5198 if (vrf_id_set == 0) {
5199 errmsg ("missing vrf id\n");
5203 M(RESET_FIB, reset_fib);
5205 mp->vrf_id = ntohl(vrf_id);
5206 mp->is_ipv6 = is_ipv6;
5213 static int api_dhcp_proxy_config (vat_main_t * vam)
5215 unformat_input_t * i = vam->input;
5216 vl_api_dhcp_proxy_config_t *mp;
5221 u8 v4_address_set = 0;
5222 u8 v6_address_set = 0;
5223 ip4_address_t v4address;
5224 ip6_address_t v6address;
5225 u8 v4_src_address_set = 0;
5226 u8 v6_src_address_set = 0;
5227 ip4_address_t v4srcaddress;
5228 ip6_address_t v6srcaddress;
5230 /* Parse args required to build the message */
5231 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5232 if (unformat (i, "del"))
5234 else if (unformat (i, "vrf %d", &vrf_id))
5236 else if (unformat (i, "insert-cid %d", &insert_cid))
5238 else if (unformat (i, "svr %U",
5239 unformat_ip4_address, &v4address))
5241 else if (unformat (i, "svr %U",
5242 unformat_ip6_address, &v6address))
5244 else if (unformat (i, "src %U",
5245 unformat_ip4_address, &v4srcaddress))
5246 v4_src_address_set = 1;
5247 else if (unformat (i, "src %U",
5248 unformat_ip6_address, &v6srcaddress))
5249 v6_src_address_set = 1;
5254 if (v4_address_set && v6_address_set) {
5255 errmsg ("both v4 and v6 server addresses set\n");
5258 if (!v4_address_set && !v6_address_set) {
5259 errmsg ("no server addresses set\n");
5263 if (v4_src_address_set && v6_src_address_set) {
5264 errmsg ("both v4 and v6 src addresses set\n");
5267 if (!v4_src_address_set && !v6_src_address_set) {
5268 errmsg ("no src addresses set\n");
5272 if (!(v4_src_address_set && v4_address_set) &&
5273 !(v6_src_address_set && v6_address_set)) {
5274 errmsg ("no matching server and src addresses set\n");
5278 /* Construct the API message */
5279 M(DHCP_PROXY_CONFIG, dhcp_proxy_config);
5281 mp->insert_circuit_id = insert_cid;
5282 mp->is_add = is_add;
5283 mp->vrf_id = ntohl (vrf_id);
5284 if (v6_address_set) {
5286 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5287 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5289 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5290 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5296 /* Wait for a reply, return good/bad news */
5302 static int api_dhcp_proxy_config_2 (vat_main_t * vam)
5304 unformat_input_t * i = vam->input;
5305 vl_api_dhcp_proxy_config_2_t *mp;
5308 u32 server_vrf_id = 0;
5311 u8 v4_address_set = 0;
5312 u8 v6_address_set = 0;
5313 ip4_address_t v4address;
5314 ip6_address_t v6address;
5315 u8 v4_src_address_set = 0;
5316 u8 v6_src_address_set = 0;
5317 ip4_address_t v4srcaddress;
5318 ip6_address_t v6srcaddress;
5320 /* Parse args required to build the message */
5321 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5322 if (unformat (i, "del"))
5324 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5326 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
5328 else if (unformat (i, "insert-cid %d", &insert_cid))
5330 else if (unformat (i, "svr %U",
5331 unformat_ip4_address, &v4address))
5333 else if (unformat (i, "svr %U",
5334 unformat_ip6_address, &v6address))
5336 else if (unformat (i, "src %U",
5337 unformat_ip4_address, &v4srcaddress))
5338 v4_src_address_set = 1;
5339 else if (unformat (i, "src %U",
5340 unformat_ip6_address, &v6srcaddress))
5341 v6_src_address_set = 1;
5346 if (v4_address_set && v6_address_set) {
5347 errmsg ("both v4 and v6 server addresses set\n");
5350 if (!v4_address_set && !v6_address_set) {
5351 errmsg ("no server addresses set\n");
5355 if (v4_src_address_set && v6_src_address_set) {
5356 errmsg ("both v4 and v6 src addresses set\n");
5359 if (!v4_src_address_set && !v6_src_address_set) {
5360 errmsg ("no src addresses set\n");
5364 if (!(v4_src_address_set && v4_address_set) &&
5365 !(v6_src_address_set && v6_address_set)) {
5366 errmsg ("no matching server and src addresses set\n");
5370 /* Construct the API message */
5371 M(DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
5373 mp->insert_circuit_id = insert_cid;
5374 mp->is_add = is_add;
5375 mp->rx_vrf_id = ntohl (rx_vrf_id);
5376 mp->server_vrf_id = ntohl (server_vrf_id);
5377 if (v6_address_set) {
5379 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5380 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5382 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5383 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5389 /* Wait for a reply, return good/bad news */
5395 static int api_dhcp_proxy_set_vss (vat_main_t * vam)
5397 unformat_input_t * i = vam->input;
5398 vl_api_dhcp_proxy_set_vss_t *mp;
5409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5410 if (unformat (i, "tbl_id %d", &tbl_id))
5412 if (unformat (i, "fib_id %d", &fib_id))
5414 if (unformat (i, "oui %d", &oui))
5416 else if (unformat (i, "ipv6"))
5418 else if (unformat (i, "del"))
5421 clib_warning ("parse error '%U'", format_unformat_error, i);
5426 if (tbl_id_set == 0) {
5427 errmsg ("missing tbl id\n");
5431 if (fib_id_set == 0) {
5432 errmsg ("missing fib id\n");
5436 errmsg ("missing oui\n");
5440 M(DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
5441 mp->tbl_id = ntohl(tbl_id);
5442 mp->fib_id = ntohl(fib_id);
5443 mp->oui = ntohl(oui);
5444 mp->is_ipv6 = is_ipv6;
5445 mp->is_add = is_add;
5452 static int api_dhcp_client_config (vat_main_t * vam)
5454 unformat_input_t * i = vam->input;
5455 vl_api_dhcp_client_config_t *mp;
5458 u8 sw_if_index_set = 0;
5461 u8 disable_event = 0;
5463 /* Parse args required to build the message */
5464 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5465 if (unformat (i, "del"))
5467 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5468 sw_if_index_set = 1;
5469 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5470 sw_if_index_set = 1;
5471 else if (unformat (i, "hostname %s", &hostname))
5473 else if (unformat (i, "disable_event"))
5479 if (sw_if_index_set == 0) {
5480 errmsg ("missing interface name or sw_if_index\n");
5484 if (vec_len (hostname) > 63) {
5485 errmsg ("hostname too long\n");
5487 vec_add1 (hostname, 0);
5489 /* Construct the API message */
5490 M(DHCP_CLIENT_CONFIG, dhcp_client_config);
5492 mp->sw_if_index = ntohl (sw_if_index);
5493 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
5494 vec_free (hostname);
5495 mp->is_add = is_add;
5496 mp->want_dhcp_event = disable_event ? 0 : 1;
5502 /* Wait for a reply, return good/bad news */
5508 static int api_set_ip_flow_hash (vat_main_t * vam)
5510 unformat_input_t * i = vam->input;
5511 vl_api_set_ip_flow_hash_t *mp;
5523 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5524 if (unformat (i, "vrf %d", &vrf_id))
5526 else if (unformat (i, "ipv6"))
5528 else if (unformat (i, "src"))
5530 else if (unformat (i, "dst"))
5532 else if (unformat (i, "sport"))
5534 else if (unformat (i, "dport"))
5536 else if (unformat (i, "proto"))
5538 else if (unformat (i, "reverse"))
5542 clib_warning ("parse error '%U'", format_unformat_error, i);
5547 if (vrf_id_set == 0) {
5548 errmsg ("missing vrf id\n");
5552 M(SET_IP_FLOW_HASH, set_ip_flow_hash);
5558 mp->reverse = reverse;
5559 mp->vrf_id = ntohl(vrf_id);
5560 mp->is_ipv6 = is_ipv6;
5567 static int api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5569 unformat_input_t * i = vam->input;
5570 vl_api_sw_interface_ip6_enable_disable_t *mp;
5573 u8 sw_if_index_set = 0;
5576 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5577 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5578 sw_if_index_set = 1;
5579 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5580 sw_if_index_set = 1;
5581 else if (unformat (i, "enable"))
5583 else if (unformat (i, "disable"))
5586 clib_warning ("parse error '%U'", format_unformat_error, i);
5591 if (sw_if_index_set == 0) {
5592 errmsg ("missing interface name or sw_if_index\n");
5596 M(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
5598 mp->sw_if_index = ntohl(sw_if_index);
5599 mp->enable = enable;
5606 static int api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
5608 unformat_input_t * i = vam->input;
5609 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
5612 u8 sw_if_index_set = 0;
5613 u32 address_length = 0;
5614 u8 v6_address_set = 0;
5615 ip6_address_t v6address;
5617 /* Parse args required to build the message */
5618 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5619 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5620 sw_if_index_set = 1;
5621 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5622 sw_if_index_set = 1;
5623 else if (unformat (i, "%U/%d",
5624 unformat_ip6_address, &v6address,
5631 if (sw_if_index_set == 0) {
5632 errmsg ("missing interface name or sw_if_index\n");
5635 if (!v6_address_set) {
5636 errmsg ("no address set\n");
5640 /* Construct the API message */
5641 M(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \
5642 sw_interface_ip6_set_link_local_address);
5644 mp->sw_if_index = ntohl (sw_if_index);
5645 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5646 mp->address_length = address_length;
5651 /* Wait for a reply, return good/bad news */
5659 static int api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
5661 unformat_input_t * i = vam->input;
5662 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
5665 u8 sw_if_index_set = 0;
5666 u32 address_length = 0;
5667 u8 v6_address_set = 0;
5668 ip6_address_t v6address;
5670 u8 no_advertise = 0;
5672 u8 no_autoconfig = 0;
5675 u32 val_lifetime = 0;
5676 u32 pref_lifetime = 0;
5678 /* Parse args required to build the message */
5679 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5680 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5681 sw_if_index_set = 1;
5682 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5683 sw_if_index_set = 1;
5684 else if (unformat (i, "%U/%d",
5685 unformat_ip6_address, &v6address,
5688 else if (unformat (i, "val_life %d", &val_lifetime))
5690 else if (unformat (i, "pref_life %d", &pref_lifetime))
5692 else if (unformat (i, "def"))
5694 else if (unformat (i, "noadv"))
5696 else if (unformat (i, "offl"))
5698 else if (unformat (i, "noauto"))
5700 else if (unformat (i, "nolink"))
5702 else if (unformat (i, "isno"))
5705 clib_warning ("parse error '%U'", format_unformat_error, i);
5710 if (sw_if_index_set == 0) {
5711 errmsg ("missing interface name or sw_if_index\n");
5714 if (!v6_address_set) {
5715 errmsg ("no address set\n");
5719 /* Construct the API message */
5720 M(SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
5722 mp->sw_if_index = ntohl (sw_if_index);
5723 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5724 mp->address_length = address_length;
5725 mp->use_default = use_default;
5726 mp->no_advertise = no_advertise;
5727 mp->off_link = off_link;
5728 mp->no_autoconfig = no_autoconfig;
5729 mp->no_onlink = no_onlink;
5731 mp->val_lifetime = ntohl(val_lifetime);
5732 mp->pref_lifetime = ntohl(pref_lifetime);
5737 /* Wait for a reply, return good/bad news */
5744 static int api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
5746 unformat_input_t * i = vam->input;
5747 vl_api_sw_interface_ip6nd_ra_config_t *mp;
5750 u8 sw_if_index_set = 0;
5755 u8 send_unicast = 0;
5758 u8 default_router = 0;
5759 u32 max_interval = 0;
5760 u32 min_interval = 0;
5762 u32 initial_count = 0;
5763 u32 initial_interval = 0;
5766 /* Parse args required to build the message */
5767 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5768 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5769 sw_if_index_set = 1;
5770 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5771 sw_if_index_set = 1;
5772 else if (unformat (i, "maxint %d", &max_interval))
5774 else if (unformat (i, "minint %d", &min_interval))
5776 else if (unformat (i, "life %d", &lifetime))
5778 else if (unformat (i, "count %d", &initial_count))
5780 else if (unformat (i, "interval %d", &initial_interval))
5782 else if (unformat (i, "suppress") || unformat (i, "surpress"))
5784 else if (unformat (i, "managed"))
5786 else if (unformat (i, "other"))
5788 else if (unformat (i, "ll"))
5790 else if (unformat (i, "send"))
5792 else if (unformat (i, "cease"))
5794 else if (unformat (i, "isno"))
5796 else if (unformat (i, "def"))
5799 clib_warning ("parse error '%U'", format_unformat_error, i);
5804 if (sw_if_index_set == 0) {
5805 errmsg ("missing interface name or sw_if_index\n");
5809 /* Construct the API message */
5810 M(SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
5812 mp->sw_if_index = ntohl (sw_if_index);
5813 mp->max_interval = ntohl(max_interval);
5814 mp->min_interval = ntohl(min_interval);
5815 mp->lifetime = ntohl(lifetime);
5816 mp->initial_count = ntohl(initial_count);
5817 mp->initial_interval = ntohl(initial_interval);
5818 mp->suppress = suppress;
5819 mp->managed = managed;
5821 mp->ll_option = ll_option;
5822 mp->send_unicast = send_unicast;
5825 mp->default_router = default_router;
5830 /* Wait for a reply, return good/bad news */
5837 static int api_set_arp_neighbor_limit (vat_main_t * vam)
5839 unformat_input_t * i = vam->input;
5840 vl_api_set_arp_neighbor_limit_t *mp;
5846 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5847 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
5849 else if (unformat (i, "ipv6"))
5852 clib_warning ("parse error '%U'", format_unformat_error, i);
5857 if (limit_set == 0) {
5858 errmsg ("missing limit value\n");
5862 M(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
5864 mp->arp_neighbor_limit = ntohl(arp_nbr_limit);
5865 mp->is_ipv6 = is_ipv6;
5872 static int api_l2_patch_add_del (vat_main_t * vam)
5874 unformat_input_t * i = vam->input;
5875 vl_api_l2_patch_add_del_t *mp;
5878 u8 rx_sw_if_index_set = 0;
5880 u8 tx_sw_if_index_set = 0;
5883 /* Parse args required to build the message */
5884 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5885 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5886 rx_sw_if_index_set = 1;
5887 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5888 tx_sw_if_index_set = 1;
5889 else if (unformat (i, "rx")) {
5890 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5891 if (unformat (i, "%U", unformat_sw_if_index, vam,
5893 rx_sw_if_index_set = 1;
5896 } else if (unformat (i, "tx")) {
5897 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5898 if (unformat (i, "%U", unformat_sw_if_index, vam,
5900 tx_sw_if_index_set = 1;
5903 } else if (unformat (i, "del"))
5909 if (rx_sw_if_index_set == 0) {
5910 errmsg ("missing rx interface name or rx_sw_if_index\n");
5914 if (tx_sw_if_index_set == 0) {
5915 errmsg ("missing tx interface name or tx_sw_if_index\n");
5919 M(L2_PATCH_ADD_DEL, l2_patch_add_del);
5921 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
5922 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
5923 mp->is_add = is_add;
5929 static int api_trace_profile_add (vat_main_t *vam)
5931 unformat_input_t * input = vam->input;
5932 vl_api_trace_profile_add_t *mp;
5935 u32 trace_option_elts = 0;
5936 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
5937 int has_pow_option = 0;
5938 int has_ppc_option = 0;
5940 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5942 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
5943 "trace-tsp %d node-id 0x%x app-data 0x%x",
5944 &id, &trace_type, &trace_option_elts, &trace_tsp,
5945 &node_id, &app_data))
5947 else if (unformat (input, "pow"))
5949 else if (unformat (input, "ppc encap"))
5950 has_ppc_option = PPC_ENCAP;
5951 else if (unformat (input, "ppc decap"))
5952 has_ppc_option = PPC_DECAP;
5953 else if (unformat (input, "ppc none"))
5954 has_ppc_option = PPC_NONE;
5958 M(TRACE_PROFILE_ADD, trace_profile_add);
5960 mp->trace_type = trace_type;
5961 mp->trace_num_elt = trace_option_elts;
5962 mp->trace_ppc = has_ppc_option;
5963 mp->trace_app_data = htonl(app_data);
5964 mp->pow_enable = has_pow_option;
5965 mp->trace_tsp = trace_tsp;
5966 mp->node_id = htonl(node_id);
5973 static int api_trace_profile_apply (vat_main_t *vam)
5975 unformat_input_t * input = vam->input;
5976 vl_api_trace_profile_apply_t *mp;
5979 u32 mask_width = ~0;
5986 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5988 if (unformat (input, "%U/%d",
5989 unformat_ip6_address, &addr, &mask_width))
5991 else if (unformat (input, "id %d", &id))
5993 else if (unformat (input, "vrf-id %d", &vrf_id))
5995 else if (unformat (input, "add"))
5997 else if (unformat (input, "pop"))
5999 else if (unformat (input, "none"))
6005 if ((is_add + is_pop + is_none) != 1) {
6006 errmsg("One of (add, pop, none) required");
6009 if (mask_width == ~0) {
6010 errmsg("<address>/<mask-width> required");
6013 M(TRACE_PROFILE_APPLY, trace_profile_apply);
6014 clib_memcpy(mp->dest_ipv6, &addr, sizeof(mp->dest_ipv6));
6016 mp->prefix_length = htonl(mask_width);
6017 mp->vrf_id = htonl(vrf_id);
6019 mp->trace_op = IOAM_HBYH_ADD;
6021 mp->trace_op = IOAM_HBYH_POP;
6023 mp->trace_op = IOAM_HBYH_MOD;
6035 static int api_trace_profile_del (vat_main_t *vam)
6037 vl_api_trace_profile_del_t *mp;
6040 M(TRACE_PROFILE_DEL, trace_profile_del);
6045 static int api_sr_tunnel_add_del (vat_main_t * vam)
6047 unformat_input_t * i = vam->input;
6048 vl_api_sr_tunnel_add_del_t *mp;
6052 ip6_address_t src_address;
6053 int src_address_set = 0;
6054 ip6_address_t dst_address;
6056 int dst_address_set = 0;
6058 u32 rx_table_id = 0;
6059 u32 tx_table_id = 0;
6060 ip6_address_t * segments = 0;
6061 ip6_address_t * this_seg;
6062 ip6_address_t * tags = 0;
6063 ip6_address_t * this_tag;
6064 ip6_address_t next_address, tag;
6066 u8 * policy_name = 0;
6068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6070 if (unformat (i, "del"))
6072 else if (unformat (i, "name %s", &name))
6074 else if (unformat (i, "policy %s", &policy_name))
6076 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
6078 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
6080 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
6081 src_address_set = 1;
6082 else if (unformat (i, "dst %U/%d",
6083 unformat_ip6_address, &dst_address,
6085 dst_address_set = 1;
6086 else if (unformat (i, "next %U", unformat_ip6_address,
6089 vec_add2 (segments, this_seg, 1);
6090 clib_memcpy (this_seg->as_u8, next_address.as_u8, sizeof (*this_seg));
6092 else if (unformat (i, "tag %U", unformat_ip6_address,
6095 vec_add2 (tags, this_tag, 1);
6096 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
6098 else if (unformat (i, "clean"))
6099 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
6100 else if (unformat (i, "protected"))
6101 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
6102 else if (unformat (i, "InPE %d", &pl_index))
6104 if (pl_index <= 0 || pl_index > 4)
6106 pl_index_range_error:
6107 errmsg ("pl index %d out of range\n", pl_index);
6110 flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3*(pl_index - 1));
6112 else if (unformat (i, "EgPE %d", &pl_index))
6114 if (pl_index <= 0 || pl_index > 4)
6115 goto pl_index_range_error;
6116 flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3*(pl_index - 1));
6118 else if (unformat (i, "OrgSrc %d", &pl_index))
6120 if (pl_index <= 0 || pl_index > 4)
6121 goto pl_index_range_error;
6122 flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3*(pl_index - 1));
6128 if (!src_address_set)
6130 errmsg ("src address required\n");
6134 if (!dst_address_set)
6136 errmsg ("dst address required\n");
6142 errmsg ("at least one sr segment required\n");
6146 M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
6147 vec_len(segments) * sizeof (ip6_address_t)
6148 + vec_len(tags) * sizeof (ip6_address_t));
6150 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
6151 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
6152 mp->dst_mask_width = dst_mask_width;
6153 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
6154 mp->n_segments = vec_len (segments);
6155 mp->n_tags = vec_len (tags);
6156 mp->is_add = is_del == 0;
6157 clib_memcpy (mp->segs_and_tags, segments,
6158 vec_len(segments)* sizeof (ip6_address_t));
6159 clib_memcpy (mp->segs_and_tags + vec_len(segments)*sizeof (ip6_address_t),
6160 tags, vec_len(tags)* sizeof (ip6_address_t));
6162 mp->outer_vrf_id = ntohl (rx_table_id);
6163 mp->inner_vrf_id = ntohl (tx_table_id);
6164 memcpy (mp->name, name, vec_len(name));
6165 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
6167 vec_free (segments);
6174 static int api_sr_policy_add_del (vat_main_t * vam)
6176 unformat_input_t * input = vam->input;
6177 vl_api_sr_policy_add_del_t *mp;
6181 u8 * tunnel_name = 0;
6182 u8 ** tunnel_names = 0;
6187 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
6188 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
6190 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6192 if (unformat (input, "del"))
6194 else if (unformat (input, "name %s", &name))
6196 else if (unformat (input, "tunnel %s", &tunnel_name))
6200 vec_add1 (tunnel_names, tunnel_name);
6202 - length = #bytes to store in serial vector
6203 - +1 = byte to store that length
6205 tunnel_names_length += (vec_len (tunnel_name) + 1);
6216 errmsg ("policy name required\n");
6220 if ((!tunnel_set) && (!is_del))
6222 errmsg ("tunnel name required\n");
6226 M2(SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
6230 mp->is_add = !is_del;
6232 memcpy (mp->name, name, vec_len(name));
6233 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
6234 u8 * serial_orig = 0;
6235 vec_validate (serial_orig, tunnel_names_length);
6236 *serial_orig = vec_len(tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
6237 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
6239 for (j=0; j < vec_len(tunnel_names); j++)
6241 tun_name_len = vec_len (tunnel_names[j]);
6242 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
6243 serial_orig += 1; // Move along one byte to store the actual tunnel name
6244 memcpy (serial_orig, tunnel_names[j], tun_name_len);
6245 serial_orig += tun_name_len; // Advance past the copy
6247 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
6249 vec_free (tunnel_names);
6250 vec_free (tunnel_name);
6256 static int api_sr_multicast_map_add_del (vat_main_t * vam)
6258 unformat_input_t * input = vam->input;
6259 vl_api_sr_multicast_map_add_del_t *mp;
6262 ip6_address_t multicast_address;
6263 u8 * policy_name = 0;
6264 int multicast_address_set = 0;
6266 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6268 if (unformat (input, "del"))
6270 else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address))
6271 multicast_address_set = 1;
6272 else if (unformat (input, "sr-policy %s", &policy_name))
6278 if (!is_del && !policy_name)
6280 errmsg ("sr-policy name required\n");
6285 if (!multicast_address_set)
6287 errmsg ("address required\n");
6291 M(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
6293 mp->is_add = !is_del;
6294 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
6295 clib_memcpy (mp->multicast_address, &multicast_address, sizeof (mp->multicast_address));
6298 vec_free (policy_name);
6305 #define foreach_ip4_proto_field \
6315 uword unformat_ip4_mask (unformat_input_t * input, va_list * args)
6317 u8 ** maskp = va_arg (*args, u8 **);
6319 u8 found_something = 0;
6322 #define _(a) u8 a=0;
6323 foreach_ip4_proto_field;
6329 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6331 if (unformat (input, "version"))
6333 else if (unformat (input, "hdr_length"))
6335 else if (unformat (input, "src"))
6337 else if (unformat (input, "dst"))
6339 else if (unformat (input, "proto"))
6342 #define _(a) else if (unformat (input, #a)) a=1;
6343 foreach_ip4_proto_field
6349 #define _(a) found_something += a;
6350 foreach_ip4_proto_field;
6353 if (found_something == 0)
6356 vec_validate (mask, sizeof (*ip) - 1);
6358 ip = (ip4_header_t *) mask;
6360 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6361 foreach_ip4_proto_field;
6364 ip->ip_version_and_header_length = 0;
6367 ip->ip_version_and_header_length |= 0xF0;
6370 ip->ip_version_and_header_length |= 0x0F;
6376 #define foreach_ip6_proto_field \
6383 uword unformat_ip6_mask (unformat_input_t * input, va_list * args)
6385 u8 ** maskp = va_arg (*args, u8 **);
6387 u8 found_something = 0;
6389 u32 ip_version_traffic_class_and_flow_label;
6391 #define _(a) u8 a=0;
6392 foreach_ip6_proto_field;
6395 u8 traffic_class = 0;
6398 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6400 if (unformat (input, "version"))
6402 else if (unformat (input, "traffic-class"))
6404 else if (unformat (input, "flow-label"))
6406 else if (unformat (input, "src"))
6408 else if (unformat (input, "dst"))
6410 else if (unformat (input, "proto"))
6413 #define _(a) else if (unformat (input, #a)) a=1;
6414 foreach_ip6_proto_field
6420 #define _(a) found_something += a;
6421 foreach_ip6_proto_field;
6424 if (found_something == 0)
6427 vec_validate (mask, sizeof (*ip) - 1);
6429 ip = (ip6_header_t *) mask;
6431 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6432 foreach_ip6_proto_field;
6435 ip_version_traffic_class_and_flow_label = 0;
6438 ip_version_traffic_class_and_flow_label |= 0xF0000000;
6441 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
6444 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
6446 ip->ip_version_traffic_class_and_flow_label =
6447 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6453 uword unformat_l3_mask (unformat_input_t * input, va_list * args)
6455 u8 ** maskp = va_arg (*args, u8 **);
6457 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6458 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
6460 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
6468 uword unformat_l2_mask (unformat_input_t * input, va_list * args)
6470 u8 ** maskp = va_arg (*args, u8 **);
6485 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6486 if (unformat (input, "src"))
6488 else if (unformat (input, "dst"))
6490 else if (unformat (input, "proto"))
6492 else if (unformat (input, "tag1"))
6494 else if (unformat (input, "tag2"))
6496 else if (unformat (input, "ignore-tag1"))
6498 else if (unformat (input, "ignore-tag2"))
6500 else if (unformat (input, "cos1"))
6502 else if (unformat (input, "cos2"))
6504 else if (unformat (input, "dot1q"))
6506 else if (unformat (input, "dot1ad"))
6511 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
6512 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6515 if (tag1 || ignore_tag1 || cos1 || dot1q)
6517 if (tag2 || ignore_tag2 || cos2 || dot1ad)
6520 vec_validate (mask, len-1);
6523 memset (mask, 0xff, 6);
6526 memset (mask + 6, 0xff, 6);
6530 /* inner vlan tag */
6539 mask[21] = mask [20] = 0xff;
6560 mask[16] = mask [17] = 0xff;
6570 mask[12] = mask [13] = 0xff;
6576 uword unformat_classify_mask (unformat_input_t * input, va_list * args)
6578 u8 ** maskp = va_arg (*args, u8 **);
6579 u32 * skipp = va_arg (*args, u32 *);
6580 u32 * matchp = va_arg (*args, u32 *);
6587 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6588 if (unformat (input, "hex %U", unformat_hex_string, &mask))
6590 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
6592 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
6598 if (mask || l2 || l3)
6602 /* "With a free Ethernet header in every package" */
6604 vec_validate (l2, 13);
6606 vec_append (mask, l3);
6610 /* Scan forward looking for the first significant mask octet */
6611 for (i = 0; i < vec_len (mask); i++)
6615 /* compute (skip, match) params */
6616 *skipp = i / sizeof(u32x4);
6617 vec_delete (mask, *skipp * sizeof(u32x4), 0);
6619 /* Pad mask to an even multiple of the vector size */
6620 while (vec_len (mask) % sizeof (u32x4))
6623 match = vec_len (mask) / sizeof (u32x4);
6625 for (i = match*sizeof(u32x4); i > 0; i-= sizeof(u32x4))
6627 u64 *tmp = (u64 *)(mask + (i-sizeof(u32x4)));
6628 if (*tmp || *(tmp+1))
6633 clib_warning ("BUG: match 0");
6635 _vec_len (mask) = match * sizeof(u32x4);
6646 #define foreach_l2_next \
6648 _(ethernet, ETHERNET_INPUT) \
6652 uword unformat_l2_next_index (unformat_input_t * input, va_list * args)
6654 u32 * miss_next_indexp = va_arg (*args, u32 *);
6659 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
6663 if (unformat (input, "%d", &tmp))
6672 *miss_next_indexp = next_index;
6676 #define foreach_ip_next \
6682 uword unformat_ip_next_index (unformat_input_t * input, va_list * args)
6684 u32 * miss_next_indexp = va_arg (*args, u32 *);
6689 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
6693 if (unformat (input, "%d", &tmp))
6702 *miss_next_indexp = next_index;
6706 #define foreach_acl_next \
6709 uword unformat_acl_next_index (unformat_input_t * input, va_list * args)
6711 u32 * miss_next_indexp = va_arg (*args, u32 *);
6716 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
6720 if (unformat (input, "permit"))
6725 else if (unformat (input, "%d", &tmp))
6734 *miss_next_indexp = next_index;
6738 static int api_classify_add_del_table (vat_main_t * vam)
6740 unformat_input_t * i = vam->input;
6741 vl_api_classify_add_del_table_t *mp;
6747 u32 table_index = ~0;
6748 u32 next_table_index = ~0;
6749 u32 miss_next_index = ~0;
6750 u32 memory_size = 32<<20;
6754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6755 if (unformat (i, "del"))
6757 else if (unformat (i, "buckets %d", &nbuckets))
6759 else if (unformat (i, "memory_size %d", &memory_size))
6761 else if (unformat (i, "skip %d", &skip))
6763 else if (unformat (i, "match %d", &match))
6765 else if (unformat (i, "table %d", &table_index))
6767 else if (unformat (i, "mask %U", unformat_classify_mask,
6768 &mask, &skip, &match))
6770 else if (unformat (i, "next-table %d", &next_table_index))
6772 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
6775 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
6778 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
6785 if (is_add && mask == 0) {
6786 errmsg ("Mask required\n");
6790 if (is_add && skip == ~0) {
6791 errmsg ("skip count required\n");
6795 if (is_add && match == ~0) {
6796 errmsg ("match count required\n");
6800 if (!is_add && table_index == ~0) {
6801 errmsg ("table index required for delete\n");
6805 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table,
6808 mp->is_add = is_add;
6809 mp->table_index = ntohl(table_index);
6810 mp->nbuckets = ntohl(nbuckets);
6811 mp->memory_size = ntohl(memory_size);
6812 mp->skip_n_vectors = ntohl(skip);
6813 mp->match_n_vectors = ntohl(match);
6814 mp->next_table_index = ntohl(next_table_index);
6815 mp->miss_next_index = ntohl(miss_next_index);
6816 clib_memcpy (mp->mask, mask, vec_len(mask));
6824 uword unformat_ip4_match (unformat_input_t * input, va_list * args)
6826 u8 ** matchp = va_arg (*args, u8 **);
6833 int src = 0, dst = 0;
6834 ip4_address_t src_val, dst_val;
6841 int fragment_id = 0;
6842 u32 fragment_id_val;
6848 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6850 if (unformat (input, "version %d", &version_val))
6852 else if (unformat (input, "hdr_length %d", &hdr_length_val))
6854 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
6856 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
6858 else if (unformat (input, "proto %d", &proto_val))
6860 else if (unformat (input, "tos %d", &tos_val))
6862 else if (unformat (input, "length %d", &length_val))
6864 else if (unformat (input, "fragment_id %d", &fragment_id_val))
6866 else if (unformat (input, "ttl %d", &ttl_val))
6868 else if (unformat (input, "checksum %d", &checksum_val))
6874 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
6875 + ttl + checksum == 0)
6879 * Aligned because we use the real comparison functions
6881 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6883 ip = (ip4_header_t *) match;
6885 /* These are realistically matched in practice */
6887 ip->src_address.as_u32 = src_val.as_u32;
6890 ip->dst_address.as_u32 = dst_val.as_u32;
6893 ip->protocol = proto_val;
6896 /* These are not, but they're included for completeness */
6898 ip->ip_version_and_header_length |= (version_val & 0xF)<<4;
6901 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
6907 ip->length = length_val;
6913 ip->checksum = checksum_val;
6919 uword unformat_ip6_match (unformat_input_t * input, va_list * args)
6921 u8 ** matchp = va_arg (*args, u8 **);
6927 u32 traffic_class_val;
6930 int src = 0, dst = 0;
6931 ip6_address_t src_val, dst_val;
6934 int payload_length = 0;
6935 u32 payload_length_val;
6938 u32 ip_version_traffic_class_and_flow_label;
6940 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6942 if (unformat (input, "version %d", &version_val))
6944 else if (unformat (input, "traffic_class %d", &traffic_class_val))
6946 else if (unformat (input, "flow_label %d", &flow_label_val))
6948 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
6950 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
6952 else if (unformat (input, "proto %d", &proto_val))
6954 else if (unformat (input, "payload_length %d", &payload_length_val))
6956 else if (unformat (input, "hop_limit %d", &hop_limit_val))
6962 if (version + traffic_class + flow_label + src + dst + proto +
6963 payload_length + hop_limit == 0)
6967 * Aligned because we use the real comparison functions
6969 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6971 ip = (ip6_header_t *) match;
6974 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
6977 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
6980 ip->protocol = proto_val;
6982 ip_version_traffic_class_and_flow_label = 0;
6985 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
6988 ip_version_traffic_class_and_flow_label |= (traffic_class_val & 0xFF) << 20;
6991 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
6993 ip->ip_version_traffic_class_and_flow_label =
6994 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6997 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
7000 ip->hop_limit = hop_limit_val;
7006 uword unformat_l3_match (unformat_input_t * input, va_list * args)
7008 u8 ** matchp = va_arg (*args, u8 **);
7010 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7011 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
7013 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
7021 uword unformat_vlan_tag (unformat_input_t * input, va_list * args)
7023 u8 * tagp = va_arg (*args, u8 *);
7026 if (unformat(input, "%d", &tag))
7028 tagp[0] = (tag>>8) & 0x0F;
7029 tagp[1] = tag & 0xFF;
7036 uword unformat_l2_match (unformat_input_t * input, va_list * args)
7038 u8 ** matchp = va_arg (*args, u8 **);
7058 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7059 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
7061 else if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
7063 else if (unformat (input, "proto %U",
7064 unformat_ethernet_type_host_byte_order, &proto_val))
7066 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
7068 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
7070 else if (unformat (input, "ignore-tag1"))
7072 else if (unformat (input, "ignore-tag2"))
7074 else if (unformat (input, "cos1 %d", &cos1_val))
7076 else if (unformat (input, "cos2 %d", &cos2_val))
7081 if ((src + dst + proto + tag1 + tag2 +
7082 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7085 if (tag1 || ignore_tag1 || cos1)
7087 if (tag2 || ignore_tag2 || cos2)
7090 vec_validate_aligned (match, len-1, sizeof(u32x4));
7093 clib_memcpy (match, dst_val, 6);
7096 clib_memcpy (match + 6, src_val, 6);
7100 /* inner vlan tag */
7101 match[19] = tag2_val[1];
7102 match[18] = tag2_val[0];
7104 match [18] |= (cos2_val & 0x7) << 5;
7107 match[21] = proto_val & 0xff;
7108 match[20] = proto_val >> 8;
7112 match [15] = tag1_val[1];
7113 match [14] = tag1_val[0];
7116 match [14] |= (cos1_val & 0x7) << 5;
7122 match [15] = tag1_val[1];
7123 match [14] = tag1_val[0];
7126 match[17] = proto_val & 0xff;
7127 match[16] = proto_val >> 8;
7130 match [14] |= (cos1_val & 0x7) << 5;
7136 match [18] |= (cos2_val & 0x7) << 5;
7138 match [14] |= (cos1_val & 0x7) << 5;
7141 match[13] = proto_val & 0xff;
7142 match[12] = proto_val >> 8;
7150 uword unformat_classify_match (unformat_input_t * input, va_list * args)
7152 u8 ** matchp = va_arg (*args, u8 **);
7153 u32 skip_n_vectors = va_arg (*args, u32);
7154 u32 match_n_vectors = va_arg (*args, u32);
7160 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7161 if (unformat (input, "hex %U", unformat_hex_string, &match))
7163 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
7165 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
7171 if (match || l2 || l3)
7175 /* "Win a free Ethernet header in every packet" */
7177 vec_validate_aligned (l2, 13, sizeof(u32x4));
7179 vec_append_aligned (match, l3, sizeof(u32x4));
7183 /* Make sure the vector is big enough even if key is all 0's */
7184 vec_validate_aligned
7185 (match, ((match_n_vectors + skip_n_vectors) * sizeof(u32x4)) - 1,
7188 /* Set size, include skipped vectors*/
7189 _vec_len (match) = (match_n_vectors+skip_n_vectors) * sizeof(u32x4);
7199 static int api_classify_add_del_session (vat_main_t * vam)
7201 unformat_input_t * i = vam->input;
7202 vl_api_classify_add_del_session_t *mp;
7204 u32 table_index = ~0;
7205 u32 hit_next_index = ~0;
7206 u32 opaque_index = ~0;
7210 u32 skip_n_vectors = 0;
7211 u32 match_n_vectors = 0;
7214 * Warning: you have to supply skip_n and match_n
7215 * because the API client cant simply look at the classify
7219 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7220 if (unformat (i, "del"))
7222 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
7225 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
7228 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
7231 else if (unformat (i, "opaque-index %d", &opaque_index))
7233 else if (unformat (i, "skip_n %d", &skip_n_vectors))
7235 else if (unformat (i, "match_n %d", &match_n_vectors))
7237 else if (unformat (i, "match %U", unformat_classify_match,
7238 &match, skip_n_vectors, match_n_vectors))
7240 else if (unformat (i, "advance %d", &advance))
7242 else if (unformat (i, "table-index %d", &table_index))
7248 if (table_index == ~0) {
7249 errmsg ("Table index required\n");
7253 if (is_add && match == 0) {
7254 errmsg ("Match value required\n");
7258 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session,
7261 mp->is_add = is_add;
7262 mp->table_index = ntohl(table_index);
7263 mp->hit_next_index = ntohl(hit_next_index);
7264 mp->opaque_index = ntohl(opaque_index);
7265 mp->advance = ntohl(advance);
7266 clib_memcpy (mp->match, match, vec_len(match));
7273 static int api_classify_set_interface_ip_table (vat_main_t * vam)
7275 unformat_input_t * i = vam->input;
7276 vl_api_classify_set_interface_ip_table_t *mp;
7279 int sw_if_index_set;
7280 u32 table_index = ~0;
7283 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7284 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7285 sw_if_index_set = 1;
7286 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7287 sw_if_index_set = 1;
7288 else if (unformat (i, "table %d", &table_index))
7291 clib_warning ("parse error '%U'", format_unformat_error, i);
7296 if (sw_if_index_set == 0) {
7297 errmsg ("missing interface name or sw_if_index\n");
7302 M(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
7304 mp->sw_if_index = ntohl(sw_if_index);
7305 mp->table_index = ntohl(table_index);
7306 mp->is_ipv6 = is_ipv6;
7313 static int api_classify_set_interface_l2_tables (vat_main_t * vam)
7315 unformat_input_t * i = vam->input;
7316 vl_api_classify_set_interface_l2_tables_t *mp;
7319 int sw_if_index_set;
7320 u32 ip4_table_index = ~0;
7321 u32 ip6_table_index = ~0;
7322 u32 other_table_index = ~0;
7324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7325 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7326 sw_if_index_set = 1;
7327 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7328 sw_if_index_set = 1;
7329 else if (unformat (i, "ip4-table %d", &ip4_table_index))
7331 else if (unformat (i, "ip6-table %d", &ip6_table_index))
7333 else if (unformat (i, "other-table %d", &other_table_index))
7336 clib_warning ("parse error '%U'", format_unformat_error, i);
7341 if (sw_if_index_set == 0) {
7342 errmsg ("missing interface name or sw_if_index\n");
7347 M(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
7349 mp->sw_if_index = ntohl(sw_if_index);
7350 mp->ip4_table_index = ntohl(ip4_table_index);
7351 mp->ip6_table_index = ntohl(ip6_table_index);
7352 mp->other_table_index = ntohl(other_table_index);
7360 static int api_get_node_index (vat_main_t * vam)
7362 unformat_input_t * i = vam->input;
7363 vl_api_get_node_index_t * mp;
7367 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7368 if (unformat (i, "node %s", &name))
7374 errmsg ("node name required\n");
7377 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7378 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7382 M(GET_NODE_INDEX, get_node_index);
7383 clib_memcpy (mp->node_name, name, vec_len(name));
7391 static int api_add_node_next (vat_main_t * vam)
7393 unformat_input_t * i = vam->input;
7394 vl_api_add_node_next_t * mp;
7399 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7400 if (unformat (i, "node %s", &name))
7402 else if (unformat (i, "next %s", &next))
7408 errmsg ("node name required\n");
7411 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7412 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7416 errmsg ("next node required\n");
7419 if (vec_len (next) >= ARRAY_LEN(mp->next_name)) {
7420 errmsg ("next name too long, max %d\n", ARRAY_LEN(mp->next_name));
7424 M(ADD_NODE_NEXT, add_node_next);
7425 clib_memcpy (mp->node_name, name, vec_len(name));
7426 clib_memcpy (mp->next_name, next, vec_len(next));
7435 static int api_l2tpv3_create_tunnel (vat_main_t * vam)
7437 unformat_input_t * i = vam->input;
7438 ip6_address_t client_address, our_address;
7439 int client_address_set = 0;
7440 int our_address_set = 0;
7441 u32 local_session_id = 0;
7442 u32 remote_session_id = 0;
7443 u64 local_cookie = 0;
7444 u64 remote_cookie = 0;
7445 u8 l2_sublayer_present = 0;
7446 vl_api_l2tpv3_create_tunnel_t * mp;
7449 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7450 if (unformat (i, "client_address %U", unformat_ip6_address,
7452 client_address_set = 1;
7453 else if (unformat (i, "our_address %U", unformat_ip6_address,
7455 our_address_set = 1;
7456 else if (unformat (i, "local_session_id %d", &local_session_id))
7458 else if (unformat (i, "remote_session_id %d", &remote_session_id))
7460 else if (unformat (i, "local_cookie %lld", &local_cookie))
7462 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
7464 else if (unformat (i, "l2-sublayer-present"))
7465 l2_sublayer_present = 1;
7470 if (client_address_set == 0) {
7471 errmsg ("client_address required\n");
7475 if (our_address_set == 0) {
7476 errmsg ("our_address required\n");
7480 M(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
7482 clib_memcpy (mp->client_address, client_address.as_u8,
7483 sizeof (mp->client_address));
7485 clib_memcpy (mp->our_address, our_address.as_u8,
7486 sizeof (mp->our_address));
7488 mp->local_session_id = ntohl (local_session_id);
7489 mp->remote_session_id = ntohl (remote_session_id);
7490 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
7491 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
7492 mp->l2_sublayer_present = l2_sublayer_present;
7500 static int api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
7502 unformat_input_t * i = vam->input;
7504 u8 sw_if_index_set = 0;
7505 u64 new_local_cookie = 0;
7506 u64 new_remote_cookie = 0;
7507 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
7510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7511 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7512 sw_if_index_set = 1;
7513 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7514 sw_if_index_set = 1;
7515 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
7517 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
7523 if (sw_if_index_set == 0) {
7524 errmsg ("missing interface name or sw_if_index\n");
7528 M(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
7530 mp->sw_if_index = ntohl(sw_if_index);
7531 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
7532 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
7539 static int api_l2tpv3_interface_enable_disable (vat_main_t * vam)
7541 unformat_input_t * i = vam->input;
7542 vl_api_l2tpv3_interface_enable_disable_t *mp;
7545 u8 sw_if_index_set = 0;
7546 u8 enable_disable = 1;
7548 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7549 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7550 sw_if_index_set = 1;
7551 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7552 sw_if_index_set = 1;
7553 else if (unformat (i, "enable"))
7555 else if (unformat (i, "disable"))
7561 if (sw_if_index_set == 0) {
7562 errmsg ("missing interface name or sw_if_index\n");
7566 M(L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
7568 mp->sw_if_index = ntohl(sw_if_index);
7569 mp->enable_disable = enable_disable;
7576 static int api_l2tpv3_set_lookup_key (vat_main_t * vam)
7578 unformat_input_t * i = vam->input;
7579 vl_api_l2tpv3_set_lookup_key_t * mp;
7583 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7584 if (unformat (i, "lookup_v6_src"))
7585 key = L2T_LOOKUP_SRC_ADDRESS;
7586 else if (unformat (i, "lookup_v6_dst"))
7587 key = L2T_LOOKUP_DST_ADDRESS;
7588 else if (unformat (i, "lookup_session_id"))
7589 key = L2T_LOOKUP_SESSION_ID;
7594 if (key == (u8) ~0) {
7595 errmsg ("l2tp session lookup key unset\n");
7599 M(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
7608 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
7609 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7611 vat_main_t * vam = &vat_main;
7613 fformat(vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
7614 format_ip6_address, mp->our_address,
7615 format_ip6_address, mp->client_address,
7616 clib_net_to_host_u32(mp->sw_if_index));
7618 fformat (vam->ofp, " local cookies %016llx %016llx remote cookie %016llx\n",
7619 clib_net_to_host_u64 (mp->local_cookie[0]),
7620 clib_net_to_host_u64 (mp->local_cookie[1]),
7621 clib_net_to_host_u64 (mp->remote_cookie));
7623 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
7624 clib_net_to_host_u32 (mp->local_session_id),
7625 clib_net_to_host_u32 (mp->remote_session_id));
7627 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
7628 mp->l2_sublayer_present ? "preset" : "absent");
7632 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
7633 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7635 vat_main_t * vam = &vat_main;
7636 vat_json_node_t *node = NULL;
7637 struct in6_addr addr;
7639 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7640 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7641 vat_json_init_array(&vam->json_tree);
7643 node = vat_json_array_add(&vam->json_tree);
7645 vat_json_init_object(node);
7647 clib_memcpy(&addr, mp->our_address, sizeof(addr));
7648 vat_json_object_add_ip6(node, "our_address", addr);
7649 clib_memcpy(&addr, mp->client_address, sizeof(addr));
7650 vat_json_object_add_ip6(node, "client_address", addr);
7652 vat_json_node_t * lc = vat_json_object_add(node, "local_cookie");
7653 vat_json_init_array(lc);
7654 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[0]));
7655 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[1]));
7656 vat_json_object_add_uint(node, "remote_cookie", clib_net_to_host_u64(mp->remote_cookie));
7658 printf("local id: %u", clib_net_to_host_u32(mp->local_session_id));
7659 vat_json_object_add_uint(node, "local_session_id", clib_net_to_host_u32(mp->local_session_id));
7660 vat_json_object_add_uint(node, "remote_session_id", clib_net_to_host_u32(mp->remote_session_id));
7661 vat_json_object_add_string_copy(node, "l2_sublayer", mp->l2_sublayer_present ?
7662 (u8*)"present" : (u8*)"absent");
7665 static int api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
7667 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
7670 /* Get list of l2tpv3-tunnel interfaces */
7671 M(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
7674 /* Use a control ping for synchronization */
7676 vl_api_control_ping_t * mp;
7677 M(CONTROL_PING, control_ping);
7684 static void vl_api_sw_interface_tap_details_t_handler
7685 (vl_api_sw_interface_tap_details_t * mp)
7687 vat_main_t * vam = &vat_main;
7689 fformat(vam->ofp, "%-16s %d\n",
7691 clib_net_to_host_u32(mp->sw_if_index));
7694 static void vl_api_sw_interface_tap_details_t_handler_json
7695 (vl_api_sw_interface_tap_details_t * mp)
7697 vat_main_t * vam = &vat_main;
7698 vat_json_node_t *node = NULL;
7700 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7701 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7702 vat_json_init_array(&vam->json_tree);
7704 node = vat_json_array_add(&vam->json_tree);
7706 vat_json_init_object(node);
7707 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7708 vat_json_object_add_string_copy(node, "dev_name", mp->dev_name);
7711 static int api_sw_interface_tap_dump (vat_main_t * vam)
7713 vl_api_sw_interface_tap_dump_t *mp;
7716 fformat(vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
7717 /* Get list of tap interfaces */
7718 M(SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
7721 /* Use a control ping for synchronization */
7723 vl_api_control_ping_t * mp;
7724 M(CONTROL_PING, control_ping);
7730 static uword unformat_vxlan_decap_next
7731 (unformat_input_t * input, va_list * args)
7733 u32 * result = va_arg (*args, u32 *);
7736 if (unformat (input, "drop"))
7737 *result = VXLAN_INPUT_NEXT_DROP;
7738 else if (unformat (input, "ip4"))
7739 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
7740 else if (unformat (input, "ip6"))
7741 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
7742 else if (unformat (input, "l2"))
7743 *result = VXLAN_INPUT_NEXT_L2_INPUT;
7744 else if (unformat (input, "%d", &tmp))
7751 static int api_vxlan_add_del_tunnel (vat_main_t * vam)
7753 unformat_input_t * line_input = vam->input;
7754 vl_api_vxlan_add_del_tunnel_t *mp;
7756 ip4_address_t src4, dst4;
7757 ip6_address_t src6, dst6;
7759 u8 ipv4_set = 0, ipv6_set = 0;
7762 u32 encap_vrf_id = 0;
7763 u32 decap_next_index = ~0;
7766 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7767 if (unformat (line_input, "del"))
7769 else if (unformat (line_input, "src %U",
7770 unformat_ip4_address, &src4))
7775 else if (unformat (line_input, "dst %U",
7776 unformat_ip4_address, &dst4))
7781 else if (unformat (line_input, "src %U",
7782 unformat_ip6_address, &src6))
7787 else if (unformat (line_input, "dst %U",
7788 unformat_ip6_address, &dst6))
7793 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
7795 else if (unformat (line_input, "decap-next %U",
7796 unformat_vxlan_decap_next, &decap_next_index))
7798 else if (unformat (line_input, "vni %d", &vni))
7801 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7807 errmsg ("tunnel src address not specified\n");
7811 errmsg ("tunnel dst address not specified\n");
7815 if (ipv4_set && ipv6_set) {
7816 errmsg ("both IPv4 and IPv6 addresses specified");
7820 if ((vni == 0) || (vni>>24)) {
7821 errmsg ("vni not specified or out of range\n");
7825 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
7828 clib_memcpy(&mp->src_address, &src6, sizeof(src6));
7829 clib_memcpy(&mp->dst_address, &dst6, sizeof(dst6));
7831 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7832 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7834 mp->encap_vrf_id = ntohl(encap_vrf_id);
7835 mp->decap_next_index = ntohl(decap_next_index);
7836 mp->vni = ntohl(vni);
7837 mp->is_add = is_add;
7838 mp->is_ipv6 = ipv6_set;
7845 static void vl_api_vxlan_tunnel_details_t_handler
7846 (vl_api_vxlan_tunnel_details_t * mp)
7848 vat_main_t * vam = &vat_main;
7850 fformat(vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
7851 ntohl(mp->sw_if_index),
7852 format_ip46_address, &(mp->src_address[0]),
7854 format_ip46_address, &(mp->dst_address[0]),
7856 ntohl(mp->encap_vrf_id),
7857 ntohl(mp->decap_next_index),
7861 static void vl_api_vxlan_tunnel_details_t_handler_json
7862 (vl_api_vxlan_tunnel_details_t * mp)
7864 vat_main_t * vam = &vat_main;
7865 vat_json_node_t *node = NULL;
7867 struct in6_addr ip6;
7869 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7870 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7871 vat_json_init_array(&vam->json_tree);
7873 node = vat_json_array_add(&vam->json_tree);
7875 vat_json_init_object(node);
7876 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7878 clib_memcpy(&ip6, &(mp->src_address[0]), sizeof(ip6));
7879 vat_json_object_add_ip6(node, "src_address", ip6);
7880 clib_memcpy(&ip6, &(mp->dst_address[0]), sizeof(ip6));
7881 vat_json_object_add_ip6(node, "dst_address", ip6);
7883 clib_memcpy(&ip4, &(mp->src_address[0]), sizeof(ip4));
7884 vat_json_object_add_ip4(node, "src_address", ip4);
7885 clib_memcpy(&ip4, &(mp->dst_address[0]), sizeof(ip4));
7886 vat_json_object_add_ip4(node, "dst_address", ip4);
7888 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
7889 vat_json_object_add_uint(node, "decap_next_index", ntohl(mp->decap_next_index));
7890 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
7891 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
7894 static int api_vxlan_tunnel_dump (vat_main_t * vam)
7896 unformat_input_t * i = vam->input;
7897 vl_api_vxlan_tunnel_dump_t *mp;
7900 u8 sw_if_index_set = 0;
7902 /* Parse args required to build the message */
7903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7904 if (unformat (i, "sw_if_index %d", &sw_if_index))
7905 sw_if_index_set = 1;
7910 if (sw_if_index_set == 0) {
7914 if (!vam->json_output) {
7915 fformat(vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
7916 "sw_if_index", "src_address", "dst_address",
7917 "encap_vrf_id", "decap_next_index", "vni");
7920 /* Get list of vxlan-tunnel interfaces */
7921 M(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
7923 mp->sw_if_index = htonl(sw_if_index);
7927 /* Use a control ping for synchronization */
7929 vl_api_control_ping_t * mp;
7930 M(CONTROL_PING, control_ping);
7936 static int api_gre_add_del_tunnel (vat_main_t * vam)
7938 unformat_input_t * line_input = vam->input;
7939 vl_api_gre_add_del_tunnel_t *mp;
7941 ip4_address_t src4, dst4;
7945 u32 outer_fib_id = 0;
7947 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7948 if (unformat (line_input, "del"))
7950 else if (unformat (line_input, "src %U",
7951 unformat_ip4_address, &src4))
7953 else if (unformat (line_input, "dst %U",
7954 unformat_ip4_address, &dst4))
7956 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
7959 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7965 errmsg ("tunnel src address not specified\n");
7969 errmsg ("tunnel dst address not specified\n");
7974 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
7976 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7977 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7978 mp->outer_table_id = ntohl(outer_fib_id);
7979 mp->is_add = is_add;
7986 static void vl_api_gre_tunnel_details_t_handler
7987 (vl_api_gre_tunnel_details_t * mp)
7989 vat_main_t * vam = &vat_main;
7991 fformat(vam->ofp, "%11d%15U%15U%14d\n",
7992 ntohl(mp->sw_if_index),
7993 format_ip4_address, &mp->src_address,
7994 format_ip4_address, &mp->dst_address,
7995 ntohl(mp->outer_table_id));
7998 static void vl_api_gre_tunnel_details_t_handler_json
7999 (vl_api_gre_tunnel_details_t * mp)
8001 vat_main_t * vam = &vat_main;
8002 vat_json_node_t *node = NULL;
8005 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8006 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8007 vat_json_init_array(&vam->json_tree);
8009 node = vat_json_array_add(&vam->json_tree);
8011 vat_json_init_object(node);
8012 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8013 clib_memcpy(&ip4, &mp->src_address, sizeof(ip4));
8014 vat_json_object_add_ip4(node, "src_address", ip4);
8015 clib_memcpy(&ip4, &mp->dst_address, sizeof(ip4));
8016 vat_json_object_add_ip4(node, "dst_address", ip4);
8017 vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_table_id));
8020 static int api_gre_tunnel_dump (vat_main_t * vam)
8022 unformat_input_t * i = vam->input;
8023 vl_api_gre_tunnel_dump_t *mp;
8026 u8 sw_if_index_set = 0;
8028 /* Parse args required to build the message */
8029 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8030 if (unformat (i, "sw_if_index %d", &sw_if_index))
8031 sw_if_index_set = 1;
8036 if (sw_if_index_set == 0) {
8040 if (!vam->json_output) {
8041 fformat(vam->ofp, "%11s%15s%15s%14s\n",
8042 "sw_if_index", "src_address", "dst_address",
8046 /* Get list of gre-tunnel interfaces */
8047 M(GRE_TUNNEL_DUMP, gre_tunnel_dump);
8049 mp->sw_if_index = htonl(sw_if_index);
8053 /* Use a control ping for synchronization */
8055 vl_api_control_ping_t * mp;
8056 M(CONTROL_PING, control_ping);
8062 static int api_l2_fib_clear_table (vat_main_t * vam)
8064 // unformat_input_t * i = vam->input;
8065 vl_api_l2_fib_clear_table_t *mp;
8068 M(L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
8075 static int api_l2_interface_efp_filter (vat_main_t * vam)
8077 unformat_input_t * i = vam->input;
8078 vl_api_l2_interface_efp_filter_t *mp;
8082 u8 sw_if_index_set = 0;
8084 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8085 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8086 sw_if_index_set = 1;
8087 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8088 sw_if_index_set = 1;
8089 else if (unformat (i, "enable"))
8091 else if (unformat (i, "disable"))
8094 clib_warning ("parse error '%U'", format_unformat_error, i);
8099 if (sw_if_index_set == 0) {
8100 errmsg ("missing sw_if_index\n");
8104 M(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
8106 mp->sw_if_index = ntohl(sw_if_index);
8107 mp->enable_disable = enable;
8114 #define foreach_vtr_op \
8115 _("disable", L2_VTR_DISABLED) \
8116 _("push-1", L2_VTR_PUSH_1) \
8117 _("push-2", L2_VTR_PUSH_2) \
8118 _("pop-1", L2_VTR_POP_1) \
8119 _("pop-2", L2_VTR_POP_2) \
8120 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
8121 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
8122 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
8123 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
8125 static int api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
8127 unformat_input_t * i = vam->input;
8128 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
8131 u8 sw_if_index_set = 0;
8138 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8139 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8140 sw_if_index_set = 1;
8141 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8142 sw_if_index_set = 1;
8143 else if (unformat (i, "vtr_op %d", &vtr_op))
8145 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
8149 else if (unformat (i, "push_dot1q %d", &push_dot1q))
8151 else if (unformat (i, "tag1 %d", &tag1))
8153 else if (unformat (i, "tag2 %d", &tag2))
8156 clib_warning ("parse error '%U'", format_unformat_error, i);
8161 if ((sw_if_index_set == 0)||(vtr_op_set == 0)) {
8162 errmsg ("missing vtr operation or sw_if_index\n");
8166 M(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
8168 mp->sw_if_index = ntohl(sw_if_index);
8169 mp->vtr_op = ntohl(vtr_op);
8170 mp->push_dot1q = ntohl(push_dot1q);
8171 mp->tag1 = ntohl(tag1);
8172 mp->tag2 = ntohl(tag2);
8179 static int api_create_vhost_user_if (vat_main_t * vam)
8181 unformat_input_t * i = vam->input;
8182 vl_api_create_vhost_user_if_t *mp;
8186 u8 file_name_set = 0;
8187 u32 custom_dev_instance = ~0;
8189 u8 use_custom_mac = 0;
8191 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8192 if (unformat (i, "socket %s", &file_name)) {
8195 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
8197 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
8199 else if (unformat (i, "server"))
8205 if (file_name_set == 0) {
8206 errmsg ("missing socket file name\n");
8210 if (vec_len (file_name) > 255) {
8211 errmsg ("socket file name too long\n");
8214 vec_add1 (file_name, 0);
8216 M(CREATE_VHOST_USER_IF, create_vhost_user_if);
8218 mp->is_server = is_server;
8219 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
8220 vec_free(file_name);
8221 if (custom_dev_instance != ~0) {
8223 mp->custom_dev_instance = ntohl(custom_dev_instance);
8225 mp->use_custom_mac = use_custom_mac;
8226 clib_memcpy(mp->mac_address, hwaddr, 6);
8233 static int api_modify_vhost_user_if (vat_main_t * vam)
8235 unformat_input_t * i = vam->input;
8236 vl_api_modify_vhost_user_if_t *mp;
8240 u8 file_name_set = 0;
8241 u32 custom_dev_instance = ~0;
8242 u8 sw_if_index_set = 0;
8243 u32 sw_if_index = (u32)~0;
8245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8246 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8247 sw_if_index_set = 1;
8248 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8249 sw_if_index_set = 1;
8250 else if (unformat (i, "socket %s", &file_name)) {
8253 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
8255 else if (unformat (i, "server"))
8261 if (sw_if_index_set == 0) {
8262 errmsg ("missing sw_if_index or interface name\n");
8266 if (file_name_set == 0) {
8267 errmsg ("missing socket file name\n");
8271 if (vec_len (file_name) > 255) {
8272 errmsg ("socket file name too long\n");
8275 vec_add1 (file_name, 0);
8277 M(MODIFY_VHOST_USER_IF, modify_vhost_user_if);
8279 mp->sw_if_index = ntohl(sw_if_index);
8280 mp->is_server = is_server;
8281 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
8282 vec_free(file_name);
8283 if (custom_dev_instance != ~0) {
8285 mp->custom_dev_instance = ntohl(custom_dev_instance);
8293 static int api_delete_vhost_user_if (vat_main_t * vam)
8295 unformat_input_t * i = vam->input;
8296 vl_api_delete_vhost_user_if_t *mp;
8298 u32 sw_if_index = ~0;
8299 u8 sw_if_index_set = 0;
8301 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8302 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8303 sw_if_index_set = 1;
8304 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8305 sw_if_index_set = 1;
8310 if (sw_if_index_set == 0) {
8311 errmsg ("missing sw_if_index or interface name\n");
8316 M(DELETE_VHOST_USER_IF, delete_vhost_user_if);
8318 mp->sw_if_index = ntohl(sw_if_index);
8325 static void vl_api_sw_interface_vhost_user_details_t_handler
8326 (vl_api_sw_interface_vhost_user_details_t * mp)
8328 vat_main_t * vam = &vat_main;
8330 fformat(vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
8331 (char *)mp->interface_name,
8332 ntohl(mp->sw_if_index), ntohl(mp->virtio_net_hdr_sz),
8333 clib_net_to_host_u64(mp->features), mp->is_server,
8334 ntohl(mp->num_regions), (char *)mp->sock_filename);
8335 fformat(vam->ofp, " Status: '%s'\n", strerror(ntohl(mp->sock_errno)));
8338 static void vl_api_sw_interface_vhost_user_details_t_handler_json
8339 (vl_api_sw_interface_vhost_user_details_t * mp)
8341 vat_main_t * vam = &vat_main;
8342 vat_json_node_t *node = NULL;
8344 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8345 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8346 vat_json_init_array(&vam->json_tree);
8348 node = vat_json_array_add(&vam->json_tree);
8350 vat_json_init_object(node);
8351 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8352 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
8353 vat_json_object_add_uint(node, "virtio_net_hdr_sz", ntohl(mp->virtio_net_hdr_sz));
8354 vat_json_object_add_uint(node, "features", clib_net_to_host_u64(mp->features));
8355 vat_json_object_add_uint(node, "is_server", mp->is_server);
8356 vat_json_object_add_string_copy(node, "sock_filename", mp->sock_filename);
8357 vat_json_object_add_uint(node, "num_regions", ntohl(mp->num_regions));
8358 vat_json_object_add_uint(node, "sock_errno", ntohl(mp->sock_errno));
8361 static int api_sw_interface_vhost_user_dump (vat_main_t * vam)
8363 vl_api_sw_interface_vhost_user_dump_t *mp;
8365 fformat(vam->ofp, "Interface name idx hdr_sz features server regions filename\n");
8367 /* Get list of vhost-user interfaces */
8368 M(SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
8371 /* Use a control ping for synchronization */
8373 vl_api_control_ping_t * mp;
8374 M(CONTROL_PING, control_ping);
8380 static int api_show_version (vat_main_t * vam)
8382 vl_api_show_version_t *mp;
8385 M(SHOW_VERSION, show_version);
8393 static int api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
8395 unformat_input_t * line_input = vam->input;
8396 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
8398 ip4_address_t local4, remote4;
8399 ip6_address_t local6, remote6;
8401 u8 ipv4_set = 0, ipv6_set = 0;
8404 u32 encap_vrf_id = 0;
8405 u32 decap_vrf_id = 0;
8410 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8411 if (unformat (line_input, "del"))
8413 else if (unformat (line_input, "local %U",
8414 unformat_ip4_address, &local4))
8419 else if (unformat (line_input, "remote %U",
8420 unformat_ip4_address, &remote4))
8425 else if (unformat (line_input, "local %U",
8426 unformat_ip6_address, &local6))
8431 else if (unformat (line_input, "remote %U",
8432 unformat_ip6_address, &remote6))
8437 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
8439 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
8441 else if (unformat (line_input, "vni %d", &vni))
8443 else if (unformat(line_input, "next-ip4"))
8445 else if (unformat(line_input, "next-ip6"))
8447 else if (unformat(line_input, "next-ethernet"))
8449 else if (unformat(line_input, "next-nsh"))
8452 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
8457 if (local_set == 0) {
8458 errmsg ("tunnel local address not specified\n");
8461 if (remote_set == 0) {
8462 errmsg ("tunnel remote address not specified\n");
8465 if (ipv4_set && ipv6_set) {
8466 errmsg ("both IPv4 and IPv6 addresses specified");
8471 errmsg ("vni not specified\n");
8475 M(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
8479 clib_memcpy(&mp->local, &local6, sizeof(local6));
8480 clib_memcpy(&mp->remote, &remote6, sizeof(remote6));
8482 clib_memcpy(&mp->local, &local4, sizeof(local4));
8483 clib_memcpy(&mp->remote, &remote4, sizeof(remote4));
8486 mp->encap_vrf_id = ntohl(encap_vrf_id);
8487 mp->decap_vrf_id = ntohl(decap_vrf_id);
8488 mp->protocol = ntohl(protocol);
8489 mp->vni = ntohl(vni);
8490 mp->is_add = is_add;
8491 mp->is_ipv6 = ipv6_set;
8498 static void vl_api_vxlan_gpe_tunnel_details_t_handler
8499 (vl_api_vxlan_gpe_tunnel_details_t * mp)
8501 vat_main_t * vam = &vat_main;
8503 fformat(vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
8504 ntohl(mp->sw_if_index),
8505 format_ip46_address, &(mp->local[0]),
8506 format_ip46_address, &(mp->remote[0]),
8508 ntohl(mp->protocol),
8509 ntohl(mp->encap_vrf_id),
8510 ntohl(mp->decap_vrf_id));
8513 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
8514 (vl_api_vxlan_gpe_tunnel_details_t * mp)
8516 vat_main_t * vam = &vat_main;
8517 vat_json_node_t *node = NULL;
8519 struct in6_addr ip6;
8521 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8522 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8523 vat_json_init_array(&vam->json_tree);
8525 node = vat_json_array_add(&vam->json_tree);
8527 vat_json_init_object(node);
8528 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8530 clib_memcpy(&ip6, &(mp->local[0]), sizeof(ip6));
8531 vat_json_object_add_ip6(node, "local", ip6);
8532 clib_memcpy(&ip6, &(mp->remote[0]), sizeof(ip6));
8533 vat_json_object_add_ip6(node, "remote", ip6);
8535 clib_memcpy(&ip4, &(mp->local[0]), sizeof(ip4));
8536 vat_json_object_add_ip4(node, "local", ip4);
8537 clib_memcpy(&ip4, &(mp->remote[0]), sizeof(ip4));
8538 vat_json_object_add_ip4(node, "remote", ip4);
8540 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
8541 vat_json_object_add_uint(node, "protocol", ntohl(mp->protocol));
8542 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
8543 vat_json_object_add_uint(node, "decap_vrf_id", ntohl(mp->decap_vrf_id));
8544 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
8547 static int api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
8549 unformat_input_t * i = vam->input;
8550 vl_api_vxlan_gpe_tunnel_dump_t *mp;
8553 u8 sw_if_index_set = 0;
8555 /* Parse args required to build the message */
8556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8557 if (unformat (i, "sw_if_index %d", &sw_if_index))
8558 sw_if_index_set = 1;
8563 if (sw_if_index_set == 0) {
8567 if (!vam->json_output) {
8568 fformat(vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
8569 "sw_if_index", "local", "remote", "vni",
8570 "protocol","encap_vrf_id", "decap_vrf_id");
8573 /* Get list of vxlan-tunnel interfaces */
8574 M(VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
8576 mp->sw_if_index = htonl(sw_if_index);
8580 /* Use a control ping for synchronization */
8582 vl_api_control_ping_t * mp;
8583 M(CONTROL_PING, control_ping);
8589 u8 * format_l2_fib_mac_address (u8 * s, va_list * args)
8591 u8 * a = va_arg (*args, u8 *);
8593 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
8594 a[2], a[3], a[4], a[5], a[6], a[7]);
8597 static void vl_api_l2_fib_table_entry_t_handler
8598 (vl_api_l2_fib_table_entry_t * mp)
8600 vat_main_t * vam = &vat_main;
8602 fformat(vam->ofp, "%3" PRIu32 " %U %3" PRIu32
8604 ntohl(mp->bd_id), format_l2_fib_mac_address, &mp->mac,
8605 ntohl(mp->sw_if_index), mp->static_mac, mp->filter_mac,
8609 static void vl_api_l2_fib_table_entry_t_handler_json
8610 (vl_api_l2_fib_table_entry_t * mp)
8612 vat_main_t * vam = &vat_main;
8613 vat_json_node_t *node = NULL;
8615 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8616 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8617 vat_json_init_array(&vam->json_tree);
8619 node = vat_json_array_add(&vam->json_tree);
8621 vat_json_init_object(node);
8622 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
8623 vat_json_object_add_uint(node, "mac", clib_net_to_host_u64(mp->mac));
8624 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8625 vat_json_object_add_uint(node, "static_mac", mp->static_mac);
8626 vat_json_object_add_uint(node, "filter_mac", mp->filter_mac);
8627 vat_json_object_add_uint(node, "bvi_mac", mp->bvi_mac);
8630 static int api_l2_fib_table_dump (vat_main_t * vam)
8632 unformat_input_t * i = vam->input;
8633 vl_api_l2_fib_table_dump_t *mp;
8638 /* Parse args required to build the message */
8639 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8640 if (unformat (i, "bd_id %d", &bd_id))
8646 if (bd_id_set == 0) {
8647 errmsg ("missing bridge domain\n");
8651 fformat(vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI\n");
8653 /* Get list of l2 fib entries */
8654 M(L2_FIB_TABLE_DUMP, l2_fib_table_dump);
8656 mp->bd_id = ntohl(bd_id);
8659 /* Use a control ping for synchronization */
8661 vl_api_control_ping_t * mp;
8662 M(CONTROL_PING, control_ping);
8670 api_interface_name_renumber (vat_main_t * vam)
8672 unformat_input_t * line_input = vam->input;
8673 vl_api_interface_name_renumber_t *mp;
8674 u32 sw_if_index = ~0;
8676 u32 new_show_dev_instance = ~0;
8678 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8679 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
8682 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
8684 else if (unformat (line_input, "new_show_dev_instance %d",
8685 &new_show_dev_instance))
8691 if (sw_if_index == ~0) {
8692 errmsg ("missing interface name or sw_if_index\n");
8696 if (new_show_dev_instance == ~0) {
8697 errmsg ("missing new_show_dev_instance\n");
8701 M(INTERFACE_NAME_RENUMBER, interface_name_renumber);
8703 mp->sw_if_index = ntohl (sw_if_index);
8704 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
8710 api_want_ip4_arp_events (vat_main_t * vam)
8712 unformat_input_t * line_input = vam->input;
8713 vl_api_want_ip4_arp_events_t * mp;
8715 ip4_address_t address;
8716 int address_set = 0;
8717 u32 enable_disable = 1;
8719 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8720 if (unformat (line_input, "address %U",
8721 unformat_ip4_address, &address))
8723 else if (unformat (line_input, "del"))
8729 if (address_set == 0) {
8730 errmsg ("missing addresses\n");
8734 M(WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
8735 mp->enable_disable = enable_disable;
8737 mp->address = address.as_u32;
8742 static int api_input_acl_set_interface (vat_main_t * vam)
8744 unformat_input_t * i = vam->input;
8745 vl_api_input_acl_set_interface_t *mp;
8748 int sw_if_index_set;
8749 u32 ip4_table_index = ~0;
8750 u32 ip6_table_index = ~0;
8751 u32 l2_table_index = ~0;
8754 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8755 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8756 sw_if_index_set = 1;
8757 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8758 sw_if_index_set = 1;
8759 else if (unformat (i, "del"))
8761 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8763 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8765 else if (unformat (i, "l2-table %d", &l2_table_index))
8768 clib_warning ("parse error '%U'", format_unformat_error, i);
8773 if (sw_if_index_set == 0) {
8774 errmsg ("missing interface name or sw_if_index\n");
8778 M(INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
8780 mp->sw_if_index = ntohl(sw_if_index);
8781 mp->ip4_table_index = ntohl(ip4_table_index);
8782 mp->ip6_table_index = ntohl(ip6_table_index);
8783 mp->l2_table_index = ntohl(l2_table_index);
8784 mp->is_add = is_add;
8792 api_ip_address_dump (vat_main_t * vam)
8794 unformat_input_t * i = vam->input;
8795 vl_api_ip_address_dump_t * mp;
8796 u32 sw_if_index = ~0;
8797 u8 sw_if_index_set = 0;
8802 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8803 if (unformat (i, "sw_if_index %d", &sw_if_index))
8804 sw_if_index_set = 1;
8805 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8806 sw_if_index_set = 1;
8807 else if (unformat (i, "ipv4"))
8809 else if (unformat (i, "ipv6"))
8815 if (ipv4_set && ipv6_set) {
8816 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8820 if ((!ipv4_set) && (!ipv6_set)) {
8821 errmsg ("no ipv4 nor ipv6 flag set\n");
8825 if (sw_if_index_set == 0) {
8826 errmsg ("missing interface name or sw_if_index\n");
8830 vam->current_sw_if_index = sw_if_index;
8831 vam->is_ipv6 = ipv6_set;
8833 M(IP_ADDRESS_DUMP, ip_address_dump);
8834 mp->sw_if_index = ntohl(sw_if_index);
8835 mp->is_ipv6 = ipv6_set;
8838 /* Use a control ping for synchronization */
8840 vl_api_control_ping_t * mp;
8841 M(CONTROL_PING, control_ping);
8848 api_ip_dump (vat_main_t * vam)
8850 vl_api_ip_dump_t * mp;
8851 unformat_input_t * in = vam->input;
8858 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT) {
8859 if (unformat (in, "ipv4"))
8861 else if (unformat (in, "ipv6"))
8867 if (ipv4_set && ipv6_set) {
8868 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8872 if ((!ipv4_set) && (!ipv6_set)) {
8873 errmsg ("no ipv4 nor ipv6 flag set\n");
8878 vam->is_ipv6 = is_ipv6;
8881 for (i = 0; i < vec_len(vam->ip_details_by_sw_if_index[is_ipv6]); i++) {
8882 vec_free(vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
8884 vec_free(vam->ip_details_by_sw_if_index[is_ipv6]);
8886 M(IP_DUMP, ip_dump);
8887 mp->is_ipv6 = ipv6_set;
8890 /* Use a control ping for synchronization */
8892 vl_api_control_ping_t * mp;
8893 M(CONTROL_PING, control_ping);
8900 api_ipsec_spd_add_del (vat_main_t * vam)
8903 unformat_input_t * i = vam->input;
8904 vl_api_ipsec_spd_add_del_t *mp;
8909 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8910 if (unformat (i, "spd_id %d", &spd_id))
8912 else if (unformat (i, "del"))
8915 clib_warning ("parse error '%U'", format_unformat_error, i);
8920 errmsg ("spd_id must be set\n");
8924 M(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
8926 mp->spd_id = ntohl(spd_id);
8927 mp->is_add = is_add;
8933 clib_warning ("unsupported (no dpdk)");
8939 api_ipsec_interface_add_del_spd (vat_main_t * vam)
8942 unformat_input_t * i = vam->input;
8943 vl_api_ipsec_interface_add_del_spd_t *mp;
8946 u8 sw_if_index_set = 0;
8947 u32 spd_id = (u32) ~0;
8950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8951 if (unformat (i, "del"))
8953 else if (unformat (i, "spd_id %d", &spd_id))
8955 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8956 sw_if_index_set = 1;
8957 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8958 sw_if_index_set = 1;
8960 clib_warning ("parse error '%U'", format_unformat_error, i);
8966 if (spd_id == (u32) ~0) {
8967 errmsg ("spd_id must be set\n");
8971 if (sw_if_index_set == 0) {
8972 errmsg ("missing interface name or sw_if_index\n");
8976 M(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
8978 mp->spd_id = ntohl(spd_id);
8979 mp->sw_if_index = ntohl (sw_if_index);
8980 mp->is_add = is_add;
8986 clib_warning ("unsupported (no dpdk)");
8992 api_ipsec_spd_add_del_entry (vat_main_t * vam)
8995 unformat_input_t * i = vam->input;
8996 vl_api_ipsec_spd_add_del_entry_t *mp;
8998 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
8999 u32 spd_id, sa_id, protocol = 0, policy = 0;
9001 u32 rport_start = 0, rport_stop = (u32) ~0;
9002 u32 lport_start = 0, lport_stop = (u32) ~0;
9003 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
9004 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
9006 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
9007 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~0;
9008 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
9009 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
9010 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~0;
9011 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~0;
9013 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9014 if (unformat (i, "del"))
9016 if (unformat (i, "outbound"))
9018 if (unformat (i, "inbound"))
9020 else if (unformat (i, "spd_id %d", &spd_id))
9022 else if (unformat (i, "sa_id %d", &sa_id))
9024 else if (unformat (i, "priority %d", &priority))
9026 else if (unformat (i, "protocol %d", &protocol))
9028 else if (unformat (i, "lport_start %d", &lport_start))
9030 else if (unformat (i, "lport_stop %d", &lport_stop))
9032 else if (unformat (i, "rport_start %d", &rport_start))
9034 else if (unformat (i, "rport_stop %d", &rport_stop))
9036 else if (unformat (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
9041 else if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
9046 else if (unformat (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
9051 else if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
9056 else if (unformat (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
9061 else if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
9066 else if (unformat (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
9071 else if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
9076 else if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
9078 if (policy == IPSEC_POLICY_ACTION_RESOLVE) {
9079 clib_warning ("unsupported action: 'resolve'");
9084 clib_warning ("parse error '%U'", format_unformat_error, i);
9090 M(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
9092 mp->spd_id = ntohl(spd_id);
9093 mp->priority = ntohl(priority);
9094 mp->is_outbound = is_outbound;
9096 mp->is_ipv6 = is_ipv6;
9097 if (is_ipv6 || is_ip_any) {
9098 clib_memcpy (mp->remote_address_start, &raddr6_start, sizeof(ip6_address_t));
9099 clib_memcpy (mp->remote_address_stop, &raddr6_stop, sizeof(ip6_address_t));
9100 clib_memcpy (mp->local_address_start, &laddr6_start, sizeof(ip6_address_t));
9101 clib_memcpy (mp->local_address_stop, &laddr6_stop, sizeof(ip6_address_t));
9103 clib_memcpy (mp->remote_address_start, &raddr4_start, sizeof(ip4_address_t));
9104 clib_memcpy (mp->remote_address_stop, &raddr4_stop, sizeof(ip4_address_t));
9105 clib_memcpy (mp->local_address_start, &laddr4_start, sizeof(ip4_address_t));
9106 clib_memcpy (mp->local_address_stop, &laddr4_stop, sizeof(ip4_address_t));
9108 mp->protocol = (u8) protocol;
9109 mp->local_port_start = ntohs((u16) lport_start);
9110 mp->local_port_stop = ntohs((u16) lport_stop);
9111 mp->remote_port_start = ntohs((u16) rport_start);
9112 mp->remote_port_stop = ntohs((u16) rport_stop);
9113 mp->policy = (u8) policy;
9114 mp->sa_id = ntohl(sa_id);
9115 mp->is_add = is_add;
9116 mp->is_ip_any = is_ip_any;
9121 clib_warning ("unsupported (no dpdk)");
9127 api_ipsec_sad_add_del_entry (vat_main_t * vam)
9130 unformat_input_t * i = vam->input;
9131 vl_api_ipsec_sad_add_del_entry_t *mp;
9137 u8 protocol = IPSEC_PROTOCOL_AH;
9138 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
9139 u32 crypto_alg = 0, integ_alg = 0;
9140 ip4_address_t tun_src4;
9141 ip4_address_t tun_dst4;
9142 ip6_address_t tun_src6;
9143 ip6_address_t tun_dst6;
9145 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9146 if (unformat (i, "del"))
9148 else if (unformat (i, "sad_id %d", &sad_id))
9150 else if (unformat (i, "spi %d", &spi))
9152 else if (unformat (i, "esp"))
9153 protocol = IPSEC_PROTOCOL_ESP;
9154 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4)) {
9158 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4)) {
9162 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6)) {
9166 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6)) {
9170 else if (unformat (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg)) {
9171 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
9172 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256) {
9173 clib_warning ("unsupported crypto-alg: '%U'",
9174 format_ipsec_crypto_alg, crypto_alg);
9178 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
9180 else if (unformat (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg)) {
9181 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
9182 integ_alg > IPSEC_INTEG_ALG_SHA_512_256) {
9183 clib_warning ("unsupported integ-alg: '%U'",
9184 format_ipsec_integ_alg, integ_alg);
9188 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
9191 clib_warning ("parse error '%U'", format_unformat_error, i);
9197 M(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
9199 mp->sad_id = ntohl(sad_id);
9200 mp->is_add = is_add;
9201 mp->protocol = protocol;
9202 mp->spi = ntohl(spi);
9203 mp->is_tunnel = is_tunnel;
9204 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
9205 mp->crypto_algorithm = crypto_alg;
9206 mp->integrity_algorithm = integ_alg;
9207 mp->crypto_key_length = vec_len(ck);
9208 mp->integrity_key_length = vec_len(ik);
9210 if (mp->crypto_key_length > sizeof(mp->crypto_key))
9211 mp->crypto_key_length = sizeof(mp->crypto_key);
9213 if (mp->integrity_key_length > sizeof(mp->integrity_key))
9214 mp->integrity_key_length = sizeof(mp->integrity_key);
9216 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
9217 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
9220 if (is_tunnel_ipv6) {
9221 clib_memcpy (mp->tunnel_src_address, &tun_src6, sizeof(ip6_address_t));
9222 clib_memcpy (mp->tunnel_dst_address, &tun_dst6, sizeof(ip6_address_t));
9224 clib_memcpy (mp->tunnel_src_address, &tun_src4, sizeof(ip4_address_t));
9225 clib_memcpy (mp->tunnel_dst_address, &tun_dst4, sizeof(ip4_address_t));
9233 clib_warning ("unsupported (no dpdk)");
9239 api_ipsec_sa_set_key (vat_main_t * vam)
9242 unformat_input_t * i = vam->input;
9243 vl_api_ipsec_sa_set_key_t *mp;
9248 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9249 if (unformat (i, "sa_id %d", &sa_id))
9251 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
9253 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
9256 clib_warning ("parse error '%U'", format_unformat_error, i);
9261 M(IPSEC_SA_SET_KEY, ipsec_set_sa_key);
9263 mp->sa_id = ntohl(sa_id);
9264 mp->crypto_key_length = vec_len(ck);
9265 mp->integrity_key_length = vec_len(ik);
9267 if (mp->crypto_key_length > sizeof(mp->crypto_key))
9268 mp->crypto_key_length = sizeof(mp->crypto_key);
9270 if (mp->integrity_key_length > sizeof(mp->integrity_key))
9271 mp->integrity_key_length = sizeof(mp->integrity_key);
9273 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
9274 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
9280 clib_warning ("unsupported (no dpdk)");
9286 api_ikev2_profile_add_del (vat_main_t * vam)
9289 unformat_input_t * i = vam->input;
9290 vl_api_ikev2_profile_add_del_t * mp;
9295 const char * valid_chars = "a-zA-Z0-9_";
9297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9298 if (unformat (i, "del"))
9300 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9303 errmsg ("parse error '%U'", format_unformat_error, i);
9308 if (!vec_len (name)) {
9309 errmsg ("profile name must be specified");
9313 if (vec_len (name) > 64) {
9314 errmsg ("profile name too long");
9318 M(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
9320 clib_memcpy(mp->name, name, vec_len (name));
9321 mp->is_add = is_add;
9328 clib_warning ("unsupported (no dpdk)");
9334 api_ikev2_profile_set_auth (vat_main_t * vam)
9337 unformat_input_t * i = vam->input;
9338 vl_api_ikev2_profile_set_auth_t * mp;
9342 u32 auth_method = 0;
9345 const char * valid_chars = "a-zA-Z0-9_";
9347 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9348 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9350 else if (unformat (i, "auth_method %U",
9351 unformat_ikev2_auth_method, &auth_method))
9353 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
9355 else if (unformat (i, "auth_data %v", &data))
9358 errmsg ("parse error '%U'", format_unformat_error, i);
9363 if (!vec_len (name)) {
9364 errmsg ("profile name must be specified");
9368 if (vec_len (name) > 64) {
9369 errmsg ("profile name too long");
9373 if (!vec_len(data)) {
9374 errmsg ("auth_data must be specified");
9379 errmsg ("auth_method must be specified");
9383 M(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
9385 mp->is_hex = is_hex;
9386 mp->auth_method = (u8) auth_method;
9387 mp->data_len = vec_len (data);
9388 clib_memcpy (mp->name, name, vec_len (name));
9389 clib_memcpy (mp->data, data, vec_len (data));
9397 clib_warning ("unsupported (no dpdk)");
9403 api_ikev2_profile_set_id (vat_main_t * vam)
9406 unformat_input_t * i = vam->input;
9407 vl_api_ikev2_profile_set_id_t * mp;
9415 const char * valid_chars = "a-zA-Z0-9_";
9417 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9418 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9420 else if (unformat (i, "id_type %U",
9421 unformat_ikev2_id_type, &id_type))
9423 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
9425 data = vec_new(u8, 4);
9426 clib_memcpy(data, ip4.as_u8, 4);
9428 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
9430 else if (unformat (i, "id_data %v", &data))
9432 else if (unformat (i, "local"))
9434 else if (unformat (i, "remote"))
9437 errmsg ("parse error '%U'", format_unformat_error, i);
9442 if (!vec_len (name)) {
9443 errmsg ("profile name must be specified");
9447 if (vec_len (name) > 64) {
9448 errmsg ("profile name too long");
9452 if (!vec_len(data)) {
9453 errmsg ("id_data must be specified");
9458 errmsg ("id_type must be specified");
9462 M(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
9464 mp->is_local = is_local;
9465 mp->id_type = (u8) id_type;
9466 mp->data_len = vec_len (data);
9467 clib_memcpy (mp->name, name, vec_len (name));
9468 clib_memcpy (mp->data, data, vec_len (data));
9476 clib_warning ("unsupported (no dpdk)");
9482 api_ikev2_profile_set_ts (vat_main_t * vam)
9485 unformat_input_t * i = vam->input;
9486 vl_api_ikev2_profile_set_ts_t * mp;
9490 u32 proto = 0, start_port = 0, end_port = (u32) ~0;
9491 ip4_address_t start_addr, end_addr;
9493 const char * valid_chars = "a-zA-Z0-9_";
9495 start_addr.as_u32 = 0;
9496 end_addr.as_u32 = (u32) ~0;
9498 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9499 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9501 else if (unformat (i, "protocol %d", &proto))
9503 else if (unformat (i, "start_port %d", &start_port))
9505 else if (unformat (i, "end_port %d", &end_port))
9507 else if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
9509 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
9511 else if (unformat (i, "local"))
9513 else if (unformat (i, "remote"))
9516 errmsg ("parse error '%U'", format_unformat_error, i);
9521 if (!vec_len (name)) {
9522 errmsg ("profile name must be specified");
9526 if (vec_len (name) > 64) {
9527 errmsg ("profile name too long");
9531 M(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
9533 mp->is_local = is_local;
9534 mp->proto = (u8) proto;
9535 mp->start_port = (u16) start_port;
9536 mp->end_port = (u16) end_port;
9537 mp->start_addr = start_addr.as_u32;
9538 mp->end_addr = end_addr.as_u32;
9539 clib_memcpy (mp->name, name, vec_len (name));
9546 clib_warning ("unsupported (no dpdk)");
9552 api_ikev2_set_local_key (vat_main_t * vam)
9555 unformat_input_t * i = vam->input;
9556 vl_api_ikev2_set_local_key_t * mp;
9560 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9561 if (unformat (i, "file %v", &file))
9564 errmsg ("parse error '%U'", format_unformat_error, i);
9569 if (!vec_len (file)) {
9570 errmsg ("RSA key file must be specified");
9574 if (vec_len (file) > 256) {
9575 errmsg ("file name too long");
9579 M(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
9581 clib_memcpy (mp->key_file, file, vec_len (file));
9588 clib_warning ("unsupported (no dpdk)");
9596 static int api_map_add_domain (vat_main_t * vam)
9598 unformat_input_t *i = vam->input;
9599 vl_api_map_add_domain_t *mp;
9602 ip4_address_t ip4_prefix;
9603 ip6_address_t ip6_prefix;
9604 ip6_address_t ip6_src;
9606 u32 ip6_prefix_len, ip4_prefix_len, ea_bits_len, psid_offset,
9608 u8 is_translation = 0;
9610 u8 ip6_src_len = 128;
9612 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9613 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
9614 &ip4_prefix, &ip4_prefix_len))
9616 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
9617 &ip6_prefix, &ip6_prefix_len))
9619 else if (unformat (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src, &ip6_src_len))
9621 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
9623 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
9625 else if (unformat (i, "psid-offset %d", &psid_offset))
9627 else if (unformat (i, "psid-len %d", &psid_length))
9629 else if (unformat (i, "mtu %d", &mtu))
9631 else if (unformat (i, "map-t"))
9634 clib_warning ("parse error '%U'", format_unformat_error, i);
9639 if (num_m_args != 6) {
9640 errmsg("mandatory argument(s) missing\n");
9644 /* Construct the API message */
9645 M(MAP_ADD_DOMAIN, map_add_domain);
9647 clib_memcpy(mp->ip4_prefix, &ip4_prefix, sizeof(ip4_prefix));
9648 mp->ip4_prefix_len = ip4_prefix_len;
9650 clib_memcpy(mp->ip6_prefix, &ip6_prefix, sizeof(ip6_prefix));
9651 mp->ip6_prefix_len = ip6_prefix_len;
9653 clib_memcpy(mp->ip6_src, &ip6_src, sizeof(ip6_src));
9654 mp->ip6_src_prefix_len = ip6_src_len;
9656 mp->ea_bits_len = ea_bits_len;
9657 mp->psid_offset = psid_offset;
9658 mp->psid_length = psid_length;
9659 mp->is_translation = is_translation;
9660 mp->mtu = htons(mtu);
9665 /* Wait for a reply, return good/bad news */
9669 static int api_map_del_domain (vat_main_t * vam)
9671 unformat_input_t *i = vam->input;
9672 vl_api_map_del_domain_t *mp;
9678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9679 if (unformat (i, "index %d", &index))
9682 clib_warning ("parse error '%U'", format_unformat_error, i);
9687 if (num_m_args != 1) {
9688 errmsg("mandatory argument(s) missing\n");
9692 /* Construct the API message */
9693 M(MAP_DEL_DOMAIN, map_del_domain);
9695 mp->index = ntohl(index);
9700 /* Wait for a reply, return good/bad news */
9704 static int api_map_add_del_rule (vat_main_t * vam)
9706 unformat_input_t *i = vam->input;
9707 vl_api_map_add_del_rule_t *mp;
9710 ip6_address_t ip6_dst;
9711 u32 num_m_args = 0, index, psid;
9713 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9714 if (unformat (i, "index %d", &index))
9716 else if (unformat (i, "psid %d", &psid))
9718 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
9720 else if (unformat (i, "del")) {
9723 clib_warning ("parse error '%U'", format_unformat_error, i);
9728 /* Construct the API message */
9729 M(MAP_ADD_DEL_RULE, map_add_del_rule);
9731 mp->index = ntohl(index);
9732 mp->is_add = is_add;
9733 clib_memcpy(mp->ip6_dst, &ip6_dst, sizeof(ip6_dst));
9734 mp->psid = ntohs(psid);
9739 /* Wait for a reply, return good/bad news */
9743 static int api_map_domain_dump (vat_main_t * vam)
9745 vl_api_map_domain_dump_t *mp;
9748 /* Construct the API message */
9749 M(MAP_DOMAIN_DUMP, map_domain_dump);
9754 /* Use a control ping for synchronization */
9756 vl_api_control_ping_t * mp;
9757 M(CONTROL_PING, control_ping);
9763 static int api_map_rule_dump (vat_main_t * vam)
9765 unformat_input_t *i = vam->input;
9766 vl_api_map_rule_dump_t *mp;
9768 u32 domain_index = ~0;
9770 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9771 if (unformat (i, "index %u", &domain_index))
9777 if (domain_index == ~0) {
9778 clib_warning("parse error: domain index expected");
9782 /* Construct the API message */
9783 M(MAP_RULE_DUMP, map_rule_dump);
9785 mp->domain_index = htonl(domain_index);
9790 /* Use a control ping for synchronization */
9792 vl_api_control_ping_t * mp;
9793 M(CONTROL_PING, control_ping);
9799 static void vl_api_map_add_domain_reply_t_handler
9800 (vl_api_map_add_domain_reply_t * mp)
9802 vat_main_t * vam = &vat_main;
9803 i32 retval = ntohl(mp->retval);
9805 if (vam->async_mode) {
9806 vam->async_errors += (retval < 0);
9808 vam->retval = retval;
9809 vam->result_ready = 1;
9813 static void vl_api_map_add_domain_reply_t_handler_json
9814 (vl_api_map_add_domain_reply_t * mp)
9816 vat_main_t * vam = &vat_main;
9817 vat_json_node_t node;
9819 vat_json_init_object(&node);
9820 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
9821 vat_json_object_add_uint(&node, "index", ntohl(mp->index));
9823 vat_json_print(vam->ofp, &node);
9824 vat_json_free(&node);
9826 vam->retval = ntohl(mp->retval);
9827 vam->result_ready = 1;
9831 api_get_first_msg_id (vat_main_t * vam)
9833 vl_api_get_first_msg_id_t * mp;
9835 unformat_input_t * i = vam->input;
9839 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9840 if (unformat (i, "client %s", &name))
9846 if (name_set == 0) {
9847 errmsg ("missing client name\n");
9852 if (vec_len (name) > 63) {
9853 errmsg ("client name too long\n");
9857 M(GET_FIRST_MSG_ID, get_first_msg_id);
9858 clib_memcpy (mp->name, name, vec_len(name));
9864 static int api_cop_interface_enable_disable (vat_main_t * vam)
9866 unformat_input_t * line_input = vam->input;
9867 vl_api_cop_interface_enable_disable_t * mp;
9869 u32 sw_if_index = ~0;
9870 u8 enable_disable = 1;
9872 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9873 if (unformat (line_input, "disable"))
9875 if (unformat (line_input, "enable"))
9877 else if (unformat (line_input, "%U", unformat_sw_if_index,
9880 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9886 if (sw_if_index == ~0) {
9887 errmsg ("missing interface name or sw_if_index\n");
9891 /* Construct the API message */
9892 M(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
9893 mp->sw_if_index = ntohl(sw_if_index);
9894 mp->enable_disable = enable_disable;
9898 /* Wait for the reply */
9902 static int api_cop_whitelist_enable_disable (vat_main_t * vam)
9904 unformat_input_t * line_input = vam->input;
9905 vl_api_cop_whitelist_enable_disable_t * mp;
9907 u32 sw_if_index = ~0;
9908 u8 ip4=0, ip6=0, default_cop=0;
9911 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9912 if (unformat (line_input, "ip4"))
9914 else if (unformat (line_input, "ip6"))
9916 else if (unformat (line_input, "default"))
9918 else if (unformat (line_input, "%U", unformat_sw_if_index,
9921 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9923 else if (unformat (line_input, "fib-id %d", &fib_id))
9929 if (sw_if_index == ~0) {
9930 errmsg ("missing interface name or sw_if_index\n");
9934 /* Construct the API message */
9935 M(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
9936 mp->sw_if_index = ntohl(sw_if_index);
9937 mp->fib_id = ntohl(fib_id);
9940 mp->default_cop = default_cop;
9944 /* Wait for the reply */
9948 static int api_get_node_graph (vat_main_t * vam)
9950 vl_api_get_node_graph_t * mp;
9953 M(GET_NODE_GRAPH, get_node_graph);
9957 /* Wait for the reply */
9962 api_lisp_add_del_locator_set(vat_main_t * vam)
9964 unformat_input_t * input = vam->input;
9965 vl_api_lisp_add_del_locator_set_t *mp;
9968 u8 *locator_set_name = NULL;
9969 u8 locator_set_name_set = 0;
9971 /* Parse args required to build the message */
9972 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9973 if (unformat(input, "del")) {
9975 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9976 locator_set_name_set = 1;
9981 if (locator_set_name_set == 0) {
9982 errmsg ("missing locator-set name");
9986 if (vec_len(locator_set_name) > 64) {
9987 errmsg ("locator-set name too long\n");
9988 vec_free(locator_set_name);
9991 vec_add1(locator_set_name, 0);
9993 /* Construct the API message */
9994 M(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
9996 mp->is_add = is_add;
9997 clib_memcpy(mp->locator_set_name, locator_set_name,
9998 vec_len(locator_set_name));
9999 vec_free(locator_set_name);
10004 /* Wait for a reply... */
10012 api_lisp_add_del_locator(vat_main_t * vam)
10014 unformat_input_t * input = vam->input;
10015 vl_api_lisp_add_del_locator_t *mp;
10017 u32 tmp_if_index = ~0;
10018 u32 sw_if_index = ~0;
10019 u8 sw_if_index_set = 0;
10020 u8 sw_if_index_if_name_set = 0;
10022 u8 priority_set = 0;
10026 u8 *locator_set_name = NULL;
10027 u8 locator_set_name_set = 0;
10029 /* Parse args required to build the message */
10030 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10031 if (unformat(input, "del")) {
10033 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
10034 locator_set_name_set = 1;
10035 } else if (unformat(input, "iface %U", unformat_sw_if_index, vam,
10037 sw_if_index_if_name_set = 1;
10038 sw_if_index = tmp_if_index;
10039 } else if (unformat(input,"sw_if_index %d", &tmp_if_index)) {
10040 sw_if_index_set = 1;
10041 sw_if_index = tmp_if_index;
10042 } else if (unformat(input, "p %d", &priority)) {
10044 } else if (unformat(input, "w %d", &weight)) {
10050 if (locator_set_name_set == 0) {
10051 errmsg ("missing locator-set name");
10055 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0) {
10056 errmsg ("missing sw_if_index");
10057 vec_free(locator_set_name);
10061 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0) {
10062 errmsg ("cannot use both params interface name and sw_if_index");
10063 vec_free(locator_set_name);
10067 if (priority_set == 0) {
10068 errmsg ("missing locator-set priority\n");
10069 vec_free(locator_set_name);
10073 if (weight_set == 0) {
10074 errmsg ("missing locator-set weight\n");
10075 vec_free(locator_set_name);
10079 if (vec_len(locator_set_name) > 64) {
10080 errmsg ("locator-set name too long\n");
10081 vec_free(locator_set_name);
10084 vec_add1(locator_set_name, 0);
10086 /* Construct the API message */
10087 M(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
10089 mp->is_add = is_add;
10090 mp->sw_if_index = ntohl(sw_if_index);
10091 mp->priority = priority;
10092 mp->weight = weight;
10093 clib_memcpy(mp->locator_set_name, locator_set_name,
10094 vec_len(locator_set_name));
10095 vec_free(locator_set_name);
10100 /* Wait for a reply... */
10108 api_lisp_add_del_local_eid(vat_main_t * vam)
10110 unformat_input_t * input = vam->input;
10111 vl_api_lisp_add_del_local_eid_t *mp;
10116 u8 eid_type = (u8)~0;
10117 ip4_address_t eidv4;
10118 ip6_address_t eidv6;
10120 u32 tmp_eid_lenght = ~0;
10121 u8 eid_lenght = ~0;
10122 u8 *locator_set_name = NULL;
10123 u8 locator_set_name_set = 0;
10126 /* Parse args required to build the message */
10127 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10128 if (unformat(input, "del")) {
10130 } else if (unformat(input, "vni &d", &vni)) {
10132 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
10133 &eidv4, &tmp_eid_lenght)) {
10134 eid_lenght = tmp_eid_lenght;
10136 eid_type = 0; /* ipv4 type */
10137 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
10138 &eidv6, &tmp_eid_lenght)) {
10139 eid_lenght = tmp_eid_lenght;
10141 eid_type = 1; /* ipv6 type */
10142 } else if (unformat(input, "eid %U", unformat_ethernet_address, mac)) {
10143 eid_type = 2; /* mac type */
10144 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
10145 locator_set_name_set = 1;
10150 if (locator_set_name_set == 0) {
10151 errmsg ("missing locator-set name\n");
10155 if ((u8)~0 == eid_type) {
10156 errmsg ("EID address not set!");
10157 vec_free(locator_set_name);
10161 if (vec_len(locator_set_name) > 64) {
10162 errmsg ("locator-set name too long\n");
10163 vec_free(locator_set_name);
10166 vec_add1(locator_set_name, 0);
10168 if (eidv4_set && eidv6_set) {
10169 errmsg ("both eid v4 and v6 addresses set\n");
10170 vec_free(locator_set_name);
10174 if (eidv4_set && eid_lenght > 32) {
10175 errmsg ("eid prefix to big\n");
10176 vec_free(locator_set_name);
10180 if (eidv6_set && eid_lenght > 128) {
10181 errmsg ("eid prefix to big\n");
10182 vec_free(locator_set_name);
10186 /* Construct the API message */
10187 M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
10189 mp->is_add = is_add;
10190 switch (eid_type) {
10192 clib_memcpy (mp->eid, &eidv4, sizeof(eidv4));
10195 clib_memcpy (mp->eid, &eidv6, sizeof(eidv6));
10198 clib_memcpy (mp->eid, mac, 6);
10201 mp->eid_type = eid_type;
10202 mp->prefix_len = eid_lenght;
10203 mp->vni = clib_host_to_net_u32(vni);
10204 clib_memcpy(mp->locator_set_name, locator_set_name,
10205 vec_len(locator_set_name));
10206 vec_free(locator_set_name);
10211 /* Wait for a reply... */
10219 api_lisp_gpe_add_del_fwd_entry(vat_main_t * vam)
10221 unformat_input_t * input = vam->input;
10222 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
10225 u8 eidv4_set = 0, slocv4_set = 0, dlocv4_set = 0;
10226 u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0;
10227 ip4_address_t eidv4, slocv4, dlocv4;
10228 ip6_address_t eidv6, slocv6, dlocv6;
10229 u32 tmp_eid_lenght = ~0;
10230 u8 eid_lenght = ~0;
10232 /* Parse args required to build the message */
10233 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10234 if (unformat(input, "del")) {
10236 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
10237 &eidv4, &tmp_eid_lenght)) {
10238 eid_lenght = tmp_eid_lenght;
10240 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
10241 &eidv6, &tmp_eid_lenght)) {
10242 eid_lenght = tmp_eid_lenght;
10244 } else if (unformat(input, "sloc %U", unformat_ip4_address, &slocv4)) {
10246 } else if (unformat(input, "sloc %U", unformat_ip6_address, &slocv6)) {
10248 } else if (unformat(input, "dloc %U", unformat_ip4_address, &dlocv4)) {
10250 } else if (unformat(input, "dloc %U", unformat_ip6_address, &dlocv6)) {
10256 if (eidv4_set && eidv6_set) {
10257 errmsg ("both eid v4 and v6 addresses set\n");
10261 if (!eidv4_set && !eidv6_set) {
10262 errmsg ("eid addresses not set\n");
10266 if (slocv4_set && slocv6_set) {
10267 errmsg ("both source v4 and v6 addresses set\n");
10271 if (!slocv4_set && !slocv6_set) {
10272 errmsg ("source addresses not set\n");
10276 if (dlocv4_set && dlocv6_set) {
10277 errmsg ("both destination v4 and v6 addresses set\n");
10281 if (dlocv4_set && dlocv6_set) {
10282 errmsg ("destination addresses not set\n");
10286 if (!(slocv4_set == dlocv4_set && slocv6_set == dlocv6_set)) {
10287 errmsg ("mixing type of source and destination address\n");
10291 /* Construct the API message */
10292 M(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
10294 mp->is_add = is_add;
10296 mp->eid_is_ipv6 = 1;
10297 clib_memcpy(mp->eid_ip_address, &eidv6, sizeof(eidv6));
10299 mp->eid_is_ipv6 = 0;
10300 clib_memcpy(mp->eid_ip_address, &eidv4, sizeof(eidv4));
10302 mp->eid_prefix_len = eid_lenght;
10304 mp->address_is_ipv6 = 1;
10305 clib_memcpy(mp->source_ip_address, &slocv6, sizeof(slocv6));
10306 clib_memcpy(mp->destination_ip_address, &dlocv6, sizeof(dlocv6));
10308 mp->address_is_ipv6 = 0;
10309 clib_memcpy(mp->source_ip_address, &slocv4, sizeof(slocv4));
10310 clib_memcpy(mp->destination_ip_address, &dlocv4, sizeof(dlocv4));
10316 /* Wait for a reply... */
10324 api_lisp_add_del_map_resolver(vat_main_t * vam)
10326 unformat_input_t * input = vam->input;
10327 vl_api_lisp_add_del_map_resolver_t *mp;
10332 ip4_address_t ipv4;
10333 ip6_address_t ipv6;
10335 /* Parse args required to build the message */
10336 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10337 if (unformat(input, "del")) {
10339 } else if (unformat(input, "%U", unformat_ip4_address, &ipv4)) {
10341 } else if (unformat(input, "%U", unformat_ip6_address, &ipv6)) {
10347 if (ipv4_set && ipv6_set) {
10348 errmsg ("both eid v4 and v6 addresses set\n");
10352 if (!ipv4_set && !ipv6_set) {
10353 errmsg ("eid addresses not set\n");
10357 /* Construct the API message */
10358 M(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
10360 mp->is_add = is_add;
10363 clib_memcpy(mp->ip_address, &ipv6, sizeof(ipv6));
10366 clib_memcpy(mp->ip_address, &ipv4, sizeof(ipv4));
10372 /* Wait for a reply... */
10380 api_lisp_gpe_enable_disable (vat_main_t * vam)
10382 unformat_input_t * input = vam->input;
10383 vl_api_lisp_gpe_enable_disable_t *mp;
10388 /* Parse args required to build the message */
10389 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10390 if (unformat(input, "enable")) {
10393 } else if (unformat(input, "disable")) {
10401 errmsg("Value not set\n");
10405 /* Construct the API message */
10406 M(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
10413 /* Wait for a reply... */
10421 api_lisp_enable_disable (vat_main_t * vam)
10423 unformat_input_t * input = vam->input;
10424 vl_api_lisp_enable_disable_t *mp;
10429 /* Parse args required to build the message */
10430 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10432 if (unformat (input, "enable"))
10437 else if (unformat (input, "disable"))
10447 errmsg ("Value not set\n");
10451 /* Construct the API message */
10452 M(LISP_ENABLE_DISABLE, lisp_enable_disable);
10459 /* Wait for a reply... */
10466 /** Used for transferring locators via VPP API */
10467 typedef CLIB_PACKED(struct
10469 u8 is_ip4; /**< is locator an IPv4 address? */
10470 u8 addr[16]; /**< IPv4/IPv6 address */
10474 * Enable/disable LISP proxy ITR.
10476 * @param vam vpp API test context
10477 * @return return code
10480 api_lisp_pitr_set_locator_set (vat_main_t * vam)
10483 u8 ls_name_set = 0;
10484 unformat_input_t * input = vam->input;
10485 vl_api_lisp_pitr_set_locator_set_t * mp;
10489 /* Parse args required to build the message */
10490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10492 if (unformat (input, "del"))
10494 else if (unformat (input, "locator-set %s", &ls_name))
10498 errmsg ("parse error '%U'", format_unformat_error, input);
10505 errmsg ("locator-set name not set!");
10509 M(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
10511 mp->is_add = is_add;
10512 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
10513 vec_free (ls_name);
10518 /* wait for reply */
10526 * Add/delete mapping between vni and vrf
10529 api_lisp_eid_table_add_del_map (vat_main_t * vam)
10532 unformat_input_t * input = vam->input;
10533 vl_api_lisp_eid_table_add_del_map_t *mp;
10534 u8 is_add = 1, vni_set = 0, vrf_set = 0;
10537 /* Parse args required to build the message */
10538 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10540 if (unformat (input, "del"))
10542 else if (unformat(input, "vrf %d", &vrf))
10544 else if (unformat(input, "vni %d", &vni))
10550 if (!vni_set || !vrf_set)
10552 errmsg ("missing arguments!");
10556 M(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
10558 mp->is_add = is_add;
10559 mp->vni = htonl (vni);
10560 mp->vrf = htonl (vrf);
10565 /* wait for reply */
10573 * Add/del remote mapping to/from LISP control plane
10575 * @param vam vpp API test context
10576 * @return return code
10579 api_lisp_add_del_remote_mapping (vat_main_t * vam)
10581 unformat_input_t * input = vam->input;
10582 vl_api_lisp_add_del_remote_mapping_t *mp;
10585 ip4_address_t seid4, deid4, rloc4;
10586 ip6_address_t seid6, deid6, rloc6;
10587 u8 deid_mac[6] = {0};
10588 u8 seid_mac[6] = {0};
10589 u8 deid_type, seid_type;
10590 u32 seid_len = 0, deid_len = 0, len;
10591 u8 is_add = 1, del_all = 0;
10593 rloc_t * rlocs = 0, rloc;
10595 seid_type = deid_type = (u8)~0;
10597 /* Parse args required to build the message */
10598 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10599 if (unformat(input, "del-all")) {
10601 } else if (unformat(input, "del")) {
10603 } else if (unformat(input, "add")) {
10605 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10607 deid_type = 0; /* ipv4 */
10609 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10611 deid_type = 1; /* ipv6 */
10613 } else if (unformat(input, "deid %U", unformat_ethernet_address,
10615 deid_type = 2; /* mac */
10616 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10618 seid_type = 0; /* ipv4 */
10620 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10622 seid_type = 1; /* ipv6 */
10624 } else if (unformat(input, "seid %U", unformat_ethernet_address,
10626 seid_type = 2; /* mac */
10627 } else if (unformat(input, "vni %d", &vni)) {
10629 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10631 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10632 vec_add1 (rlocs, rloc);
10633 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10635 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10636 vec_add1 (rlocs, rloc);
10637 } else if (unformat(input, "action %d", &action)) {
10640 clib_warning ("parse error '%U'", format_unformat_error, input);
10645 if ((u8)~0 == deid_type) {
10646 errmsg ("missing params!");
10650 if (seid_type != deid_type) {
10651 errmsg ("source and destination EIDs are of different types!");
10655 if (is_add && (~0 == action)
10656 && 0 == vec_len (rlocs)) {
10657 errmsg ("no action set for negative map-reply!");
10661 M(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
10662 mp->is_add = is_add;
10663 mp->vni = htonl (vni);
10664 mp->seid_len = seid_len;
10665 mp->action = (u8) action;
10666 mp->deid_len = deid_len;
10667 mp->del_all = del_all;
10668 mp->eid_type = deid_type;
10670 switch (mp->eid_type) {
10672 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10673 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10676 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10677 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10680 clib_memcpy (mp->seid, seid_mac, 6);
10681 clib_memcpy (mp->deid, deid_mac, 6);
10684 errmsg ("unknown EID type %d!", mp->eid_type);
10688 mp->rloc_num = vec_len (rlocs);
10689 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10695 /* Wait for a reply... */
10703 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
10704 * forwarding entries in data-plane accordingly.
10706 * @param vam vpp API test context
10707 * @return return code
10710 api_lisp_add_del_adjacency (vat_main_t * vam)
10712 unformat_input_t * input = vam->input;
10713 vl_api_lisp_add_del_adjacency_t *mp;
10716 ip4_address_t seid4, deid4, rloc4;
10717 ip6_address_t seid6, deid6, rloc6;
10718 u8 deid_mac[6] = {0};
10719 u8 seid_mac[6] = {0};
10720 u8 deid_type, seid_type;
10721 u32 seid_len = 0, deid_len = 0, len;
10724 rloc_t * rlocs = 0, rloc;
10726 memset(mp, 0, sizeof(mp[0]));
10727 seid_type = deid_type = (u8)~0;
10729 /* Parse args required to build the message */
10730 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10731 if (unformat(input, "del")) {
10733 } else if (unformat(input, "add")) {
10735 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10737 deid_type = 0; /* ipv4 */
10739 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10741 deid_type = 1; /* ipv6 */
10743 } else if (unformat(input, "deid %U", unformat_ethernet_address,
10745 deid_type = 2; /* mac */
10746 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10748 seid_type = 0; /* ipv4 */
10750 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10752 seid_type = 1; /* ipv6 */
10754 } else if (unformat(input, "seid %U", unformat_ethernet_address,
10756 seid_type = 2; /* mac */
10757 } else if (unformat(input, "vni %d", &vni)) {
10759 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10761 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10762 vec_add1 (rlocs, rloc);
10763 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10765 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10766 vec_add1 (rlocs, rloc);
10767 } else if (unformat(input, "action %d", &action)) {
10770 clib_warning ("parse error '%U'", format_unformat_error, input);
10775 if ((u8)~0 == deid_type) {
10776 errmsg ("missing params!");
10780 if (seid_type != deid_type) {
10781 errmsg ("source and destination EIDs are of different types!");
10785 if (is_add && (~0 == action)
10786 && 0 == vec_len (rlocs)) {
10787 errmsg ("no action set for negative map-reply!");
10791 M(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
10792 mp->is_add = is_add;
10793 mp->vni = htonl (vni);
10794 mp->seid_len = seid_len;
10795 mp->action = (u8) action;
10796 mp->deid_len = deid_len;
10797 mp->eid_type = deid_type;
10799 switch (mp->eid_type) {
10801 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10802 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10805 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10806 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10809 clib_memcpy (mp->seid, seid_mac, 6);
10810 clib_memcpy (mp->deid, deid_mac, 6);
10813 errmsg ("unknown EID type %d!", mp->eid_type);
10817 mp->rloc_num = vec_len (rlocs);
10818 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10824 /* Wait for a reply... */
10832 api_lisp_gpe_add_del_iface(vat_main_t * vam)
10834 unformat_input_t * input = vam->input;
10835 vl_api_lisp_gpe_add_del_iface_t *mp;
10841 /* Parse args required to build the message */
10842 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10843 if (unformat(input, "up")) {
10846 } else if (unformat(input, "down")) {
10849 } else if (unformat(input, "table_id %d", &table_id)) {
10851 } else if (unformat(input, "vni %d", &vni)) {
10858 errmsg("Value not set\n");
10862 /* Construct the API message */
10863 M(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
10865 mp->is_add = is_add;
10866 mp->table_id = table_id;
10872 /* Wait for a reply... */
10880 * Add/del map request itr rlocs from LISP control plane and updates
10882 * @param vam vpp API test context
10883 * @return return code
10886 api_lisp_add_del_map_request_itr_rlocs(vat_main_t * vam)
10888 unformat_input_t * input = vam->input;
10889 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
10891 u8 *locator_set_name = 0;
10892 u8 locator_set_name_set = 0;
10895 /* Parse args required to build the message */
10896 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10897 if (unformat(input, "del")) {
10899 } else if (unformat(input, "%_%v%_", &locator_set_name)) {
10900 locator_set_name_set = 1;
10902 clib_warning ("parse error '%U'", format_unformat_error, input);
10907 if (is_add && !locator_set_name_set) {
10908 errmsg ("itr-rloc is not set!");
10912 if (is_add && vec_len(locator_set_name) > 64) {
10913 errmsg ("itr-rloc locator-set name too long\n");
10914 vec_free(locator_set_name);
10918 M(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
10919 mp->is_add = is_add;
10921 clib_memcpy (mp->locator_set_name , locator_set_name,
10922 vec_len(locator_set_name));
10924 memset(mp->locator_set_name, 0, sizeof(mp->locator_set_name));
10926 vec_free (locator_set_name);
10931 /* Wait for a reply... */
10939 api_lisp_locator_set_dump(vat_main_t *vam)
10941 vl_api_lisp_locator_set_dump_t *mp;
10944 if (!vam->json_output) {
10945 fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n",
10946 "Locator-set", "Locator", "Priority", "Weight");
10949 M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
10953 /* Use a control ping for synchronization */
10955 vl_api_control_ping_t * mp;
10956 M(CONTROL_PING, control_ping);
10959 /* Wait for a reply... */
10967 api_lisp_local_eid_table_dump(vat_main_t *vam)
10969 unformat_input_t * i = vam->input;
10970 vl_api_lisp_local_eid_table_dump_t *mp;
10972 struct in_addr ip4;
10973 struct in6_addr ip6;
10975 u8 eid_type = ~0, eid_set;
10976 u32 prefix_length = ~0, t, vni = 0;
10978 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10979 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t)) {
10983 } else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t)) {
10987 } else if (unformat (i, "eid %U", unformat_ethernet_address, mac)) {
10990 } else if (unformat (i, "vni %d", &t))
10993 errmsg ("parse error '%U'", format_unformat_error, i);
10998 if (!vam->json_output) {
10999 fformat(vam->ofp, "%=20s%=30s\n",
11000 "Locator-set", "Eid");
11003 M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
11007 mp->vni = htonl (vni);
11008 mp->eid_type = eid_type;
11009 switch (eid_type) {
11011 mp->prefix_length = prefix_length;
11012 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
11015 mp->prefix_length = prefix_length;
11016 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
11019 clib_memcpy (mp->eid, mac, sizeof (mac));
11022 errmsg ("unknown EID type %d!", eid_type);
11030 /* Use a control ping for synchronization */
11032 vl_api_control_ping_t * mp;
11033 M(CONTROL_PING, control_ping);
11036 /* Wait for a reply... */
11044 api_lisp_gpe_tunnel_dump(vat_main_t *vam)
11046 vl_api_lisp_gpe_tunnel_dump_t *mp;
11049 if (!vam->json_output) {
11050 fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
11051 "%=16s%=16s%=16s%=16s%=16s\n",
11052 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
11053 "Decap next", "Lisp version", "Flags", "Next protocol",
11054 "ver_res", "res", "iid");
11057 M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
11061 /* Use a control ping for synchronization */
11063 vl_api_control_ping_t * mp;
11064 M(CONTROL_PING, control_ping);
11067 /* Wait for a reply... */
11075 api_lisp_map_resolver_dump(vat_main_t *vam)
11077 vl_api_lisp_map_resolver_dump_t *mp;
11080 if (!vam->json_output) {
11081 fformat(vam->ofp, "%=20s\n",
11085 M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
11089 /* Use a control ping for synchronization */
11091 vl_api_control_ping_t * mp;
11092 M(CONTROL_PING, control_ping);
11095 /* Wait for a reply... */
11103 api_lisp_enable_disable_status_dump(vat_main_t *vam)
11105 vl_api_lisp_enable_disable_status_dump_t *mp;
11108 if (!vam->json_output) {
11109 fformat(vam->ofp, "%=20s\n",
11113 M(LISP_ENABLE_DISABLE_STATUS_DUMP,
11114 lisp_enable_disable_status_dump);
11118 /* Use a control ping for synchronization */
11120 vl_api_control_ping_t * mp;
11121 M(CONTROL_PING, control_ping);
11124 /* Wait for a reply... */
11132 api_lisp_get_map_request_itr_rlocs(vat_main_t *vam)
11134 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
11137 if (!vam->json_output) {
11138 fformat(vam->ofp, "%=20s\n",
11142 M(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
11145 /* Wait for a reply... */
11153 api_af_packet_create (vat_main_t * vam)
11155 unformat_input_t * i = vam->input;
11156 vl_api_af_packet_create_t * mp;
11158 u8 * host_if_name = 0;
11160 u8 random_hw_addr = 1;
11162 memset (hw_addr, 0, sizeof (hw_addr));
11164 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11165 if (unformat (i, "name %s", &host_if_name))
11166 vec_add1 (host_if_name, 0);
11167 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
11168 random_hw_addr = 0;
11173 if (!vec_len (host_if_name)) {
11174 errmsg ("host-interface name must be specified");
11178 if (vec_len (host_if_name) > 64) {
11179 errmsg ("host-interface name too long");
11183 M(AF_PACKET_CREATE, af_packet_create);
11185 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11186 clib_memcpy (mp->hw_addr, hw_addr, 6);
11187 mp->use_random_hw_addr = random_hw_addr;
11188 vec_free (host_if_name);
11190 S; W2(fprintf(vam->ofp," new sw_if_index = %d ", vam->sw_if_index));
11196 api_af_packet_delete (vat_main_t * vam)
11198 unformat_input_t * i = vam->input;
11199 vl_api_af_packet_delete_t * mp;
11201 u8 * host_if_name = 0;
11203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11204 if (unformat (i, "name %s", &host_if_name))
11205 vec_add1 (host_if_name, 0);
11210 if (!vec_len (host_if_name)) {
11211 errmsg ("host-interface name must be specified");
11215 if (vec_len (host_if_name) > 64) {
11216 errmsg ("host-interface name too long");
11220 M(AF_PACKET_DELETE, af_packet_delete);
11222 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11223 vec_free (host_if_name);
11231 api_policer_add_del (vat_main_t * vam)
11233 unformat_input_t * i = vam->input;
11234 vl_api_policer_add_del_t * mp;
11246 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11247 if (unformat (i, "del"))
11249 else if (unformat (i, "name %s", &name))
11250 vec_add1 (name, 0);
11251 else if (unformat (i, "cir %u", &cir))
11253 else if (unformat (i, "eir %u", &eir))
11255 else if (unformat (i, "cb %u", &cb))
11257 else if (unformat (i, "eb %u", &eb))
11259 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
11262 else if (unformat (i, "round_type %U", unformat_policer_round_type,
11265 else if (unformat (i, "type %U", unformat_policer_type, &type))
11271 if (!vec_len (name)) {
11272 errmsg ("policer name must be specified");
11276 if (vec_len (name) > 64) {
11277 errmsg ("policer name too long");
11281 M(POLICER_ADD_DEL, policer_add_del);
11283 clib_memcpy (mp->name, name, vec_len (name));
11285 mp->is_add = is_add;
11290 mp->rate_type = rate_type;
11291 mp->round_type = round_type;
11300 api_policer_dump(vat_main_t *vam)
11302 unformat_input_t * i = vam->input;
11303 vl_api_policer_dump_t *mp;
11305 u8 *match_name = 0;
11306 u8 match_name_valid = 0;
11308 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11309 if (unformat (i, "name %s", &match_name)) {
11310 vec_add1 (match_name, 0);
11311 match_name_valid = 1;
11316 M(POLICER_DUMP, policer_dump);
11317 mp->match_name_valid = match_name_valid;
11318 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
11319 vec_free (match_name);
11323 /* Use a control ping for synchronization */
11325 vl_api_control_ping_t * mp;
11326 M(CONTROL_PING, control_ping);
11329 /* Wait for a reply... */
11337 api_netmap_create (vat_main_t * vam)
11339 unformat_input_t * i = vam->input;
11340 vl_api_netmap_create_t * mp;
11344 u8 random_hw_addr = 1;
11348 memset (hw_addr, 0, sizeof (hw_addr));
11350 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11351 if (unformat (i, "name %s", &if_name))
11352 vec_add1 (if_name, 0);
11353 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
11354 random_hw_addr = 0;
11355 else if (unformat (i, "pipe"))
11357 else if (unformat (i, "master"))
11359 else if (unformat (i, "slave"))
11365 if (!vec_len (if_name)) {
11366 errmsg ("interface name must be specified");
11370 if (vec_len (if_name) > 64) {
11371 errmsg ("interface name too long");
11375 M(NETMAP_CREATE, netmap_create);
11377 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
11378 clib_memcpy (mp->hw_addr, hw_addr, 6);
11379 mp->use_random_hw_addr = random_hw_addr;
11380 mp->is_pipe = is_pipe;
11381 mp->is_master = is_master;
11382 vec_free (if_name);
11390 api_netmap_delete (vat_main_t * vam)
11392 unformat_input_t * i = vam->input;
11393 vl_api_netmap_delete_t * mp;
11397 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11398 if (unformat (i, "name %s", &if_name))
11399 vec_add1 (if_name, 0);
11404 if (!vec_len (if_name)) {
11405 errmsg ("interface name must be specified");
11409 if (vec_len (if_name) > 64) {
11410 errmsg ("interface name too long");
11414 M(NETMAP_DELETE, netmap_delete);
11416 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
11417 vec_free (if_name);
11424 static void vl_api_mpls_gre_tunnel_details_t_handler
11425 (vl_api_mpls_gre_tunnel_details_t * mp)
11427 vat_main_t * vam = &vat_main;
11429 i32 len = ntohl(mp->nlabels);
11431 if (mp->l2_only == 0) {
11432 fformat(vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
11433 ntohl(mp->tunnel_index),
11434 format_ip4_address, &mp->tunnel_src,
11435 format_ip4_address, &mp->tunnel_dst,
11436 format_ip4_address, &mp->intfc_address,
11437 ntohl(mp->mask_width));
11438 for (i = 0; i < len; i++) {
11439 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11441 fformat(vam->ofp, "\n");
11442 fformat(vam->ofp, " inner fib index %d, outer fib index %d\n",
11443 ntohl(mp->inner_fib_index), ntohl(mp->outer_fib_index));
11445 fformat(vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
11446 ntohl(mp->tunnel_index),
11447 format_ip4_address, &mp->tunnel_src,
11448 format_ip4_address, &mp->tunnel_dst,
11449 format_ip4_address, &mp->intfc_address);
11450 for (i = 0; i < len; i++) {
11451 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11453 fformat(vam->ofp, "\n");
11454 fformat(vam->ofp, " l2 interface %d, outer fib index %d\n",
11455 ntohl(mp->hw_if_index), ntohl(mp->outer_fib_index));
11459 static void vl_api_mpls_gre_tunnel_details_t_handler_json
11460 (vl_api_mpls_gre_tunnel_details_t * mp)
11462 vat_main_t * vam = &vat_main;
11463 vat_json_node_t *node = NULL;
11464 struct in_addr ip4;
11466 i32 len = ntohl(mp->nlabels);
11468 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11469 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11470 vat_json_init_array(&vam->json_tree);
11472 node = vat_json_array_add(&vam->json_tree);
11474 vat_json_init_object(node);
11475 vat_json_object_add_uint(node, "tunnel_index", ntohl(mp->tunnel_index));
11476 clib_memcpy(&ip4, &(mp->intfc_address), sizeof(ip4));
11477 vat_json_object_add_ip4(node, "intfc_address", ip4);
11478 vat_json_object_add_uint(node, "inner_fib_index", ntohl(mp->inner_fib_index));
11479 vat_json_object_add_uint(node, "mask_width", ntohl(mp->mask_width));
11480 vat_json_object_add_uint(node, "encap_index", ntohl(mp->encap_index));
11481 vat_json_object_add_uint(node, "hw_if_index", ntohl(mp->hw_if_index));
11482 vat_json_object_add_uint(node, "l2_only", ntohl(mp->l2_only));
11483 clib_memcpy(&ip4, &(mp->tunnel_src), sizeof(ip4));
11484 vat_json_object_add_ip4(node, "tunnel_src", ip4);
11485 clib_memcpy(&ip4, &(mp->tunnel_dst), sizeof(ip4));
11486 vat_json_object_add_ip4(node, "tunnel_dst", ip4);
11487 vat_json_object_add_uint(node, "outer_fib_index", ntohl(mp->outer_fib_index));
11488 vat_json_object_add_uint(node, "label_count", len);
11489 for (i = 0; i < len; i++) {
11490 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11494 static int api_mpls_gre_tunnel_dump (vat_main_t * vam)
11496 vl_api_mpls_gre_tunnel_dump_t *mp;
11500 /* Parse args required to build the message */
11501 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT) {
11502 if (!unformat (vam->input, "tunnel_index %d", &index)) {
11508 fformat(vam->ofp, " tunnel_index %d\n", index);
11510 M(MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
11511 mp->tunnel_index = htonl(index);
11514 /* Use a control ping for synchronization */
11516 vl_api_control_ping_t * mp;
11517 M(CONTROL_PING, control_ping);
11523 static void vl_api_mpls_eth_tunnel_details_t_handler
11524 (vl_api_mpls_eth_tunnel_details_t * mp)
11526 vat_main_t * vam = &vat_main;
11528 i32 len = ntohl(mp->nlabels);
11530 fformat(vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
11531 ntohl(mp->tunnel_index),
11532 format_ethernet_address, &mp->tunnel_dst_mac,
11533 format_ip4_address, &mp->intfc_address,
11534 ntohl(mp->mask_width));
11535 for (i = 0; i < len; i++) {
11536 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11538 fformat(vam->ofp, "\n");
11539 fformat(vam->ofp, " tx on %d, rx fib index %d\n",
11540 ntohl(mp->tx_sw_if_index),
11541 ntohl(mp->inner_fib_index));
11544 static void vl_api_mpls_eth_tunnel_details_t_handler_json
11545 (vl_api_mpls_eth_tunnel_details_t * mp)
11547 vat_main_t * vam = &vat_main;
11548 vat_json_node_t *node = NULL;
11549 struct in_addr ip4;
11551 i32 len = ntohl(mp->nlabels);
11553 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11554 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11555 vat_json_init_array(&vam->json_tree);
11557 node = vat_json_array_add(&vam->json_tree);
11559 vat_json_init_object(node);
11560 vat_json_object_add_uint(node, "tunnel_index", ntohl(mp->tunnel_index));
11561 clib_memcpy(&ip4, &(mp->intfc_address), sizeof(ip4));
11562 vat_json_object_add_ip4(node, "intfc_address", ip4);
11563 vat_json_object_add_uint(node, "inner_fib_index", ntohl(mp->inner_fib_index));
11564 vat_json_object_add_uint(node, "mask_width", ntohl(mp->mask_width));
11565 vat_json_object_add_uint(node, "encap_index", ntohl(mp->encap_index));
11566 vat_json_object_add_uint(node, "hw_if_index", ntohl(mp->hw_if_index));
11567 vat_json_object_add_uint(node, "l2_only", ntohl(mp->l2_only));
11568 vat_json_object_add_string_copy(node, "tunnel_dst_mac",
11569 format(0, "%U", format_ethernet_address, &mp->tunnel_dst_mac));
11570 vat_json_object_add_uint(node, "tx_sw_if_index", ntohl(mp->tx_sw_if_index));
11571 vat_json_object_add_uint(node, "label_count", len);
11572 for (i = 0; i < len; i++) {
11573 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11577 static int api_mpls_eth_tunnel_dump (vat_main_t * vam)
11579 vl_api_mpls_eth_tunnel_dump_t *mp;
11583 /* Parse args required to build the message */
11584 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT) {
11585 if (!unformat (vam->input, "tunnel_index %d", &index)) {
11591 fformat(vam->ofp, " tunnel_index %d\n", index);
11593 M(MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
11594 mp->tunnel_index = htonl(index);
11597 /* Use a control ping for synchronization */
11599 vl_api_control_ping_t * mp;
11600 M(CONTROL_PING, control_ping);
11606 static void vl_api_mpls_fib_encap_details_t_handler
11607 (vl_api_mpls_fib_encap_details_t * mp)
11609 vat_main_t * vam = &vat_main;
11611 i32 len = ntohl(mp->nlabels);
11613 fformat(vam->ofp, "table %d, dest %U, label ",
11614 ntohl(mp->fib_index),
11615 format_ip4_address, &mp->dest,
11617 for (i = 0; i < len; i++) {
11618 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11620 fformat(vam->ofp, "\n");
11623 static void vl_api_mpls_fib_encap_details_t_handler_json
11624 (vl_api_mpls_fib_encap_details_t * mp)
11626 vat_main_t * vam = &vat_main;
11627 vat_json_node_t *node = NULL;
11629 i32 len = ntohl(mp->nlabels);
11630 struct in_addr ip4;
11632 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11633 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11634 vat_json_init_array(&vam->json_tree);
11636 node = vat_json_array_add(&vam->json_tree);
11638 vat_json_init_object(node);
11639 vat_json_object_add_uint(node, "table", ntohl(mp->fib_index));
11640 vat_json_object_add_uint(node, "entry_index", ntohl(mp->entry_index));
11641 clib_memcpy(&ip4, &(mp->dest), sizeof(ip4));
11642 vat_json_object_add_ip4(node, "dest", ip4);
11643 vat_json_object_add_uint(node, "s_bit", ntohl(mp->s_bit));
11644 vat_json_object_add_uint(node, "label_count", len);
11645 for (i = 0; i < len; i++) {
11646 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11650 static int api_mpls_fib_encap_dump (vat_main_t * vam)
11652 vl_api_mpls_fib_encap_dump_t *mp;
11655 M(MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
11658 /* Use a control ping for synchronization */
11660 vl_api_control_ping_t * mp;
11661 M(CONTROL_PING, control_ping);
11667 static void vl_api_mpls_fib_decap_details_t_handler
11668 (vl_api_mpls_fib_decap_details_t * mp)
11670 vat_main_t * vam = &vat_main;
11672 fformat(vam->ofp, "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
11673 ntohl(mp->rx_table_id),
11674 ntohl(mp->tx_table_id),
11680 static void vl_api_mpls_fib_decap_details_t_handler_json
11681 (vl_api_mpls_fib_decap_details_t * mp)
11683 vat_main_t * vam = &vat_main;
11684 vat_json_node_t *node = NULL;
11685 struct in_addr ip4;
11687 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11688 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11689 vat_json_init_array(&vam->json_tree);
11691 node = vat_json_array_add(&vam->json_tree);
11693 vat_json_init_object(node);
11694 vat_json_object_add_uint(node, "table", ntohl(mp->fib_index));
11695 vat_json_object_add_uint(node, "entry_index", ntohl(mp->entry_index));
11696 clib_memcpy(&ip4, &(mp->dest), sizeof(ip4));
11697 vat_json_object_add_ip4(node, "dest", ip4);
11698 vat_json_object_add_uint(node, "s_bit", ntohl(mp->s_bit));
11699 vat_json_object_add_uint(node, "label", ntohl(mp->label));
11700 vat_json_object_add_uint(node, "rx_table_id", ntohl(mp->rx_table_id));
11701 vat_json_object_add_uint(node, "tx_table_id", ntohl(mp->tx_table_id));
11702 vat_json_object_add_string_copy(node, "swif_tag", mp->swif_tag);
11705 static int api_mpls_fib_decap_dump (vat_main_t * vam)
11707 vl_api_mpls_fib_decap_dump_t *mp;
11710 M(MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
11713 /* Use a control ping for synchronization */
11715 vl_api_control_ping_t * mp;
11716 M(CONTROL_PING, control_ping);
11722 int api_classify_table_ids (vat_main_t *vam)
11724 vl_api_classify_table_ids_t *mp;
11727 /* Construct the API message */
11728 M(CLASSIFY_TABLE_IDS, classify_table_ids);
11736 int api_classify_table_by_interface (vat_main_t *vam)
11738 unformat_input_t * input = vam->input;
11739 vl_api_classify_table_by_interface_t *mp;
11742 u32 sw_if_index = ~0;
11743 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11744 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
11746 else if (unformat (input, "sw_if_index %d", &sw_if_index))
11751 if (sw_if_index == ~0) {
11752 errmsg ("missing interface name or sw_if_index\n");
11756 /* Construct the API message */
11757 M(CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
11759 mp->sw_if_index = ntohl(sw_if_index);
11766 int api_classify_table_info (vat_main_t *vam)
11768 unformat_input_t * input = vam->input;
11769 vl_api_classify_table_info_t *mp;
11773 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11774 if (unformat (input, "table_id %d", &table_id))
11779 if (table_id == ~0) {
11780 errmsg ("missing table id\n");
11784 /* Construct the API message */
11785 M(CLASSIFY_TABLE_INFO, classify_table_info);
11787 mp->table_id = ntohl(table_id);
11794 int api_classify_session_dump (vat_main_t *vam)
11796 unformat_input_t * input = vam->input;
11797 vl_api_classify_session_dump_t *mp;
11801 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11802 if (unformat (input, "table_id %d", &table_id))
11807 if (table_id == ~0) {
11808 errmsg ("missing table id\n");
11812 /* Construct the API message */
11813 M(CLASSIFY_SESSION_DUMP, classify_session_dump);
11815 mp->table_id = ntohl(table_id);
11818 /* Use a control ping for synchronization */
11820 vl_api_control_ping_t * mp;
11821 M(CONTROL_PING, control_ping);
11829 static int q_or_quit (vat_main_t * vam)
11831 longjmp (vam->jump_buf, 1);
11832 return 0; /* not so much */
11834 static int q (vat_main_t * vam) {return q_or_quit (vam);}
11835 static int quit (vat_main_t * vam) {return q_or_quit (vam);}
11837 static int comment (vat_main_t * vam)
11842 static int cmd_cmp (void * a1, void * a2)
11847 return strcmp ((char *)(c1[0]), (char *)(c2[0]));
11850 static int help (vat_main_t * vam)
11855 unformat_input_t * i = vam->input;
11858 if (unformat (i, "%s", &name)) {
11863 hs = hash_get_mem (vam->help_by_name, name);
11865 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
11867 fformat (vam->ofp, "No such msg / command '%s'\n", name);
11872 fformat(vam->ofp, "Help is available for the following:\n");
11874 hash_foreach_pair (p, vam->function_by_name,
11876 vec_add1 (cmds, (u8 *)(p->key));
11879 vec_sort_with_function (cmds, cmd_cmp);
11881 for (j = 0; j < vec_len(cmds); j++)
11882 fformat (vam->ofp, "%s\n", cmds[j]);
11888 static int set (vat_main_t * vam)
11890 u8 * name = 0, * value = 0;
11891 unformat_input_t * i = vam->input;
11893 if (unformat (i, "%s", &name)) {
11894 /* The input buffer is a vector, not a string. */
11895 value = vec_dup (i->buffer);
11896 vec_delete (value, i->index, 0);
11897 /* Almost certainly has a trailing newline */
11898 if (value[vec_len(value)-1] == '\n')
11899 value[vec_len(value)-1] = 0;
11900 /* Make sure it's a proper string, one way or the other */
11901 vec_add1 (value, 0);
11902 (void) clib_macro_set_value (&vam->macro_main,
11903 (char *)name, (char *)value);
11906 errmsg ("usage: set <name> <value>\n");
11913 static int unset (vat_main_t * vam)
11917 if (unformat (vam->input, "%s", &name))
11918 if (clib_macro_unset (&vam->macro_main, (char *)name) == 1)
11919 errmsg ("unset: %s wasn't set\n", name);
11930 static int macro_sort_cmp (void * a1, void * a2)
11932 macro_sort_t * s1 = a1;
11933 macro_sort_t * s2 = a2;
11935 return strcmp ((char *)(s1->name), (char *)(s2->name));
11938 static int dump_macro_table (vat_main_t * vam)
11940 macro_sort_t * sort_me = 0, * sm;
11944 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
11946 vec_add2 (sort_me, sm, 1);
11947 sm->name = (u8 *)(p->key);
11948 sm->value = (u8 *) (p->value[0]);
11951 vec_sort_with_function (sort_me, macro_sort_cmp);
11953 if (vec_len(sort_me))
11954 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
11956 fformat (vam->ofp, "The macro table is empty...\n");
11958 for (i = 0; i < vec_len (sort_me); i++)
11959 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name,
11964 static int dump_node_table (vat_main_t * vam)
11967 vlib_node_t * node, * next_node;
11969 if (vec_len (vam->graph_nodes) == 0) {
11970 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
11974 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
11975 node = vam->graph_nodes[i];
11976 fformat (vam->ofp, "[%d] %s\n", i, node->name);
11977 for (j = 0; j < vec_len (node->next_nodes); j++) {
11978 if (node->next_nodes[j] != ~0) {
11979 next_node = vam->graph_nodes[node->next_nodes[j]];
11980 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
11987 static int search_node_table (vat_main_t * vam)
11989 unformat_input_t * line_input = vam->input;
11992 vlib_node_t * node, * next_node;
11995 if (vam->graph_node_index_by_name == 0) {
11996 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
12000 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
12001 if (unformat (line_input, "%s", &node_to_find)) {
12002 vec_add1 (node_to_find, 0);
12003 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
12005 fformat (vam->ofp, "%s not found...\n", node_to_find);
12008 node = vam->graph_nodes[p[0]];
12009 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
12010 for (j = 0; j < vec_len (node->next_nodes); j++) {
12011 if (node->next_nodes[j] != ~0) {
12012 next_node = vam->graph_nodes[node->next_nodes[j]];
12013 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
12019 clib_warning ("parse error '%U'", format_unformat_error,
12025 vec_free(node_to_find);
12033 static int script (vat_main_t * vam)
12036 char * save_current_file;
12037 unformat_input_t save_input;
12038 jmp_buf save_jump_buf;
12039 u32 save_line_number;
12041 FILE * new_fp, * save_ifp;
12043 if (unformat (vam->input, "%s", &s)) {
12044 new_fp = fopen ((char *)s, "r");
12046 errmsg ("Couldn't open script file %s\n", s);
12051 errmsg ("Missing script name\n");
12055 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
12056 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
12057 save_ifp = vam->ifp;
12058 save_line_number = vam->input_line_number;
12059 save_current_file = (char *) vam->current_file;
12061 vam->input_line_number = 0;
12063 vam->current_file = s;
12066 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
12067 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
12068 vam->ifp = save_ifp;
12069 vam->input_line_number = save_line_number;
12070 vam->current_file = (u8 *) save_current_file;
12076 static int echo (vat_main_t * vam)
12078 fformat (vam->ofp, "%v", vam->input->buffer);
12082 /* List of API message constructors, CLI names map to api_xxx */
12083 #define foreach_vpe_api_msg \
12084 _(create_loopback,"[mac <mac-addr>]") \
12085 _(sw_interface_dump,"") \
12086 _(sw_interface_set_flags, \
12087 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
12088 _(sw_interface_add_del_address, \
12089 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
12090 _(sw_interface_set_table, \
12091 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
12092 _(sw_interface_set_vpath, \
12093 "<intfc> | sw_if_index <id> enable | disable") \
12094 _(sw_interface_set_l2_xconnect, \
12095 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12096 "enable | disable") \
12097 _(sw_interface_set_l2_bridge, \
12098 "rx <intfc> | rx_sw_if_index <id> bd_id <bridge-domain-id>\n" \
12099 "[shg <split-horizon-group>] [bvi]\n" \
12100 "enable | disable") \
12101 _(bridge_domain_add_del, \
12102 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
12103 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
12105 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi]\n") \
12107 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
12109 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
12111 "tapname <name> mac <mac-addr> | random-mac") \
12113 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
12115 "<vpp-if-name> | sw_if_index <id>") \
12116 _(sw_interface_tap_dump, "") \
12117 _(ip_add_del_route, \
12118 "<addr>/<mask> via <addr> [vrf <n>]\n" \
12119 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
12120 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
12121 "[multipath] [count <n>]") \
12122 _(proxy_arp_add_del, \
12123 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
12124 _(proxy_arp_intfc_enable_disable, \
12125 "<intfc> | sw_if_index <id> enable | disable") \
12126 _(mpls_add_del_encap, \
12127 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
12128 _(mpls_add_del_decap, \
12129 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
12130 _(mpls_gre_add_del_tunnel, \
12131 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
12132 "adj <ip4-address>/<mask-width> [del]") \
12133 _(sw_interface_set_unnumbered, \
12134 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
12135 _(ip_neighbor_add_del, \
12136 "<intfc> | sw_if_index <id> dst <ip46-address> mac <mac-addr>") \
12137 _(reset_vrf, "vrf <id> [ipv6]") \
12138 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
12139 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
12140 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
12141 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
12142 "[outer_vlan_id_any][inner_vlan_id_any]") \
12143 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
12144 _(reset_fib, "vrf <n> [ipv6]") \
12145 _(dhcp_proxy_config, \
12146 "svr <v46-address> src <v46-address>\n" \
12147 "insert-cid <n> [del]") \
12148 _(dhcp_proxy_config_2, \
12149 "svr <v46-address> src <v46-address>\n" \
12150 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
12151 _(dhcp_proxy_set_vss, \
12152 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
12153 _(dhcp_client_config, \
12154 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
12155 _(set_ip_flow_hash, \
12156 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
12157 _(sw_interface_ip6_enable_disable, \
12158 "<intfc> | sw_if_index <id> enable | disable") \
12159 _(sw_interface_ip6_set_link_local_address, \
12160 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
12161 _(sw_interface_ip6nd_ra_prefix, \
12162 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
12163 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
12164 "[nolink] [isno]") \
12165 _(sw_interface_ip6nd_ra_config, \
12166 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
12167 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
12168 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
12169 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
12170 _(l2_patch_add_del, \
12171 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12172 "enable | disable") \
12173 _(mpls_ethernet_add_del_tunnel, \
12174 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
12175 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
12176 _(mpls_ethernet_add_del_tunnel_2, \
12177 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
12178 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
12179 _(sr_tunnel_add_del, \
12180 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
12181 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
12182 "[policy <policy_name>]") \
12183 _(sr_policy_add_del, \
12184 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
12185 _(sr_multicast_map_add_del, \
12186 "address [ip6 multicast address] sr-policy [policy name] [del]") \
12187 _(classify_add_del_table, \
12188 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
12189 "[del] mask <mask-value>\n" \
12190 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
12191 _(classify_add_del_session, \
12192 "[hit-next|l2-hit-next|acl-hit-next] <name|nn> table-index <nn>\n" \
12193 "skip_n <nn> match_n <nn> match [hex] [l2] [l3 [ip4|ip6]]") \
12194 _(classify_set_interface_ip_table, \
12195 "<intfc> | sw_if_index <nn> table <nn>") \
12196 _(classify_set_interface_l2_tables, \
12197 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
12198 " [other-table <nn>]") \
12199 _(get_node_index, "node <node-name") \
12200 _(add_node_next, "node <node-name> next <next-node-name>") \
12201 _(l2tpv3_create_tunnel, \
12202 "client_address <ip6-addr> our_address <ip6-addr>\n" \
12203 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
12204 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
12205 _(l2tpv3_set_tunnel_cookies, \
12206 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
12207 "[new_remote_cookie <nn>]\n") \
12208 _(l2tpv3_interface_enable_disable, \
12209 "<intfc> | sw_if_index <nn> enable | disable") \
12210 _(l2tpv3_set_lookup_key, \
12211 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
12212 _(sw_if_l2tpv3_tunnel_dump, "") \
12213 _(vxlan_add_del_tunnel, \
12214 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
12215 " [decap-next l2|ip4|ip6] [del]") \
12216 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12217 _(gre_add_del_tunnel, \
12218 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
12219 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12220 _(l2_fib_clear_table, "") \
12221 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
12222 _(l2_interface_vlan_tag_rewrite, \
12223 "<intfc> | sw_if_index <nn> \n" \
12224 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
12225 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
12226 _(create_vhost_user_if, \
12227 "socket <filename> [server] [renumber <dev_instance>] " \
12228 "[mac <mac_address>]") \
12229 _(modify_vhost_user_if, \
12230 "<intfc> | sw_if_index <nn> socket <filename>\n" \
12231 "[server] [renumber <dev_instance>]") \
12232 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
12233 _(sw_interface_vhost_user_dump, "") \
12234 _(show_version, "") \
12235 _(vxlan_gpe_add_del_tunnel, \
12236 "local <addr> remote <addr> vni <nn>\n" \
12237 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
12238 "[next-ethernet] [next-nsh]\n") \
12239 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12240 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
12241 _(interface_name_renumber, \
12242 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
12243 _(input_acl_set_interface, \
12244 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
12245 " [l2-table <nn>] [del]") \
12246 _(want_ip4_arp_events, "address <ip4-address> [del]") \
12247 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
12248 _(ip_dump, "ipv4 | ipv6") \
12249 _(ipsec_spd_add_del, "spd_id <n> [del]") \
12250 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
12252 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
12253 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
12254 " integ_alg <alg> integ_key <hex>") \
12255 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
12256 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
12257 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
12258 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
12259 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
12260 _(ikev2_profile_add_del, "name <profile_name> [del]") \
12261 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
12262 "(auth_data 0x<data> | auth_data <data>)") \
12263 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
12264 "(id_data 0x<data> | id_data <data>) (local|remote)") \
12265 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
12266 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
12267 "(local|remote)") \
12268 _(ikev2_set_local_key, "file <absolute_file_path>") \
12269 _(delete_loopback,"sw_if_index <nn>") \
12270 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
12271 _(map_add_domain, \
12272 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
12273 "ip6-src <ip6addr> " \
12274 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
12275 _(map_del_domain, "index <n>") \
12276 _(map_add_del_rule, \
12277 "index <n> psid <n> dst <ip6addr> [del]") \
12278 _(map_domain_dump, "") \
12279 _(map_rule_dump, "index <map-domain>") \
12280 _(want_interface_events, "enable|disable") \
12281 _(want_stats,"enable|disable") \
12282 _(get_first_msg_id, "client <name>") \
12283 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
12284 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
12285 "fib-id <nn> [ip4][ip6][default]") \
12286 _(get_node_graph, " ") \
12287 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
12288 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
12289 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
12290 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
12291 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
12292 " vrf_id <nn> add | pop | none") \
12293 _(trace_profile_del, "") \
12294 _(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \
12295 _(lisp_add_del_locator, "locator-set <locator_name> " \
12296 "iface <intf> | sw_if_index <sw_if_index> " \
12297 "p <priority> w <weight> [del]") \
12298 _(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \
12299 "locator-set <locator_name> [del]") \
12300 _(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \
12301 "sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \
12302 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
12303 _(lisp_gpe_enable_disable, "enable|disable") \
12304 _(lisp_enable_disable, "enable|disable") \
12305 _(lisp_gpe_add_del_iface, "up|down") \
12306 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> seid" \
12307 " <src-eid> rloc <locator> " \
12308 "[rloc <loc> ... ] action <action>") \
12309 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid" \
12310 " <src-eid> rloc <locator> " \
12311 "[rloc <loc> ... ] action <action>") \
12312 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
12313 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
12314 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
12315 _(lisp_locator_set_dump, "") \
12316 _(lisp_local_eid_table_dump, "") \
12317 _(lisp_gpe_tunnel_dump, "") \
12318 _(lisp_map_resolver_dump, "") \
12319 _(lisp_enable_disable_status_dump, "") \
12320 _(lisp_get_map_request_itr_rlocs, "") \
12321 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
12322 _(af_packet_delete, "name <host interface name>") \
12323 _(policer_add_del, "name <policer name> <params> [del]") \
12324 _(policer_dump, "[name <policer name>]") \
12325 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
12326 "[master|slave]") \
12327 _(netmap_delete, "name <interface name>") \
12328 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
12329 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
12330 _(mpls_fib_encap_dump, "") \
12331 _(mpls_fib_decap_dump, "") \
12332 _(classify_table_ids, "") \
12333 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
12334 _(classify_table_info, "table_id <nn>") \
12335 _(classify_session_dump, "table_id <nn>")
12337 /* List of command functions, CLI names map directly to functions */
12338 #define foreach_cli_function \
12339 _(comment, "usage: comment <ignore-rest-of-line>") \
12340 _(dump_interface_table, "usage: dump_interface_table") \
12341 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
12342 _(dump_ipv4_table, "usage: dump_ipv4_table") \
12343 _(dump_ipv6_table, "usage: dump_ipv6_table") \
12344 _(dump_stats_table, "usage: dump_stats_table") \
12345 _(dump_macro_table, "usage: dump_macro_table ") \
12346 _(dump_node_table, "usage: dump_node_table") \
12347 _(echo, "usage: echo <message>") \
12348 _(exec, "usage: exec <vpe-debug-CLI-command>") \
12349 _(help, "usage: help") \
12350 _(q, "usage: quit") \
12351 _(quit, "usage: quit") \
12352 _(search_node_table, "usage: search_node_table <name>...") \
12353 _(set, "usage: set <variable-name> <value>") \
12354 _(script, "usage: script <file-name>") \
12355 _(unset, "usage: unset <variable-name>")
12358 static void vl_api_##n##_t_handler_uni \
12359 (vl_api_##n##_t * mp) \
12361 vat_main_t * vam = &vat_main; \
12362 if (vam->json_output) { \
12363 vl_api_##n##_t_handler_json(mp); \
12365 vl_api_##n##_t_handler(mp); \
12368 foreach_vpe_api_reply_msg;
12371 void vat_api_hookup (vat_main_t *vam)
12374 vl_msg_api_set_handlers(VL_API_##N, #n, \
12375 vl_api_##n##_t_handler_uni, \
12377 vl_api_##n##_t_endian, \
12378 vl_api_##n##_t_print, \
12379 sizeof(vl_api_##n##_t), 1);
12380 foreach_vpe_api_reply_msg;
12383 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
12385 vam->sw_if_index_by_interface_name =
12386 hash_create_string (0, sizeof (uword));
12388 vam->function_by_name =
12389 hash_create_string (0, sizeof(uword));
12391 vam->help_by_name =
12392 hash_create_string (0, sizeof(uword));
12394 /* API messages we can send */
12395 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
12396 foreach_vpe_api_msg;
12400 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
12401 foreach_vpe_api_msg;
12404 /* CLI functions */
12405 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
12406 foreach_cli_function;
12410 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
12411 foreach_cli_function;
12415 #undef vl_api_version
12416 #define vl_api_version(n,v) static u32 vpe_api_version = v;
12417 #include <vpp-api/vpe.api.h>
12418 #undef vl_api_version
12420 void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
12423 * Send the main API signature in slot 0. This bit of code must
12424 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
12426 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);