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;
3910 /* Parse args required to build the message */
3911 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3912 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
3914 else if (unformat (i, "bd_id %d", &bd_id))
3916 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3917 sw_if_index_set = 1;
3918 else if (unformat (i, "sw_if")) {
3919 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3920 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3921 sw_if_index_set = 1;
3924 } else if (unformat (i, "static"))
3926 else if (unformat (i, "filter")) {
3929 } else if (unformat (i, "bvi")) {
3932 } else if (unformat (i, "del"))
3939 errmsg ("missing mac address\n");
3943 if (bd_id_set == 0) {
3944 errmsg ("missing bridge domain\n");
3948 if (is_add && (sw_if_index_set == 0)) {
3949 errmsg ("missing interface name or sw_if_index\n");
3953 M(L2FIB_ADD_DEL, l2fib_add_del);
3956 mp->bd_id = ntohl(bd_id);
3957 mp->is_add = is_add;
3960 mp->sw_if_index = ntohl(sw_if_index);
3961 mp->static_mac = static_mac;
3962 mp->filter_mac = filter_mac;
3963 mp->bvi_mac = bvi_mac;
3971 static int api_l2_flags (vat_main_t * vam)
3973 unformat_input_t * i = vam->input;
3974 vl_api_l2_flags_t *mp;
3977 u32 feature_bitmap = 0;
3978 u8 sw_if_index_set = 0;
3980 /* Parse args required to build the message */
3981 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3982 if (unformat (i, "sw_if_index %d", &sw_if_index))
3983 sw_if_index_set = 1;
3984 else if (unformat (i, "sw_if")) {
3985 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3986 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3987 sw_if_index_set = 1;
3990 } else if (unformat (i, "learn"))
3991 feature_bitmap |= L2INPUT_FEAT_LEARN;
3992 else if (unformat (i, "forward"))
3993 feature_bitmap |= L2INPUT_FEAT_FWD;
3994 else if (unformat (i, "flood"))
3995 feature_bitmap |= L2INPUT_FEAT_FLOOD;
3996 else if (unformat (i, "uu-flood"))
3997 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
4002 if (sw_if_index_set == 0) {
4003 errmsg ("missing interface name or sw_if_index\n");
4007 M(L2_FLAGS, l2_flags);
4009 mp->sw_if_index = ntohl(sw_if_index);
4010 mp->feature_bitmap = ntohl(feature_bitmap);
4017 static int api_bridge_flags (vat_main_t * vam)
4019 unformat_input_t * i = vam->input;
4020 vl_api_bridge_flags_t *mp;
4027 /* Parse args required to build the message */
4028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4029 if (unformat (i, "bd_id %d", &bd_id))
4031 else if (unformat (i, "learn"))
4033 else if (unformat (i, "forward"))
4035 else if (unformat (i, "flood"))
4037 else if (unformat (i, "uu-flood"))
4038 flags |= L2_UU_FLOOD;
4039 else if (unformat (i, "arp-term"))
4040 flags |= L2_ARP_TERM;
4041 else if (unformat (i, "off"))
4043 else if (unformat (i, "disable"))
4049 if (bd_id_set == 0) {
4050 errmsg ("missing bridge domain\n");
4054 M(BRIDGE_FLAGS, bridge_flags);
4056 mp->bd_id = ntohl(bd_id);
4057 mp->feature_bitmap = ntohl(flags);
4058 mp->is_set = is_set;
4065 static int api_bd_ip_mac_add_del (vat_main_t * vam)
4067 unformat_input_t * i = vam->input;
4068 vl_api_bd_ip_mac_add_del_t *mp;
4076 ip4_address_t v4addr;
4077 ip6_address_t v6addr;
4081 /* Parse args required to build the message */
4082 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4083 if (unformat (i, "bd_id %d", &bd_id)) {
4085 } else if (unformat (i, "%U", unformat_ip4_address, &v4addr)) {
4087 } else if (unformat (i, "%U", unformat_ip6_address, &v6addr)) {
4090 } else if (unformat (i, "%U", unformat_ethernet_address, macaddr)) {
4092 } else if (unformat (i, "del"))
4098 if (bd_id_set == 0) {
4099 errmsg ("missing bridge domain\n");
4101 } else if (ip_set == 0) {
4102 errmsg ("missing IP address\n");
4104 } else if (mac_set == 0) {
4105 errmsg ("missing MAC address\n");
4109 M(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
4111 mp->bd_id = ntohl(bd_id);
4112 mp->is_ipv6 = is_ipv6;
4113 mp->is_add = is_add;
4115 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
4116 else clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
4117 clib_memcpy (mp->mac_address, macaddr, 6);
4123 static int api_tap_connect (vat_main_t * vam)
4125 unformat_input_t * i = vam->input;
4126 vl_api_tap_connect_t *mp;
4133 memset (mac_address, 0, sizeof (mac_address));
4135 /* Parse args required to build the message */
4136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4137 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4140 else if (unformat (i, "random-mac"))
4142 else if (unformat (i, "tapname %s", &tap_name))
4148 if (name_set == 0) {
4149 errmsg ("missing tap name\n");
4152 if (vec_len (tap_name) > 63) {
4153 errmsg ("tap name too long\n");
4155 vec_add1 (tap_name, 0);
4157 /* Construct the API message */
4158 M(TAP_CONNECT, tap_connect);
4160 mp->use_random_mac = random_mac;
4161 clib_memcpy (mp->mac_address, mac_address, 6);
4162 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
4163 vec_free (tap_name);
4168 /* Wait for a reply... */
4172 static int api_tap_modify (vat_main_t * vam)
4174 unformat_input_t * i = vam->input;
4175 vl_api_tap_modify_t *mp;
4181 u32 sw_if_index = ~0;
4182 u8 sw_if_index_set = 0;
4184 memset (mac_address, 0, sizeof (mac_address));
4186 /* Parse args required to build the message */
4187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4188 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4189 sw_if_index_set = 1;
4190 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4191 sw_if_index_set = 1;
4192 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4195 else if (unformat (i, "random-mac"))
4197 else if (unformat (i, "tapname %s", &tap_name))
4203 if (sw_if_index_set == 0) {
4204 errmsg ("missing vpp interface name");
4207 if (name_set == 0) {
4208 errmsg ("missing tap name\n");
4211 if (vec_len (tap_name) > 63) {
4212 errmsg ("tap name too long\n");
4214 vec_add1 (tap_name, 0);
4216 /* Construct the API message */
4217 M(TAP_MODIFY, tap_modify);
4219 mp->use_random_mac = random_mac;
4220 mp->sw_if_index = ntohl(sw_if_index);
4221 clib_memcpy (mp->mac_address, mac_address, 6);
4222 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
4223 vec_free (tap_name);
4228 /* Wait for a reply... */
4232 static int api_tap_delete (vat_main_t * vam)
4234 unformat_input_t * i = vam->input;
4235 vl_api_tap_delete_t *mp;
4237 u32 sw_if_index = ~0;
4238 u8 sw_if_index_set = 0;
4240 /* Parse args required to build the message */
4241 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4242 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4243 sw_if_index_set = 1;
4244 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4245 sw_if_index_set = 1;
4250 if (sw_if_index_set == 0) {
4251 errmsg ("missing vpp interface name");
4255 /* Construct the API message */
4256 M(TAP_DELETE, tap_delete);
4258 mp->sw_if_index = ntohl(sw_if_index);
4263 /* Wait for a reply... */
4267 static int api_ip_add_del_route (vat_main_t * vam)
4269 unformat_input_t * i = vam->input;
4270 vl_api_ip_add_del_route_t *mp;
4272 u32 sw_if_index = 0, vrf_id = 0;
4273 u8 sw_if_index_set = 0;
4275 u8 is_local = 0, is_drop = 0;
4276 u8 create_vrf_if_needed = 0;
4278 u8 next_hop_weight = 1;
4280 u8 is_multipath = 0;
4282 u8 address_length_set = 0;
4283 u32 lookup_in_vrf = 0;
4284 u32 resolve_attempts = 0;
4285 u32 dst_address_length = 0;
4286 u8 next_hop_set = 0;
4287 ip4_address_t v4_dst_address, v4_next_hop_address;
4288 ip6_address_t v6_dst_address, v6_next_hop_address;
4292 u32 random_add_del = 0;
4293 u32 * random_vector = 0;
4294 uword * random_hash;
4295 u32 random_seed = 0xdeaddabe;
4296 u32 classify_table_index = ~0;
4299 /* Parse args required to build the message */
4300 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4301 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4302 sw_if_index_set = 1;
4303 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4304 sw_if_index_set = 1;
4305 else if (unformat (i, "%U", unformat_ip4_address,
4310 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address)) {
4314 else if (unformat (i, "/%d", &dst_address_length)) {
4315 address_length_set = 1;
4318 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
4319 &v4_next_hop_address)) {
4322 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
4323 &v6_next_hop_address)) {
4326 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4328 else if (unformat (i, "weight %d", &next_hop_weight))
4330 else if (unformat (i, "drop")) {
4332 } else if (unformat (i, "local")) {
4334 } else if (unformat (i, "classify %d", &classify_table_index)) {
4336 } else if (unformat (i, "del"))
4338 else if (unformat (i, "add"))
4340 else if (unformat (i, "not-last"))
4342 else if (unformat (i, "multipath"))
4344 else if (unformat (i, "vrf %d", &vrf_id))
4346 else if (unformat (i, "create-vrf"))
4347 create_vrf_if_needed = 1;
4348 else if (unformat (i, "count %d", &count))
4350 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
4352 else if (unformat (i, "random"))
4354 else if (unformat (i, "seed %d", &random_seed))
4357 clib_warning ("parse error '%U'", format_unformat_error, i);
4362 if (resolve_attempts > 0 && sw_if_index_set == 0) {
4363 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
4367 if (!next_hop_set && !is_drop && !is_local && !is_classify) {
4368 errmsg ("next hop / local / drop / classify not set\n");
4372 if (address_set == 0) {
4373 errmsg ("missing addresses\n");
4377 if (address_length_set == 0) {
4378 errmsg ("missing address length\n");
4382 /* Generate a pile of unique, random routes */
4383 if (random_add_del) {
4384 u32 this_random_address;
4385 random_hash = hash_create (count, sizeof(uword));
4387 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
4388 for (j = 0; j <= count; j++) {
4390 this_random_address = random_u32 (&random_seed);
4391 this_random_address =
4392 clib_host_to_net_u32 (this_random_address);
4393 } while (hash_get (random_hash, this_random_address));
4394 vec_add1 (random_vector, this_random_address);
4395 hash_set (random_hash, this_random_address, 1);
4397 hash_free (random_hash);
4398 v4_dst_address.as_u32 = random_vector[0];
4402 /* Turn on async mode */
4403 vam->async_mode = 1;
4404 vam->async_errors = 0;
4405 before = vat_time_now(vam);
4408 for (j = 0; j < count; j++) {
4409 /* Construct the API message */
4410 M(IP_ADD_DEL_ROUTE, ip_add_del_route);
4412 mp->next_hop_sw_if_index = ntohl (sw_if_index);
4413 mp->vrf_id = ntohl (vrf_id);
4414 if (resolve_attempts > 0) {
4415 mp->resolve_attempts = ntohl (resolve_attempts);
4416 mp->resolve_if_needed = 1;
4418 mp->create_vrf_if_needed = create_vrf_if_needed;
4420 mp->is_add = is_add;
4421 mp->is_drop = is_drop;
4422 mp->is_ipv6 = is_ipv6;
4423 mp->is_local = is_local;
4424 mp->is_classify = is_classify;
4425 mp->is_multipath = is_multipath;
4426 mp->not_last = not_last;
4427 mp->next_hop_weight = next_hop_weight;
4428 mp->dst_address_length = dst_address_length;
4429 mp->lookup_in_vrf = ntohl(lookup_in_vrf);
4430 mp->classify_table_index = ntohl(classify_table_index);
4433 clib_memcpy (mp->dst_address, &v6_dst_address, sizeof (v6_dst_address));
4435 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
4436 sizeof (v6_next_hop_address));
4437 increment_v6_address (&v6_dst_address);
4439 clib_memcpy (mp->dst_address, &v4_dst_address, sizeof (v4_dst_address));
4441 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
4442 sizeof (v4_next_hop_address));
4444 v4_dst_address.as_u32 = random_vector[j+1];
4446 increment_v4_address (&v4_dst_address);
4452 /* When testing multiple add/del ops, use a control-ping to sync */
4454 vl_api_control_ping_t * mp;
4457 /* Shut off async mode */
4458 vam->async_mode = 0;
4460 M(CONTROL_PING, control_ping);
4463 timeout = vat_time_now(vam) + 1.0;
4464 while (vat_time_now (vam) < timeout)
4465 if (vam->result_ready == 1)
4470 if (vam->retval == -99)
4471 errmsg ("timeout\n");
4473 if (vam->async_errors > 0) {
4474 errmsg ("%d asynchronous errors\n", vam->async_errors);
4477 vam->async_errors = 0;
4478 after = vat_time_now(vam);
4480 fformat(vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4481 count, after - before, count / (after - before));
4483 /* Wait for a reply... */
4487 /* Return the good/bad news */
4488 return (vam->retval);
4491 static int api_proxy_arp_add_del (vat_main_t * vam)
4493 unformat_input_t * i = vam->input;
4494 vl_api_proxy_arp_add_del_t *mp;
4498 ip4_address_t lo, hi;
4501 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4502 if (unformat (i, "vrf %d", &vrf_id))
4504 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
4505 unformat_ip4_address, &hi))
4507 else if (unformat (i, "del"))
4510 clib_warning ("parse error '%U'", format_unformat_error, i);
4515 if (range_set == 0) {
4516 errmsg ("address range not set\n");
4520 M(PROXY_ARP_ADD_DEL, proxy_arp_add_del);
4522 mp->vrf_id = ntohl(vrf_id);
4523 mp->is_add = is_add;
4524 clib_memcpy(mp->low_address, &lo, sizeof (mp->low_address));
4525 clib_memcpy(mp->hi_address, &hi, sizeof (mp->hi_address));
4532 static int api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
4534 unformat_input_t * i = vam->input;
4535 vl_api_proxy_arp_intfc_enable_disable_t *mp;
4539 u8 sw_if_index_set = 0;
4541 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4542 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4543 sw_if_index_set = 1;
4544 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4545 sw_if_index_set = 1;
4546 else if (unformat (i, "enable"))
4548 else if (unformat (i, "disable"))
4551 clib_warning ("parse error '%U'", format_unformat_error, i);
4556 if (sw_if_index_set == 0) {
4557 errmsg ("missing interface name or sw_if_index\n");
4561 M(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
4563 mp->sw_if_index = ntohl(sw_if_index);
4564 mp->enable_disable = enable;
4571 static int api_mpls_add_del_decap (vat_main_t * vam)
4573 unformat_input_t * i = vam->input;
4574 vl_api_mpls_add_del_decap_t *mp;
4583 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4584 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4586 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
4588 else if (unformat (i, "label %d", &label))
4590 else if (unformat (i, "next-index %d", &next_index))
4592 else if (unformat (i, "del"))
4594 else if (unformat (i, "s-bit-clear"))
4597 clib_warning ("parse error '%U'", format_unformat_error, i);
4602 M(MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
4604 mp->rx_vrf_id = ntohl(rx_vrf_id);
4605 mp->tx_vrf_id = ntohl(tx_vrf_id);
4606 mp->label = ntohl(label);
4607 mp->next_index = ntohl(next_index);
4609 mp->is_add = is_add;
4616 static int api_mpls_add_del_encap (vat_main_t * vam)
4618 unformat_input_t * i = vam->input;
4619 vl_api_mpls_add_del_encap_t *mp;
4624 ip4_address_t dst_address;
4627 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4628 if (unformat (i, "vrf %d", &vrf_id))
4630 else if (unformat (i, "label %d", &label))
4631 vec_add1 (labels, ntohl(label));
4632 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4634 else if (unformat (i, "del"))
4637 clib_warning ("parse error '%U'", format_unformat_error, i);
4642 if (vec_len (labels) == 0) {
4643 errmsg ("missing encap label stack\n");
4647 M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
4648 sizeof (u32) * vec_len (labels));
4650 mp->vrf_id = ntohl(vrf_id);
4651 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4652 mp->is_add = is_add;
4653 mp->nlabels = vec_len (labels);
4654 clib_memcpy(mp->labels, labels, sizeof(u32)*mp->nlabels);
4663 static int api_mpls_gre_add_del_tunnel (vat_main_t * vam)
4665 unformat_input_t * i = vam->input;
4666 vl_api_mpls_gre_add_del_tunnel_t *mp;
4668 u32 inner_vrf_id = 0;
4669 u32 outer_vrf_id = 0;
4670 ip4_address_t src_address;
4671 ip4_address_t dst_address;
4672 ip4_address_t intfc_address;
4674 u8 intfc_address_length = 0;
4678 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4679 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4681 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4683 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
4685 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4687 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4688 &intfc_address, &tmp))
4689 intfc_address_length = tmp;
4690 else if (unformat (i, "l2-only"))
4692 else if (unformat (i, "del"))
4695 clib_warning ("parse error '%U'", format_unformat_error, i);
4700 M(MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
4702 mp->inner_vrf_id = ntohl(inner_vrf_id);
4703 mp->outer_vrf_id = ntohl(outer_vrf_id);
4704 clib_memcpy(mp->src_address, &src_address, sizeof (src_address));
4705 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4706 clib_memcpy(mp->intfc_address, &intfc_address, sizeof (intfc_address));
4707 mp->intfc_address_length = intfc_address_length;
4708 mp->l2_only = l2_only;
4709 mp->is_add = is_add;
4716 static int api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
4718 unformat_input_t * i = vam->input;
4719 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
4721 u32 inner_vrf_id = 0;
4722 ip4_address_t intfc_address;
4723 u8 dst_mac_address[6];
4726 u8 intfc_address_length = 0;
4730 int tx_sw_if_index_set = 0;
4732 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4733 if (unformat (i, "vrf %d", &inner_vrf_id))
4735 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4736 &intfc_address, &tmp))
4737 intfc_address_length = tmp;
4738 else if (unformat (i, "%U",
4739 unformat_sw_if_index, vam, &tx_sw_if_index))
4740 tx_sw_if_index_set = 1;
4741 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4742 tx_sw_if_index_set = 1;
4743 else if (unformat (i, "dst %U", unformat_ethernet_address,
4746 else if (unformat (i, "l2-only"))
4748 else if (unformat (i, "del"))
4751 clib_warning ("parse error '%U'", format_unformat_error, i);
4757 errmsg ("dst (mac address) not set\n");
4760 if (!tx_sw_if_index_set) {
4761 errmsg ("tx-intfc not set\n");
4765 M(MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
4767 mp->vrf_id = ntohl(inner_vrf_id);
4768 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
4769 mp->adj_address_length = intfc_address_length;
4770 clib_memcpy (mp->dst_mac_address, dst_mac_address, sizeof (dst_mac_address));
4771 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
4772 mp->l2_only = l2_only;
4773 mp->is_add = is_add;
4780 static int api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
4782 unformat_input_t * i = vam->input;
4783 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
4785 u32 inner_vrf_id = 0;
4786 u32 outer_vrf_id = 0;
4787 ip4_address_t adj_address;
4788 int adj_address_set = 0;
4789 ip4_address_t next_hop_address;
4790 int next_hop_address_set = 0;
4792 u8 adj_address_length = 0;
4795 u32 resolve_attempts = 5;
4796 u8 resolve_if_needed = 1;
4798 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4799 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4801 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4803 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4804 &adj_address, &tmp)) {
4805 adj_address_length = tmp;
4806 adj_address_set = 1;
4808 else if (unformat (i, "next-hop %U", unformat_ip4_address,
4810 next_hop_address_set = 1;
4811 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4813 else if (unformat (i, "resolve-if-needed %d", &tmp))
4814 resolve_if_needed = tmp;
4815 else if (unformat (i, "l2-only"))
4817 else if (unformat (i, "del"))
4820 clib_warning ("parse error '%U'", format_unformat_error, i);
4825 if (!adj_address_set) {
4826 errmsg ("adjacency address/mask not set\n");
4829 if (!next_hop_address_set) {
4830 errmsg ("ip4 next hop address (in outer fib) not set\n");
4834 M(MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
4836 mp->inner_vrf_id = ntohl(inner_vrf_id);
4837 mp->outer_vrf_id = ntohl(outer_vrf_id);
4838 mp->resolve_attempts = ntohl(resolve_attempts);
4839 mp->resolve_if_needed = resolve_if_needed;
4840 mp->is_add = is_add;
4841 mp->l2_only = l2_only;
4842 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
4843 mp->adj_address_length = adj_address_length;
4844 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
4845 sizeof (next_hop_address));
4852 static int api_sw_interface_set_unnumbered (vat_main_t * vam)
4854 unformat_input_t * i = vam->input;
4855 vl_api_sw_interface_set_unnumbered_t *mp;
4860 u8 sw_if_index_set = 0;
4862 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4863 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4864 sw_if_index_set = 1;
4865 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4866 sw_if_index_set = 1;
4867 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4869 else if (unformat (i, "del"))
4872 clib_warning ("parse error '%U'", format_unformat_error, i);
4877 if (sw_if_index_set == 0) {
4878 errmsg ("missing interface name or sw_if_index\n");
4882 M(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
4884 mp->sw_if_index = ntohl(sw_if_index);
4885 mp->unnumbered_sw_if_index = ntohl(unnum_sw_index);
4886 mp->is_add = is_add;
4893 static int api_ip_neighbor_add_del (vat_main_t * vam)
4895 unformat_input_t * i = vam->input;
4896 vl_api_ip_neighbor_add_del_t *mp;
4899 u8 sw_if_index_set = 0;
4905 u8 v4_address_set = 0;
4906 u8 v6_address_set = 0;
4907 ip4_address_t v4address;
4908 ip6_address_t v6address;
4910 memset (mac_address, 0, sizeof (mac_address));
4912 /* Parse args required to build the message */
4913 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4914 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4917 else if (unformat (i, "del"))
4919 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4920 sw_if_index_set = 1;
4921 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4922 sw_if_index_set = 1;
4923 else if (unformat (i, "is_static"))
4925 else if (unformat (i, "vrf %d", &vrf_id))
4927 else if (unformat (i, "dst %U",
4928 unformat_ip4_address, &v4address))
4930 else if (unformat (i, "dst %U",
4931 unformat_ip6_address, &v6address))
4934 clib_warning ("parse error '%U'", format_unformat_error, i);
4939 if (sw_if_index_set == 0) {
4940 errmsg ("missing interface name or sw_if_index\n");
4943 if (v4_address_set && v6_address_set) {
4944 errmsg ("both v4 and v6 addresses set\n");
4947 if (!v4_address_set && !v6_address_set) {
4948 errmsg ("no addresses set\n");
4952 /* Construct the API message */
4953 M(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
4955 mp->sw_if_index = ntohl (sw_if_index);
4956 mp->is_add = is_add;
4957 mp->vrf_id = ntohl (vrf_id);
4958 mp->is_static = is_static;
4960 clib_memcpy (mp->mac_address, mac_address, 6);
4961 if (v6_address_set) {
4963 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
4965 /* mp->is_ipv6 = 0; via memset in M macro above */
4966 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
4972 /* Wait for a reply, return good/bad news */
4979 static int api_reset_vrf (vat_main_t * vam)
4981 unformat_input_t * i = vam->input;
4982 vl_api_reset_vrf_t *mp;
4988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4989 if (unformat (i, "vrf %d", &vrf_id))
4991 else if (unformat (i, "ipv6"))
4994 clib_warning ("parse error '%U'", format_unformat_error, i);
4999 if (vrf_id_set == 0) {
5000 errmsg ("missing vrf id\n");
5004 M(RESET_VRF, reset_vrf);
5006 mp->vrf_id = ntohl(vrf_id);
5007 mp->is_ipv6 = is_ipv6;
5014 static int api_create_vlan_subif (vat_main_t * vam)
5016 unformat_input_t * i = vam->input;
5017 vl_api_create_vlan_subif_t *mp;
5020 u8 sw_if_index_set = 0;
5024 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5025 if (unformat (i, "sw_if_index %d", &sw_if_index))
5026 sw_if_index_set = 1;
5027 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5028 sw_if_index_set = 1;
5029 else if (unformat (i, "vlan %d", &vlan_id))
5032 clib_warning ("parse error '%U'", format_unformat_error, i);
5037 if (sw_if_index_set == 0) {
5038 errmsg ("missing interface name or sw_if_index\n");
5042 if (vlan_id_set == 0) {
5043 errmsg ("missing vlan_id\n");
5046 M(CREATE_VLAN_SUBIF, create_vlan_subif);
5048 mp->sw_if_index = ntohl(sw_if_index);
5049 mp->vlan_id = ntohl(vlan_id);
5056 #define foreach_create_subif_bit \
5063 _(outer_vlan_id_any) \
5064 _(inner_vlan_id_any)
5066 static int api_create_subif (vat_main_t * vam)
5068 unformat_input_t * i = vam->input;
5069 vl_api_create_subif_t *mp;
5072 u8 sw_if_index_set = 0;
5079 u32 exact_match = 0;
5080 u32 default_sub = 0;
5081 u32 outer_vlan_id_any = 0;
5082 u32 inner_vlan_id_any = 0;
5084 u16 outer_vlan_id = 0;
5085 u16 inner_vlan_id = 0;
5087 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5088 if (unformat (i, "sw_if_index %d", &sw_if_index))
5089 sw_if_index_set = 1;
5090 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5091 sw_if_index_set = 1;
5092 else if (unformat (i, "sub_id %d", &sub_id))
5094 else if (unformat (i, "outer_vlan_id %d", &tmp))
5095 outer_vlan_id = tmp;
5096 else if (unformat (i, "inner_vlan_id %d", &tmp))
5097 inner_vlan_id = tmp;
5099 #define _(a) else if (unformat (i, #a)) a = 1 ;
5100 foreach_create_subif_bit
5104 clib_warning ("parse error '%U'", format_unformat_error, i);
5109 if (sw_if_index_set == 0) {
5110 errmsg ("missing interface name or sw_if_index\n");
5114 if (sub_id_set == 0) {
5115 errmsg ("missing sub_id\n");
5118 M(CREATE_SUBIF, create_subif);
5120 mp->sw_if_index = ntohl(sw_if_index);
5121 mp->sub_id = ntohl(sub_id);
5123 #define _(a) mp->a = a;
5124 foreach_create_subif_bit;
5127 mp->outer_vlan_id = ntohs (outer_vlan_id);
5128 mp->inner_vlan_id = ntohs (inner_vlan_id);
5135 static int api_oam_add_del (vat_main_t * vam)
5137 unformat_input_t * i = vam->input;
5138 vl_api_oam_add_del_t *mp;
5142 ip4_address_t src, dst;
5146 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5147 if (unformat (i, "vrf %d", &vrf_id))
5149 else if (unformat (i, "src %U", unformat_ip4_address, &src))
5151 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
5153 else if (unformat (i, "del"))
5156 clib_warning ("parse error '%U'", format_unformat_error, i);
5162 errmsg ("missing src addr\n");
5167 errmsg ("missing dst addr\n");
5171 M(OAM_ADD_DEL, oam_add_del);
5173 mp->vrf_id = ntohl(vrf_id);
5174 mp->is_add = is_add;
5175 clib_memcpy(mp->src_address, &src, sizeof (mp->src_address));
5176 clib_memcpy(mp->dst_address, &dst, sizeof (mp->dst_address));
5183 static int api_reset_fib (vat_main_t * vam)
5185 unformat_input_t * i = vam->input;
5186 vl_api_reset_fib_t *mp;
5192 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5193 if (unformat (i, "vrf %d", &vrf_id))
5195 else if (unformat (i, "ipv6"))
5198 clib_warning ("parse error '%U'", format_unformat_error, i);
5203 if (vrf_id_set == 0) {
5204 errmsg ("missing vrf id\n");
5208 M(RESET_FIB, reset_fib);
5210 mp->vrf_id = ntohl(vrf_id);
5211 mp->is_ipv6 = is_ipv6;
5218 static int api_dhcp_proxy_config (vat_main_t * vam)
5220 unformat_input_t * i = vam->input;
5221 vl_api_dhcp_proxy_config_t *mp;
5226 u8 v4_address_set = 0;
5227 u8 v6_address_set = 0;
5228 ip4_address_t v4address;
5229 ip6_address_t v6address;
5230 u8 v4_src_address_set = 0;
5231 u8 v6_src_address_set = 0;
5232 ip4_address_t v4srcaddress;
5233 ip6_address_t v6srcaddress;
5235 /* Parse args required to build the message */
5236 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5237 if (unformat (i, "del"))
5239 else if (unformat (i, "vrf %d", &vrf_id))
5241 else if (unformat (i, "insert-cid %d", &insert_cid))
5243 else if (unformat (i, "svr %U",
5244 unformat_ip4_address, &v4address))
5246 else if (unformat (i, "svr %U",
5247 unformat_ip6_address, &v6address))
5249 else if (unformat (i, "src %U",
5250 unformat_ip4_address, &v4srcaddress))
5251 v4_src_address_set = 1;
5252 else if (unformat (i, "src %U",
5253 unformat_ip6_address, &v6srcaddress))
5254 v6_src_address_set = 1;
5259 if (v4_address_set && v6_address_set) {
5260 errmsg ("both v4 and v6 server addresses set\n");
5263 if (!v4_address_set && !v6_address_set) {
5264 errmsg ("no server addresses set\n");
5268 if (v4_src_address_set && v6_src_address_set) {
5269 errmsg ("both v4 and v6 src addresses set\n");
5272 if (!v4_src_address_set && !v6_src_address_set) {
5273 errmsg ("no src addresses set\n");
5277 if (!(v4_src_address_set && v4_address_set) &&
5278 !(v6_src_address_set && v6_address_set)) {
5279 errmsg ("no matching server and src addresses set\n");
5283 /* Construct the API message */
5284 M(DHCP_PROXY_CONFIG, dhcp_proxy_config);
5286 mp->insert_circuit_id = insert_cid;
5287 mp->is_add = is_add;
5288 mp->vrf_id = ntohl (vrf_id);
5289 if (v6_address_set) {
5291 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5292 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5294 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5295 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5301 /* Wait for a reply, return good/bad news */
5307 static int api_dhcp_proxy_config_2 (vat_main_t * vam)
5309 unformat_input_t * i = vam->input;
5310 vl_api_dhcp_proxy_config_2_t *mp;
5313 u32 server_vrf_id = 0;
5316 u8 v4_address_set = 0;
5317 u8 v6_address_set = 0;
5318 ip4_address_t v4address;
5319 ip6_address_t v6address;
5320 u8 v4_src_address_set = 0;
5321 u8 v6_src_address_set = 0;
5322 ip4_address_t v4srcaddress;
5323 ip6_address_t v6srcaddress;
5325 /* Parse args required to build the message */
5326 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5327 if (unformat (i, "del"))
5329 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
5331 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
5333 else if (unformat (i, "insert-cid %d", &insert_cid))
5335 else if (unformat (i, "svr %U",
5336 unformat_ip4_address, &v4address))
5338 else if (unformat (i, "svr %U",
5339 unformat_ip6_address, &v6address))
5341 else if (unformat (i, "src %U",
5342 unformat_ip4_address, &v4srcaddress))
5343 v4_src_address_set = 1;
5344 else if (unformat (i, "src %U",
5345 unformat_ip6_address, &v6srcaddress))
5346 v6_src_address_set = 1;
5351 if (v4_address_set && v6_address_set) {
5352 errmsg ("both v4 and v6 server addresses set\n");
5355 if (!v4_address_set && !v6_address_set) {
5356 errmsg ("no server addresses set\n");
5360 if (v4_src_address_set && v6_src_address_set) {
5361 errmsg ("both v4 and v6 src addresses set\n");
5364 if (!v4_src_address_set && !v6_src_address_set) {
5365 errmsg ("no src addresses set\n");
5369 if (!(v4_src_address_set && v4_address_set) &&
5370 !(v6_src_address_set && v6_address_set)) {
5371 errmsg ("no matching server and src addresses set\n");
5375 /* Construct the API message */
5376 M(DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
5378 mp->insert_circuit_id = insert_cid;
5379 mp->is_add = is_add;
5380 mp->rx_vrf_id = ntohl (rx_vrf_id);
5381 mp->server_vrf_id = ntohl (server_vrf_id);
5382 if (v6_address_set) {
5384 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5385 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5387 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5388 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5394 /* Wait for a reply, return good/bad news */
5400 static int api_dhcp_proxy_set_vss (vat_main_t * vam)
5402 unformat_input_t * i = vam->input;
5403 vl_api_dhcp_proxy_set_vss_t *mp;
5414 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5415 if (unformat (i, "tbl_id %d", &tbl_id))
5417 if (unformat (i, "fib_id %d", &fib_id))
5419 if (unformat (i, "oui %d", &oui))
5421 else if (unformat (i, "ipv6"))
5423 else if (unformat (i, "del"))
5426 clib_warning ("parse error '%U'", format_unformat_error, i);
5431 if (tbl_id_set == 0) {
5432 errmsg ("missing tbl id\n");
5436 if (fib_id_set == 0) {
5437 errmsg ("missing fib id\n");
5441 errmsg ("missing oui\n");
5445 M(DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
5446 mp->tbl_id = ntohl(tbl_id);
5447 mp->fib_id = ntohl(fib_id);
5448 mp->oui = ntohl(oui);
5449 mp->is_ipv6 = is_ipv6;
5450 mp->is_add = is_add;
5457 static int api_dhcp_client_config (vat_main_t * vam)
5459 unformat_input_t * i = vam->input;
5460 vl_api_dhcp_client_config_t *mp;
5463 u8 sw_if_index_set = 0;
5466 u8 disable_event = 0;
5468 /* Parse args required to build the message */
5469 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5470 if (unformat (i, "del"))
5472 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5473 sw_if_index_set = 1;
5474 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5475 sw_if_index_set = 1;
5476 else if (unformat (i, "hostname %s", &hostname))
5478 else if (unformat (i, "disable_event"))
5484 if (sw_if_index_set == 0) {
5485 errmsg ("missing interface name or sw_if_index\n");
5489 if (vec_len (hostname) > 63) {
5490 errmsg ("hostname too long\n");
5492 vec_add1 (hostname, 0);
5494 /* Construct the API message */
5495 M(DHCP_CLIENT_CONFIG, dhcp_client_config);
5497 mp->sw_if_index = ntohl (sw_if_index);
5498 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
5499 vec_free (hostname);
5500 mp->is_add = is_add;
5501 mp->want_dhcp_event = disable_event ? 0 : 1;
5507 /* Wait for a reply, return good/bad news */
5513 static int api_set_ip_flow_hash (vat_main_t * vam)
5515 unformat_input_t * i = vam->input;
5516 vl_api_set_ip_flow_hash_t *mp;
5528 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5529 if (unformat (i, "vrf %d", &vrf_id))
5531 else if (unformat (i, "ipv6"))
5533 else if (unformat (i, "src"))
5535 else if (unformat (i, "dst"))
5537 else if (unformat (i, "sport"))
5539 else if (unformat (i, "dport"))
5541 else if (unformat (i, "proto"))
5543 else if (unformat (i, "reverse"))
5547 clib_warning ("parse error '%U'", format_unformat_error, i);
5552 if (vrf_id_set == 0) {
5553 errmsg ("missing vrf id\n");
5557 M(SET_IP_FLOW_HASH, set_ip_flow_hash);
5563 mp->reverse = reverse;
5564 mp->vrf_id = ntohl(vrf_id);
5565 mp->is_ipv6 = is_ipv6;
5572 static int api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5574 unformat_input_t * i = vam->input;
5575 vl_api_sw_interface_ip6_enable_disable_t *mp;
5578 u8 sw_if_index_set = 0;
5581 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5582 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5583 sw_if_index_set = 1;
5584 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5585 sw_if_index_set = 1;
5586 else if (unformat (i, "enable"))
5588 else if (unformat (i, "disable"))
5591 clib_warning ("parse error '%U'", format_unformat_error, i);
5596 if (sw_if_index_set == 0) {
5597 errmsg ("missing interface name or sw_if_index\n");
5601 M(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
5603 mp->sw_if_index = ntohl(sw_if_index);
5604 mp->enable = enable;
5611 static int api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
5613 unformat_input_t * i = vam->input;
5614 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
5617 u8 sw_if_index_set = 0;
5618 u32 address_length = 0;
5619 u8 v6_address_set = 0;
5620 ip6_address_t v6address;
5622 /* Parse args required to build the message */
5623 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5624 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5625 sw_if_index_set = 1;
5626 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5627 sw_if_index_set = 1;
5628 else if (unformat (i, "%U/%d",
5629 unformat_ip6_address, &v6address,
5636 if (sw_if_index_set == 0) {
5637 errmsg ("missing interface name or sw_if_index\n");
5640 if (!v6_address_set) {
5641 errmsg ("no address set\n");
5645 /* Construct the API message */
5646 M(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \
5647 sw_interface_ip6_set_link_local_address);
5649 mp->sw_if_index = ntohl (sw_if_index);
5650 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5651 mp->address_length = address_length;
5656 /* Wait for a reply, return good/bad news */
5664 static int api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
5666 unformat_input_t * i = vam->input;
5667 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
5670 u8 sw_if_index_set = 0;
5671 u32 address_length = 0;
5672 u8 v6_address_set = 0;
5673 ip6_address_t v6address;
5675 u8 no_advertise = 0;
5677 u8 no_autoconfig = 0;
5680 u32 val_lifetime = 0;
5681 u32 pref_lifetime = 0;
5683 /* Parse args required to build the message */
5684 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5685 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5686 sw_if_index_set = 1;
5687 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5688 sw_if_index_set = 1;
5689 else if (unformat (i, "%U/%d",
5690 unformat_ip6_address, &v6address,
5693 else if (unformat (i, "val_life %d", &val_lifetime))
5695 else if (unformat (i, "pref_life %d", &pref_lifetime))
5697 else if (unformat (i, "def"))
5699 else if (unformat (i, "noadv"))
5701 else if (unformat (i, "offl"))
5703 else if (unformat (i, "noauto"))
5705 else if (unformat (i, "nolink"))
5707 else if (unformat (i, "isno"))
5710 clib_warning ("parse error '%U'", format_unformat_error, i);
5715 if (sw_if_index_set == 0) {
5716 errmsg ("missing interface name or sw_if_index\n");
5719 if (!v6_address_set) {
5720 errmsg ("no address set\n");
5724 /* Construct the API message */
5725 M(SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
5727 mp->sw_if_index = ntohl (sw_if_index);
5728 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5729 mp->address_length = address_length;
5730 mp->use_default = use_default;
5731 mp->no_advertise = no_advertise;
5732 mp->off_link = off_link;
5733 mp->no_autoconfig = no_autoconfig;
5734 mp->no_onlink = no_onlink;
5736 mp->val_lifetime = ntohl(val_lifetime);
5737 mp->pref_lifetime = ntohl(pref_lifetime);
5742 /* Wait for a reply, return good/bad news */
5749 static int api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
5751 unformat_input_t * i = vam->input;
5752 vl_api_sw_interface_ip6nd_ra_config_t *mp;
5755 u8 sw_if_index_set = 0;
5760 u8 send_unicast = 0;
5763 u8 default_router = 0;
5764 u32 max_interval = 0;
5765 u32 min_interval = 0;
5767 u32 initial_count = 0;
5768 u32 initial_interval = 0;
5771 /* Parse args required to build the message */
5772 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5773 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5774 sw_if_index_set = 1;
5775 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5776 sw_if_index_set = 1;
5777 else if (unformat (i, "maxint %d", &max_interval))
5779 else if (unformat (i, "minint %d", &min_interval))
5781 else if (unformat (i, "life %d", &lifetime))
5783 else if (unformat (i, "count %d", &initial_count))
5785 else if (unformat (i, "interval %d", &initial_interval))
5787 else if (unformat (i, "suppress") || unformat (i, "surpress"))
5789 else if (unformat (i, "managed"))
5791 else if (unformat (i, "other"))
5793 else if (unformat (i, "ll"))
5795 else if (unformat (i, "send"))
5797 else if (unformat (i, "cease"))
5799 else if (unformat (i, "isno"))
5801 else if (unformat (i, "def"))
5804 clib_warning ("parse error '%U'", format_unformat_error, i);
5809 if (sw_if_index_set == 0) {
5810 errmsg ("missing interface name or sw_if_index\n");
5814 /* Construct the API message */
5815 M(SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
5817 mp->sw_if_index = ntohl (sw_if_index);
5818 mp->max_interval = ntohl(max_interval);
5819 mp->min_interval = ntohl(min_interval);
5820 mp->lifetime = ntohl(lifetime);
5821 mp->initial_count = ntohl(initial_count);
5822 mp->initial_interval = ntohl(initial_interval);
5823 mp->suppress = suppress;
5824 mp->managed = managed;
5826 mp->ll_option = ll_option;
5827 mp->send_unicast = send_unicast;
5830 mp->default_router = default_router;
5835 /* Wait for a reply, return good/bad news */
5842 static int api_set_arp_neighbor_limit (vat_main_t * vam)
5844 unformat_input_t * i = vam->input;
5845 vl_api_set_arp_neighbor_limit_t *mp;
5851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5852 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
5854 else if (unformat (i, "ipv6"))
5857 clib_warning ("parse error '%U'", format_unformat_error, i);
5862 if (limit_set == 0) {
5863 errmsg ("missing limit value\n");
5867 M(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
5869 mp->arp_neighbor_limit = ntohl(arp_nbr_limit);
5870 mp->is_ipv6 = is_ipv6;
5877 static int api_l2_patch_add_del (vat_main_t * vam)
5879 unformat_input_t * i = vam->input;
5880 vl_api_l2_patch_add_del_t *mp;
5883 u8 rx_sw_if_index_set = 0;
5885 u8 tx_sw_if_index_set = 0;
5888 /* Parse args required to build the message */
5889 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5890 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5891 rx_sw_if_index_set = 1;
5892 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5893 tx_sw_if_index_set = 1;
5894 else if (unformat (i, "rx")) {
5895 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5896 if (unformat (i, "%U", unformat_sw_if_index, vam,
5898 rx_sw_if_index_set = 1;
5901 } else if (unformat (i, "tx")) {
5902 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5903 if (unformat (i, "%U", unformat_sw_if_index, vam,
5905 tx_sw_if_index_set = 1;
5908 } else if (unformat (i, "del"))
5914 if (rx_sw_if_index_set == 0) {
5915 errmsg ("missing rx interface name or rx_sw_if_index\n");
5919 if (tx_sw_if_index_set == 0) {
5920 errmsg ("missing tx interface name or tx_sw_if_index\n");
5924 M(L2_PATCH_ADD_DEL, l2_patch_add_del);
5926 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
5927 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
5928 mp->is_add = is_add;
5934 static int api_trace_profile_add (vat_main_t *vam)
5936 unformat_input_t * input = vam->input;
5937 vl_api_trace_profile_add_t *mp;
5940 u32 trace_option_elts = 0;
5941 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
5942 int has_pow_option = 0;
5943 int has_ppc_option = 0;
5945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5947 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
5948 "trace-tsp %d node-id 0x%x app-data 0x%x",
5949 &id, &trace_type, &trace_option_elts, &trace_tsp,
5950 &node_id, &app_data))
5952 else if (unformat (input, "pow"))
5954 else if (unformat (input, "ppc encap"))
5955 has_ppc_option = PPC_ENCAP;
5956 else if (unformat (input, "ppc decap"))
5957 has_ppc_option = PPC_DECAP;
5958 else if (unformat (input, "ppc none"))
5959 has_ppc_option = PPC_NONE;
5963 M(TRACE_PROFILE_ADD, trace_profile_add);
5965 mp->trace_type = trace_type;
5966 mp->trace_num_elt = trace_option_elts;
5967 mp->trace_ppc = has_ppc_option;
5968 mp->trace_app_data = htonl(app_data);
5969 mp->pow_enable = has_pow_option;
5970 mp->trace_tsp = trace_tsp;
5971 mp->node_id = htonl(node_id);
5978 static int api_trace_profile_apply (vat_main_t *vam)
5980 unformat_input_t * input = vam->input;
5981 vl_api_trace_profile_apply_t *mp;
5984 u32 mask_width = ~0;
5991 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5993 if (unformat (input, "%U/%d",
5994 unformat_ip6_address, &addr, &mask_width))
5996 else if (unformat (input, "id %d", &id))
5998 else if (unformat (input, "vrf-id %d", &vrf_id))
6000 else if (unformat (input, "add"))
6002 else if (unformat (input, "pop"))
6004 else if (unformat (input, "none"))
6010 if ((is_add + is_pop + is_none) != 1) {
6011 errmsg("One of (add, pop, none) required");
6014 if (mask_width == ~0) {
6015 errmsg("<address>/<mask-width> required");
6018 M(TRACE_PROFILE_APPLY, trace_profile_apply);
6019 clib_memcpy(mp->dest_ipv6, &addr, sizeof(mp->dest_ipv6));
6021 mp->prefix_length = htonl(mask_width);
6022 mp->vrf_id = htonl(vrf_id);
6024 mp->trace_op = IOAM_HBYH_ADD;
6026 mp->trace_op = IOAM_HBYH_POP;
6028 mp->trace_op = IOAM_HBYH_MOD;
6040 static int api_trace_profile_del (vat_main_t *vam)
6042 vl_api_trace_profile_del_t *mp;
6045 M(TRACE_PROFILE_DEL, trace_profile_del);
6050 static int api_sr_tunnel_add_del (vat_main_t * vam)
6052 unformat_input_t * i = vam->input;
6053 vl_api_sr_tunnel_add_del_t *mp;
6057 ip6_address_t src_address;
6058 int src_address_set = 0;
6059 ip6_address_t dst_address;
6061 int dst_address_set = 0;
6063 u32 rx_table_id = 0;
6064 u32 tx_table_id = 0;
6065 ip6_address_t * segments = 0;
6066 ip6_address_t * this_seg;
6067 ip6_address_t * tags = 0;
6068 ip6_address_t * this_tag;
6069 ip6_address_t next_address, tag;
6071 u8 * policy_name = 0;
6073 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
6075 if (unformat (i, "del"))
6077 else if (unformat (i, "name %s", &name))
6079 else if (unformat (i, "policy %s", &policy_name))
6081 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
6083 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
6085 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
6086 src_address_set = 1;
6087 else if (unformat (i, "dst %U/%d",
6088 unformat_ip6_address, &dst_address,
6090 dst_address_set = 1;
6091 else if (unformat (i, "next %U", unformat_ip6_address,
6094 vec_add2 (segments, this_seg, 1);
6095 clib_memcpy (this_seg->as_u8, next_address.as_u8, sizeof (*this_seg));
6097 else if (unformat (i, "tag %U", unformat_ip6_address,
6100 vec_add2 (tags, this_tag, 1);
6101 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
6103 else if (unformat (i, "clean"))
6104 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
6105 else if (unformat (i, "protected"))
6106 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
6107 else if (unformat (i, "InPE %d", &pl_index))
6109 if (pl_index <= 0 || pl_index > 4)
6111 pl_index_range_error:
6112 errmsg ("pl index %d out of range\n", pl_index);
6115 flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3*(pl_index - 1));
6117 else if (unformat (i, "EgPE %d", &pl_index))
6119 if (pl_index <= 0 || pl_index > 4)
6120 goto pl_index_range_error;
6121 flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3*(pl_index - 1));
6123 else if (unformat (i, "OrgSrc %d", &pl_index))
6125 if (pl_index <= 0 || pl_index > 4)
6126 goto pl_index_range_error;
6127 flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3*(pl_index - 1));
6133 if (!src_address_set)
6135 errmsg ("src address required\n");
6139 if (!dst_address_set)
6141 errmsg ("dst address required\n");
6147 errmsg ("at least one sr segment required\n");
6151 M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
6152 vec_len(segments) * sizeof (ip6_address_t)
6153 + vec_len(tags) * sizeof (ip6_address_t));
6155 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
6156 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
6157 mp->dst_mask_width = dst_mask_width;
6158 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
6159 mp->n_segments = vec_len (segments);
6160 mp->n_tags = vec_len (tags);
6161 mp->is_add = is_del == 0;
6162 clib_memcpy (mp->segs_and_tags, segments,
6163 vec_len(segments)* sizeof (ip6_address_t));
6164 clib_memcpy (mp->segs_and_tags + vec_len(segments)*sizeof (ip6_address_t),
6165 tags, vec_len(tags)* sizeof (ip6_address_t));
6167 mp->outer_vrf_id = ntohl (rx_table_id);
6168 mp->inner_vrf_id = ntohl (tx_table_id);
6169 memcpy (mp->name, name, vec_len(name));
6170 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
6172 vec_free (segments);
6179 static int api_sr_policy_add_del (vat_main_t * vam)
6181 unformat_input_t * input = vam->input;
6182 vl_api_sr_policy_add_del_t *mp;
6186 u8 * tunnel_name = 0;
6187 u8 ** tunnel_names = 0;
6192 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
6193 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
6195 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6197 if (unformat (input, "del"))
6199 else if (unformat (input, "name %s", &name))
6201 else if (unformat (input, "tunnel %s", &tunnel_name))
6205 vec_add1 (tunnel_names, tunnel_name);
6207 - length = #bytes to store in serial vector
6208 - +1 = byte to store that length
6210 tunnel_names_length += (vec_len (tunnel_name) + 1);
6221 errmsg ("policy name required\n");
6225 if ((!tunnel_set) && (!is_del))
6227 errmsg ("tunnel name required\n");
6231 M2(SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
6235 mp->is_add = !is_del;
6237 memcpy (mp->name, name, vec_len(name));
6238 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
6239 u8 * serial_orig = 0;
6240 vec_validate (serial_orig, tunnel_names_length);
6241 *serial_orig = vec_len(tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
6242 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
6244 for (j=0; j < vec_len(tunnel_names); j++)
6246 tun_name_len = vec_len (tunnel_names[j]);
6247 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
6248 serial_orig += 1; // Move along one byte to store the actual tunnel name
6249 memcpy (serial_orig, tunnel_names[j], tun_name_len);
6250 serial_orig += tun_name_len; // Advance past the copy
6252 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
6254 vec_free (tunnel_names);
6255 vec_free (tunnel_name);
6261 static int api_sr_multicast_map_add_del (vat_main_t * vam)
6263 unformat_input_t * input = vam->input;
6264 vl_api_sr_multicast_map_add_del_t *mp;
6267 ip6_address_t multicast_address;
6268 u8 * policy_name = 0;
6269 int multicast_address_set = 0;
6271 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6273 if (unformat (input, "del"))
6275 else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address))
6276 multicast_address_set = 1;
6277 else if (unformat (input, "sr-policy %s", &policy_name))
6283 if (!is_del && !policy_name)
6285 errmsg ("sr-policy name required\n");
6290 if (!multicast_address_set)
6292 errmsg ("address required\n");
6296 M(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
6298 mp->is_add = !is_del;
6299 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
6300 clib_memcpy (mp->multicast_address, &multicast_address, sizeof (mp->multicast_address));
6303 vec_free (policy_name);
6310 #define foreach_ip4_proto_field \
6320 uword unformat_ip4_mask (unformat_input_t * input, va_list * args)
6322 u8 ** maskp = va_arg (*args, u8 **);
6324 u8 found_something = 0;
6327 #define _(a) u8 a=0;
6328 foreach_ip4_proto_field;
6334 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6336 if (unformat (input, "version"))
6338 else if (unformat (input, "hdr_length"))
6340 else if (unformat (input, "src"))
6342 else if (unformat (input, "dst"))
6344 else if (unformat (input, "proto"))
6347 #define _(a) else if (unformat (input, #a)) a=1;
6348 foreach_ip4_proto_field
6354 #define _(a) found_something += a;
6355 foreach_ip4_proto_field;
6358 if (found_something == 0)
6361 vec_validate (mask, sizeof (*ip) - 1);
6363 ip = (ip4_header_t *) mask;
6365 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6366 foreach_ip4_proto_field;
6369 ip->ip_version_and_header_length = 0;
6372 ip->ip_version_and_header_length |= 0xF0;
6375 ip->ip_version_and_header_length |= 0x0F;
6381 #define foreach_ip6_proto_field \
6388 uword unformat_ip6_mask (unformat_input_t * input, va_list * args)
6390 u8 ** maskp = va_arg (*args, u8 **);
6392 u8 found_something = 0;
6394 u32 ip_version_traffic_class_and_flow_label;
6396 #define _(a) u8 a=0;
6397 foreach_ip6_proto_field;
6400 u8 traffic_class = 0;
6403 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6405 if (unformat (input, "version"))
6407 else if (unformat (input, "traffic-class"))
6409 else if (unformat (input, "flow-label"))
6411 else if (unformat (input, "src"))
6413 else if (unformat (input, "dst"))
6415 else if (unformat (input, "proto"))
6418 #define _(a) else if (unformat (input, #a)) a=1;
6419 foreach_ip6_proto_field
6425 #define _(a) found_something += a;
6426 foreach_ip6_proto_field;
6429 if (found_something == 0)
6432 vec_validate (mask, sizeof (*ip) - 1);
6434 ip = (ip6_header_t *) mask;
6436 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6437 foreach_ip6_proto_field;
6440 ip_version_traffic_class_and_flow_label = 0;
6443 ip_version_traffic_class_and_flow_label |= 0xF0000000;
6446 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
6449 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
6451 ip->ip_version_traffic_class_and_flow_label =
6452 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6458 uword unformat_l3_mask (unformat_input_t * input, va_list * args)
6460 u8 ** maskp = va_arg (*args, u8 **);
6462 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6463 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
6465 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
6473 uword unformat_l2_mask (unformat_input_t * input, va_list * args)
6475 u8 ** maskp = va_arg (*args, u8 **);
6490 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6491 if (unformat (input, "src"))
6493 else if (unformat (input, "dst"))
6495 else if (unformat (input, "proto"))
6497 else if (unformat (input, "tag1"))
6499 else if (unformat (input, "tag2"))
6501 else if (unformat (input, "ignore-tag1"))
6503 else if (unformat (input, "ignore-tag2"))
6505 else if (unformat (input, "cos1"))
6507 else if (unformat (input, "cos2"))
6509 else if (unformat (input, "dot1q"))
6511 else if (unformat (input, "dot1ad"))
6516 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
6517 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6520 if (tag1 || ignore_tag1 || cos1 || dot1q)
6522 if (tag2 || ignore_tag2 || cos2 || dot1ad)
6525 vec_validate (mask, len-1);
6528 memset (mask, 0xff, 6);
6531 memset (mask + 6, 0xff, 6);
6535 /* inner vlan tag */
6544 mask[21] = mask [20] = 0xff;
6565 mask[16] = mask [17] = 0xff;
6575 mask[12] = mask [13] = 0xff;
6581 uword unformat_classify_mask (unformat_input_t * input, va_list * args)
6583 u8 ** maskp = va_arg (*args, u8 **);
6584 u32 * skipp = va_arg (*args, u32 *);
6585 u32 * matchp = va_arg (*args, u32 *);
6592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6593 if (unformat (input, "hex %U", unformat_hex_string, &mask))
6595 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
6597 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
6603 if (mask || l2 || l3)
6607 /* "With a free Ethernet header in every package" */
6609 vec_validate (l2, 13);
6611 vec_append (mask, l3);
6615 /* Scan forward looking for the first significant mask octet */
6616 for (i = 0; i < vec_len (mask); i++)
6620 /* compute (skip, match) params */
6621 *skipp = i / sizeof(u32x4);
6622 vec_delete (mask, *skipp * sizeof(u32x4), 0);
6624 /* Pad mask to an even multiple of the vector size */
6625 while (vec_len (mask) % sizeof (u32x4))
6628 match = vec_len (mask) / sizeof (u32x4);
6630 for (i = match*sizeof(u32x4); i > 0; i-= sizeof(u32x4))
6632 u64 *tmp = (u64 *)(mask + (i-sizeof(u32x4)));
6633 if (*tmp || *(tmp+1))
6638 clib_warning ("BUG: match 0");
6640 _vec_len (mask) = match * sizeof(u32x4);
6651 #define foreach_l2_next \
6653 _(ethernet, ETHERNET_INPUT) \
6657 uword unformat_l2_next_index (unformat_input_t * input, va_list * args)
6659 u32 * miss_next_indexp = va_arg (*args, u32 *);
6664 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
6668 if (unformat (input, "%d", &tmp))
6677 *miss_next_indexp = next_index;
6681 #define foreach_ip_next \
6687 uword unformat_ip_next_index (unformat_input_t * input, va_list * args)
6689 u32 * miss_next_indexp = va_arg (*args, u32 *);
6694 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
6698 if (unformat (input, "%d", &tmp))
6707 *miss_next_indexp = next_index;
6711 #define foreach_acl_next \
6714 uword unformat_acl_next_index (unformat_input_t * input, va_list * args)
6716 u32 * miss_next_indexp = va_arg (*args, u32 *);
6721 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
6725 if (unformat (input, "permit"))
6730 else if (unformat (input, "%d", &tmp))
6739 *miss_next_indexp = next_index;
6743 static int api_classify_add_del_table (vat_main_t * vam)
6745 unformat_input_t * i = vam->input;
6746 vl_api_classify_add_del_table_t *mp;
6752 u32 table_index = ~0;
6753 u32 next_table_index = ~0;
6754 u32 miss_next_index = ~0;
6755 u32 memory_size = 32<<20;
6759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6760 if (unformat (i, "del"))
6762 else if (unformat (i, "buckets %d", &nbuckets))
6764 else if (unformat (i, "memory_size %d", &memory_size))
6766 else if (unformat (i, "skip %d", &skip))
6768 else if (unformat (i, "match %d", &match))
6770 else if (unformat (i, "table %d", &table_index))
6772 else if (unformat (i, "mask %U", unformat_classify_mask,
6773 &mask, &skip, &match))
6775 else if (unformat (i, "next-table %d", &next_table_index))
6777 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
6780 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
6783 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
6790 if (is_add && mask == 0) {
6791 errmsg ("Mask required\n");
6795 if (is_add && skip == ~0) {
6796 errmsg ("skip count required\n");
6800 if (is_add && match == ~0) {
6801 errmsg ("match count required\n");
6805 if (!is_add && table_index == ~0) {
6806 errmsg ("table index required for delete\n");
6810 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table,
6813 mp->is_add = is_add;
6814 mp->table_index = ntohl(table_index);
6815 mp->nbuckets = ntohl(nbuckets);
6816 mp->memory_size = ntohl(memory_size);
6817 mp->skip_n_vectors = ntohl(skip);
6818 mp->match_n_vectors = ntohl(match);
6819 mp->next_table_index = ntohl(next_table_index);
6820 mp->miss_next_index = ntohl(miss_next_index);
6821 clib_memcpy (mp->mask, mask, vec_len(mask));
6829 uword unformat_ip4_match (unformat_input_t * input, va_list * args)
6831 u8 ** matchp = va_arg (*args, u8 **);
6838 int src = 0, dst = 0;
6839 ip4_address_t src_val, dst_val;
6846 int fragment_id = 0;
6847 u32 fragment_id_val;
6853 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6855 if (unformat (input, "version %d", &version_val))
6857 else if (unformat (input, "hdr_length %d", &hdr_length_val))
6859 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
6861 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
6863 else if (unformat (input, "proto %d", &proto_val))
6865 else if (unformat (input, "tos %d", &tos_val))
6867 else if (unformat (input, "length %d", &length_val))
6869 else if (unformat (input, "fragment_id %d", &fragment_id_val))
6871 else if (unformat (input, "ttl %d", &ttl_val))
6873 else if (unformat (input, "checksum %d", &checksum_val))
6879 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
6880 + ttl + checksum == 0)
6884 * Aligned because we use the real comparison functions
6886 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6888 ip = (ip4_header_t *) match;
6890 /* These are realistically matched in practice */
6892 ip->src_address.as_u32 = src_val.as_u32;
6895 ip->dst_address.as_u32 = dst_val.as_u32;
6898 ip->protocol = proto_val;
6901 /* These are not, but they're included for completeness */
6903 ip->ip_version_and_header_length |= (version_val & 0xF)<<4;
6906 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
6912 ip->length = length_val;
6918 ip->checksum = checksum_val;
6924 uword unformat_ip6_match (unformat_input_t * input, va_list * args)
6926 u8 ** matchp = va_arg (*args, u8 **);
6932 u32 traffic_class_val;
6935 int src = 0, dst = 0;
6936 ip6_address_t src_val, dst_val;
6939 int payload_length = 0;
6940 u32 payload_length_val;
6943 u32 ip_version_traffic_class_and_flow_label;
6945 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6947 if (unformat (input, "version %d", &version_val))
6949 else if (unformat (input, "traffic_class %d", &traffic_class_val))
6951 else if (unformat (input, "flow_label %d", &flow_label_val))
6953 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
6955 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
6957 else if (unformat (input, "proto %d", &proto_val))
6959 else if (unformat (input, "payload_length %d", &payload_length_val))
6961 else if (unformat (input, "hop_limit %d", &hop_limit_val))
6967 if (version + traffic_class + flow_label + src + dst + proto +
6968 payload_length + hop_limit == 0)
6972 * Aligned because we use the real comparison functions
6974 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6976 ip = (ip6_header_t *) match;
6979 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
6982 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
6985 ip->protocol = proto_val;
6987 ip_version_traffic_class_and_flow_label = 0;
6990 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
6993 ip_version_traffic_class_and_flow_label |= (traffic_class_val & 0xFF) << 20;
6996 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
6998 ip->ip_version_traffic_class_and_flow_label =
6999 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
7002 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
7005 ip->hop_limit = hop_limit_val;
7011 uword unformat_l3_match (unformat_input_t * input, va_list * args)
7013 u8 ** matchp = va_arg (*args, u8 **);
7015 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7016 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
7018 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
7026 uword unformat_vlan_tag (unformat_input_t * input, va_list * args)
7028 u8 * tagp = va_arg (*args, u8 *);
7031 if (unformat(input, "%d", &tag))
7033 tagp[0] = (tag>>8) & 0x0F;
7034 tagp[1] = tag & 0xFF;
7041 uword unformat_l2_match (unformat_input_t * input, va_list * args)
7043 u8 ** matchp = va_arg (*args, u8 **);
7063 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7064 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
7066 else if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
7068 else if (unformat (input, "proto %U",
7069 unformat_ethernet_type_host_byte_order, &proto_val))
7071 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
7073 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
7075 else if (unformat (input, "ignore-tag1"))
7077 else if (unformat (input, "ignore-tag2"))
7079 else if (unformat (input, "cos1 %d", &cos1_val))
7081 else if (unformat (input, "cos2 %d", &cos2_val))
7086 if ((src + dst + proto + tag1 + tag2 +
7087 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
7090 if (tag1 || ignore_tag1 || cos1)
7092 if (tag2 || ignore_tag2 || cos2)
7095 vec_validate_aligned (match, len-1, sizeof(u32x4));
7098 clib_memcpy (match, dst_val, 6);
7101 clib_memcpy (match + 6, src_val, 6);
7105 /* inner vlan tag */
7106 match[19] = tag2_val[1];
7107 match[18] = tag2_val[0];
7109 match [18] |= (cos2_val & 0x7) << 5;
7112 match[21] = proto_val & 0xff;
7113 match[20] = proto_val >> 8;
7117 match [15] = tag1_val[1];
7118 match [14] = tag1_val[0];
7121 match [14] |= (cos1_val & 0x7) << 5;
7127 match [15] = tag1_val[1];
7128 match [14] = tag1_val[0];
7131 match[17] = proto_val & 0xff;
7132 match[16] = proto_val >> 8;
7135 match [14] |= (cos1_val & 0x7) << 5;
7141 match [18] |= (cos2_val & 0x7) << 5;
7143 match [14] |= (cos1_val & 0x7) << 5;
7146 match[13] = proto_val & 0xff;
7147 match[12] = proto_val >> 8;
7155 uword unformat_classify_match (unformat_input_t * input, va_list * args)
7157 u8 ** matchp = va_arg (*args, u8 **);
7158 u32 skip_n_vectors = va_arg (*args, u32);
7159 u32 match_n_vectors = va_arg (*args, u32);
7165 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
7166 if (unformat (input, "hex %U", unformat_hex_string, &match))
7168 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
7170 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
7176 if (match || l2 || l3)
7180 /* "Win a free Ethernet header in every packet" */
7182 vec_validate_aligned (l2, 13, sizeof(u32x4));
7184 vec_append_aligned (match, l3, sizeof(u32x4));
7188 /* Make sure the vector is big enough even if key is all 0's */
7189 vec_validate_aligned
7190 (match, ((match_n_vectors + skip_n_vectors) * sizeof(u32x4)) - 1,
7193 /* Set size, include skipped vectors*/
7194 _vec_len (match) = (match_n_vectors+skip_n_vectors) * sizeof(u32x4);
7204 static int api_classify_add_del_session (vat_main_t * vam)
7206 unformat_input_t * i = vam->input;
7207 vl_api_classify_add_del_session_t *mp;
7209 u32 table_index = ~0;
7210 u32 hit_next_index = ~0;
7211 u32 opaque_index = ~0;
7215 u32 skip_n_vectors = 0;
7216 u32 match_n_vectors = 0;
7219 * Warning: you have to supply skip_n and match_n
7220 * because the API client cant simply look at the classify
7224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7225 if (unformat (i, "del"))
7227 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
7230 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
7233 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
7236 else if (unformat (i, "opaque-index %d", &opaque_index))
7238 else if (unformat (i, "skip_n %d", &skip_n_vectors))
7240 else if (unformat (i, "match_n %d", &match_n_vectors))
7242 else if (unformat (i, "match %U", unformat_classify_match,
7243 &match, skip_n_vectors, match_n_vectors))
7245 else if (unformat (i, "advance %d", &advance))
7247 else if (unformat (i, "table-index %d", &table_index))
7253 if (table_index == ~0) {
7254 errmsg ("Table index required\n");
7258 if (is_add && match == 0) {
7259 errmsg ("Match value required\n");
7263 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session,
7266 mp->is_add = is_add;
7267 mp->table_index = ntohl(table_index);
7268 mp->hit_next_index = ntohl(hit_next_index);
7269 mp->opaque_index = ntohl(opaque_index);
7270 mp->advance = ntohl(advance);
7271 clib_memcpy (mp->match, match, vec_len(match));
7278 static int api_classify_set_interface_ip_table (vat_main_t * vam)
7280 unformat_input_t * i = vam->input;
7281 vl_api_classify_set_interface_ip_table_t *mp;
7284 int sw_if_index_set;
7285 u32 table_index = ~0;
7288 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7289 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7290 sw_if_index_set = 1;
7291 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7292 sw_if_index_set = 1;
7293 else if (unformat (i, "table %d", &table_index))
7296 clib_warning ("parse error '%U'", format_unformat_error, i);
7301 if (sw_if_index_set == 0) {
7302 errmsg ("missing interface name or sw_if_index\n");
7307 M(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
7309 mp->sw_if_index = ntohl(sw_if_index);
7310 mp->table_index = ntohl(table_index);
7311 mp->is_ipv6 = is_ipv6;
7318 static int api_classify_set_interface_l2_tables (vat_main_t * vam)
7320 unformat_input_t * i = vam->input;
7321 vl_api_classify_set_interface_l2_tables_t *mp;
7324 int sw_if_index_set;
7325 u32 ip4_table_index = ~0;
7326 u32 ip6_table_index = ~0;
7327 u32 other_table_index = ~0;
7329 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7330 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7331 sw_if_index_set = 1;
7332 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7333 sw_if_index_set = 1;
7334 else if (unformat (i, "ip4-table %d", &ip4_table_index))
7336 else if (unformat (i, "ip6-table %d", &ip6_table_index))
7338 else if (unformat (i, "other-table %d", &other_table_index))
7341 clib_warning ("parse error '%U'", format_unformat_error, i);
7346 if (sw_if_index_set == 0) {
7347 errmsg ("missing interface name or sw_if_index\n");
7352 M(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
7354 mp->sw_if_index = ntohl(sw_if_index);
7355 mp->ip4_table_index = ntohl(ip4_table_index);
7356 mp->ip6_table_index = ntohl(ip6_table_index);
7357 mp->other_table_index = ntohl(other_table_index);
7365 static int api_get_node_index (vat_main_t * vam)
7367 unformat_input_t * i = vam->input;
7368 vl_api_get_node_index_t * mp;
7372 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7373 if (unformat (i, "node %s", &name))
7379 errmsg ("node name required\n");
7382 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7383 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7387 M(GET_NODE_INDEX, get_node_index);
7388 clib_memcpy (mp->node_name, name, vec_len(name));
7396 static int api_add_node_next (vat_main_t * vam)
7398 unformat_input_t * i = vam->input;
7399 vl_api_add_node_next_t * mp;
7404 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7405 if (unformat (i, "node %s", &name))
7407 else if (unformat (i, "next %s", &next))
7413 errmsg ("node name required\n");
7416 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7417 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7421 errmsg ("next node required\n");
7424 if (vec_len (next) >= ARRAY_LEN(mp->next_name)) {
7425 errmsg ("next name too long, max %d\n", ARRAY_LEN(mp->next_name));
7429 M(ADD_NODE_NEXT, add_node_next);
7430 clib_memcpy (mp->node_name, name, vec_len(name));
7431 clib_memcpy (mp->next_name, next, vec_len(next));
7440 static int api_l2tpv3_create_tunnel (vat_main_t * vam)
7442 unformat_input_t * i = vam->input;
7443 ip6_address_t client_address, our_address;
7444 int client_address_set = 0;
7445 int our_address_set = 0;
7446 u32 local_session_id = 0;
7447 u32 remote_session_id = 0;
7448 u64 local_cookie = 0;
7449 u64 remote_cookie = 0;
7450 u8 l2_sublayer_present = 0;
7451 vl_api_l2tpv3_create_tunnel_t * mp;
7454 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7455 if (unformat (i, "client_address %U", unformat_ip6_address,
7457 client_address_set = 1;
7458 else if (unformat (i, "our_address %U", unformat_ip6_address,
7460 our_address_set = 1;
7461 else if (unformat (i, "local_session_id %d", &local_session_id))
7463 else if (unformat (i, "remote_session_id %d", &remote_session_id))
7465 else if (unformat (i, "local_cookie %lld", &local_cookie))
7467 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
7469 else if (unformat (i, "l2-sublayer-present"))
7470 l2_sublayer_present = 1;
7475 if (client_address_set == 0) {
7476 errmsg ("client_address required\n");
7480 if (our_address_set == 0) {
7481 errmsg ("our_address required\n");
7485 M(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
7487 clib_memcpy (mp->client_address, client_address.as_u8,
7488 sizeof (mp->client_address));
7490 clib_memcpy (mp->our_address, our_address.as_u8,
7491 sizeof (mp->our_address));
7493 mp->local_session_id = ntohl (local_session_id);
7494 mp->remote_session_id = ntohl (remote_session_id);
7495 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
7496 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
7497 mp->l2_sublayer_present = l2_sublayer_present;
7505 static int api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
7507 unformat_input_t * i = vam->input;
7509 u8 sw_if_index_set = 0;
7510 u64 new_local_cookie = 0;
7511 u64 new_remote_cookie = 0;
7512 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
7515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7516 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7517 sw_if_index_set = 1;
7518 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7519 sw_if_index_set = 1;
7520 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
7522 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
7528 if (sw_if_index_set == 0) {
7529 errmsg ("missing interface name or sw_if_index\n");
7533 M(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
7535 mp->sw_if_index = ntohl(sw_if_index);
7536 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
7537 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
7544 static int api_l2tpv3_interface_enable_disable (vat_main_t * vam)
7546 unformat_input_t * i = vam->input;
7547 vl_api_l2tpv3_interface_enable_disable_t *mp;
7550 u8 sw_if_index_set = 0;
7551 u8 enable_disable = 1;
7553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7554 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7555 sw_if_index_set = 1;
7556 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7557 sw_if_index_set = 1;
7558 else if (unformat (i, "enable"))
7560 else if (unformat (i, "disable"))
7566 if (sw_if_index_set == 0) {
7567 errmsg ("missing interface name or sw_if_index\n");
7571 M(L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
7573 mp->sw_if_index = ntohl(sw_if_index);
7574 mp->enable_disable = enable_disable;
7581 static int api_l2tpv3_set_lookup_key (vat_main_t * vam)
7583 unformat_input_t * i = vam->input;
7584 vl_api_l2tpv3_set_lookup_key_t * mp;
7588 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7589 if (unformat (i, "lookup_v6_src"))
7590 key = L2T_LOOKUP_SRC_ADDRESS;
7591 else if (unformat (i, "lookup_v6_dst"))
7592 key = L2T_LOOKUP_DST_ADDRESS;
7593 else if (unformat (i, "lookup_session_id"))
7594 key = L2T_LOOKUP_SESSION_ID;
7599 if (key == (u8) ~0) {
7600 errmsg ("l2tp session lookup key unset\n");
7604 M(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
7613 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
7614 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7616 vat_main_t * vam = &vat_main;
7618 fformat(vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
7619 format_ip6_address, mp->our_address,
7620 format_ip6_address, mp->client_address,
7621 clib_net_to_host_u32(mp->sw_if_index));
7623 fformat (vam->ofp, " local cookies %016llx %016llx remote cookie %016llx\n",
7624 clib_net_to_host_u64 (mp->local_cookie[0]),
7625 clib_net_to_host_u64 (mp->local_cookie[1]),
7626 clib_net_to_host_u64 (mp->remote_cookie));
7628 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
7629 clib_net_to_host_u32 (mp->local_session_id),
7630 clib_net_to_host_u32 (mp->remote_session_id));
7632 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
7633 mp->l2_sublayer_present ? "preset" : "absent");
7637 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
7638 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7640 vat_main_t * vam = &vat_main;
7641 vat_json_node_t *node = NULL;
7642 struct in6_addr addr;
7644 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7645 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7646 vat_json_init_array(&vam->json_tree);
7648 node = vat_json_array_add(&vam->json_tree);
7650 vat_json_init_object(node);
7652 clib_memcpy(&addr, mp->our_address, sizeof(addr));
7653 vat_json_object_add_ip6(node, "our_address", addr);
7654 clib_memcpy(&addr, mp->client_address, sizeof(addr));
7655 vat_json_object_add_ip6(node, "client_address", addr);
7657 vat_json_node_t * lc = vat_json_object_add(node, "local_cookie");
7658 vat_json_init_array(lc);
7659 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[0]));
7660 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[1]));
7661 vat_json_object_add_uint(node, "remote_cookie", clib_net_to_host_u64(mp->remote_cookie));
7663 printf("local id: %u", clib_net_to_host_u32(mp->local_session_id));
7664 vat_json_object_add_uint(node, "local_session_id", clib_net_to_host_u32(mp->local_session_id));
7665 vat_json_object_add_uint(node, "remote_session_id", clib_net_to_host_u32(mp->remote_session_id));
7666 vat_json_object_add_string_copy(node, "l2_sublayer", mp->l2_sublayer_present ?
7667 (u8*)"present" : (u8*)"absent");
7670 static int api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
7672 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
7675 /* Get list of l2tpv3-tunnel interfaces */
7676 M(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
7679 /* Use a control ping for synchronization */
7681 vl_api_control_ping_t * mp;
7682 M(CONTROL_PING, control_ping);
7689 static void vl_api_sw_interface_tap_details_t_handler
7690 (vl_api_sw_interface_tap_details_t * mp)
7692 vat_main_t * vam = &vat_main;
7694 fformat(vam->ofp, "%-16s %d\n",
7696 clib_net_to_host_u32(mp->sw_if_index));
7699 static void vl_api_sw_interface_tap_details_t_handler_json
7700 (vl_api_sw_interface_tap_details_t * mp)
7702 vat_main_t * vam = &vat_main;
7703 vat_json_node_t *node = NULL;
7705 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7706 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7707 vat_json_init_array(&vam->json_tree);
7709 node = vat_json_array_add(&vam->json_tree);
7711 vat_json_init_object(node);
7712 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7713 vat_json_object_add_string_copy(node, "dev_name", mp->dev_name);
7716 static int api_sw_interface_tap_dump (vat_main_t * vam)
7718 vl_api_sw_interface_tap_dump_t *mp;
7721 fformat(vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
7722 /* Get list of tap interfaces */
7723 M(SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
7726 /* Use a control ping for synchronization */
7728 vl_api_control_ping_t * mp;
7729 M(CONTROL_PING, control_ping);
7735 static uword unformat_vxlan_decap_next
7736 (unformat_input_t * input, va_list * args)
7738 u32 * result = va_arg (*args, u32 *);
7741 if (unformat (input, "drop"))
7742 *result = VXLAN_INPUT_NEXT_DROP;
7743 else if (unformat (input, "ip4"))
7744 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
7745 else if (unformat (input, "ip6"))
7746 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
7747 else if (unformat (input, "l2"))
7748 *result = VXLAN_INPUT_NEXT_L2_INPUT;
7749 else if (unformat (input, "%d", &tmp))
7756 static int api_vxlan_add_del_tunnel (vat_main_t * vam)
7758 unformat_input_t * line_input = vam->input;
7759 vl_api_vxlan_add_del_tunnel_t *mp;
7761 ip4_address_t src4, dst4;
7762 ip6_address_t src6, dst6;
7764 u8 ipv4_set = 0, ipv6_set = 0;
7767 u32 encap_vrf_id = 0;
7768 u32 decap_next_index = ~0;
7771 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7772 if (unformat (line_input, "del"))
7774 else if (unformat (line_input, "src %U",
7775 unformat_ip4_address, &src4))
7780 else if (unformat (line_input, "dst %U",
7781 unformat_ip4_address, &dst4))
7786 else if (unformat (line_input, "src %U",
7787 unformat_ip6_address, &src6))
7792 else if (unformat (line_input, "dst %U",
7793 unformat_ip6_address, &dst6))
7798 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
7800 else if (unformat (line_input, "decap-next %U",
7801 unformat_vxlan_decap_next, &decap_next_index))
7803 else if (unformat (line_input, "vni %d", &vni))
7806 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7812 errmsg ("tunnel src address not specified\n");
7816 errmsg ("tunnel dst address not specified\n");
7820 if (ipv4_set && ipv6_set) {
7821 errmsg ("both IPv4 and IPv6 addresses specified");
7825 if ((vni == 0) || (vni>>24)) {
7826 errmsg ("vni not specified or out of range\n");
7830 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
7833 clib_memcpy(&mp->src_address, &src6, sizeof(src6));
7834 clib_memcpy(&mp->dst_address, &dst6, sizeof(dst6));
7836 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7837 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7839 mp->encap_vrf_id = ntohl(encap_vrf_id);
7840 mp->decap_next_index = ntohl(decap_next_index);
7841 mp->vni = ntohl(vni);
7842 mp->is_add = is_add;
7843 mp->is_ipv6 = ipv6_set;
7850 static void vl_api_vxlan_tunnel_details_t_handler
7851 (vl_api_vxlan_tunnel_details_t * mp)
7853 vat_main_t * vam = &vat_main;
7855 fformat(vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
7856 ntohl(mp->sw_if_index),
7857 format_ip46_address, &(mp->src_address[0]),
7859 format_ip46_address, &(mp->dst_address[0]),
7861 ntohl(mp->encap_vrf_id),
7862 ntohl(mp->decap_next_index),
7866 static void vl_api_vxlan_tunnel_details_t_handler_json
7867 (vl_api_vxlan_tunnel_details_t * mp)
7869 vat_main_t * vam = &vat_main;
7870 vat_json_node_t *node = NULL;
7872 struct in6_addr ip6;
7874 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7875 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7876 vat_json_init_array(&vam->json_tree);
7878 node = vat_json_array_add(&vam->json_tree);
7880 vat_json_init_object(node);
7881 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7883 clib_memcpy(&ip6, &(mp->src_address[0]), sizeof(ip6));
7884 vat_json_object_add_ip6(node, "src_address", ip6);
7885 clib_memcpy(&ip6, &(mp->dst_address[0]), sizeof(ip6));
7886 vat_json_object_add_ip6(node, "dst_address", ip6);
7888 clib_memcpy(&ip4, &(mp->src_address[0]), sizeof(ip4));
7889 vat_json_object_add_ip4(node, "src_address", ip4);
7890 clib_memcpy(&ip4, &(mp->dst_address[0]), sizeof(ip4));
7891 vat_json_object_add_ip4(node, "dst_address", ip4);
7893 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
7894 vat_json_object_add_uint(node, "decap_next_index", ntohl(mp->decap_next_index));
7895 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
7896 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
7899 static int api_vxlan_tunnel_dump (vat_main_t * vam)
7901 unformat_input_t * i = vam->input;
7902 vl_api_vxlan_tunnel_dump_t *mp;
7905 u8 sw_if_index_set = 0;
7907 /* Parse args required to build the message */
7908 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7909 if (unformat (i, "sw_if_index %d", &sw_if_index))
7910 sw_if_index_set = 1;
7915 if (sw_if_index_set == 0) {
7919 if (!vam->json_output) {
7920 fformat(vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
7921 "sw_if_index", "src_address", "dst_address",
7922 "encap_vrf_id", "decap_next_index", "vni");
7925 /* Get list of vxlan-tunnel interfaces */
7926 M(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
7928 mp->sw_if_index = htonl(sw_if_index);
7932 /* Use a control ping for synchronization */
7934 vl_api_control_ping_t * mp;
7935 M(CONTROL_PING, control_ping);
7941 static int api_gre_add_del_tunnel (vat_main_t * vam)
7943 unformat_input_t * line_input = vam->input;
7944 vl_api_gre_add_del_tunnel_t *mp;
7946 ip4_address_t src4, dst4;
7950 u32 outer_fib_id = 0;
7952 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7953 if (unformat (line_input, "del"))
7955 else if (unformat (line_input, "src %U",
7956 unformat_ip4_address, &src4))
7958 else if (unformat (line_input, "dst %U",
7959 unformat_ip4_address, &dst4))
7961 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
7964 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7970 errmsg ("tunnel src address not specified\n");
7974 errmsg ("tunnel dst address not specified\n");
7979 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
7981 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7982 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7983 mp->outer_table_id = ntohl(outer_fib_id);
7984 mp->is_add = is_add;
7991 static void vl_api_gre_tunnel_details_t_handler
7992 (vl_api_gre_tunnel_details_t * mp)
7994 vat_main_t * vam = &vat_main;
7996 fformat(vam->ofp, "%11d%15U%15U%14d\n",
7997 ntohl(mp->sw_if_index),
7998 format_ip4_address, &mp->src_address,
7999 format_ip4_address, &mp->dst_address,
8000 ntohl(mp->outer_table_id));
8003 static void vl_api_gre_tunnel_details_t_handler_json
8004 (vl_api_gre_tunnel_details_t * mp)
8006 vat_main_t * vam = &vat_main;
8007 vat_json_node_t *node = NULL;
8010 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8011 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8012 vat_json_init_array(&vam->json_tree);
8014 node = vat_json_array_add(&vam->json_tree);
8016 vat_json_init_object(node);
8017 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8018 clib_memcpy(&ip4, &mp->src_address, sizeof(ip4));
8019 vat_json_object_add_ip4(node, "src_address", ip4);
8020 clib_memcpy(&ip4, &mp->dst_address, sizeof(ip4));
8021 vat_json_object_add_ip4(node, "dst_address", ip4);
8022 vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_table_id));
8025 static int api_gre_tunnel_dump (vat_main_t * vam)
8027 unformat_input_t * i = vam->input;
8028 vl_api_gre_tunnel_dump_t *mp;
8031 u8 sw_if_index_set = 0;
8033 /* Parse args required to build the message */
8034 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8035 if (unformat (i, "sw_if_index %d", &sw_if_index))
8036 sw_if_index_set = 1;
8041 if (sw_if_index_set == 0) {
8045 if (!vam->json_output) {
8046 fformat(vam->ofp, "%11s%15s%15s%14s\n",
8047 "sw_if_index", "src_address", "dst_address",
8051 /* Get list of gre-tunnel interfaces */
8052 M(GRE_TUNNEL_DUMP, gre_tunnel_dump);
8054 mp->sw_if_index = htonl(sw_if_index);
8058 /* Use a control ping for synchronization */
8060 vl_api_control_ping_t * mp;
8061 M(CONTROL_PING, control_ping);
8067 static int api_l2_fib_clear_table (vat_main_t * vam)
8069 // unformat_input_t * i = vam->input;
8070 vl_api_l2_fib_clear_table_t *mp;
8073 M(L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
8080 static int api_l2_interface_efp_filter (vat_main_t * vam)
8082 unformat_input_t * i = vam->input;
8083 vl_api_l2_interface_efp_filter_t *mp;
8087 u8 sw_if_index_set = 0;
8089 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8090 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8091 sw_if_index_set = 1;
8092 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8093 sw_if_index_set = 1;
8094 else if (unformat (i, "enable"))
8096 else if (unformat (i, "disable"))
8099 clib_warning ("parse error '%U'", format_unformat_error, i);
8104 if (sw_if_index_set == 0) {
8105 errmsg ("missing sw_if_index\n");
8109 M(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
8111 mp->sw_if_index = ntohl(sw_if_index);
8112 mp->enable_disable = enable;
8119 #define foreach_vtr_op \
8120 _("disable", L2_VTR_DISABLED) \
8121 _("push-1", L2_VTR_PUSH_1) \
8122 _("push-2", L2_VTR_PUSH_2) \
8123 _("pop-1", L2_VTR_POP_1) \
8124 _("pop-2", L2_VTR_POP_2) \
8125 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
8126 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
8127 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
8128 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
8130 static int api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
8132 unformat_input_t * i = vam->input;
8133 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
8136 u8 sw_if_index_set = 0;
8143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8144 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8145 sw_if_index_set = 1;
8146 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8147 sw_if_index_set = 1;
8148 else if (unformat (i, "vtr_op %d", &vtr_op))
8150 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
8154 else if (unformat (i, "push_dot1q %d", &push_dot1q))
8156 else if (unformat (i, "tag1 %d", &tag1))
8158 else if (unformat (i, "tag2 %d", &tag2))
8161 clib_warning ("parse error '%U'", format_unformat_error, i);
8166 if ((sw_if_index_set == 0)||(vtr_op_set == 0)) {
8167 errmsg ("missing vtr operation or sw_if_index\n");
8171 M(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
8173 mp->sw_if_index = ntohl(sw_if_index);
8174 mp->vtr_op = ntohl(vtr_op);
8175 mp->push_dot1q = ntohl(push_dot1q);
8176 mp->tag1 = ntohl(tag1);
8177 mp->tag2 = ntohl(tag2);
8184 static int api_create_vhost_user_if (vat_main_t * vam)
8186 unformat_input_t * i = vam->input;
8187 vl_api_create_vhost_user_if_t *mp;
8191 u8 file_name_set = 0;
8192 u32 custom_dev_instance = ~0;
8194 u8 use_custom_mac = 0;
8196 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8197 if (unformat (i, "socket %s", &file_name)) {
8200 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
8202 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
8204 else if (unformat (i, "server"))
8210 if (file_name_set == 0) {
8211 errmsg ("missing socket file name\n");
8215 if (vec_len (file_name) > 255) {
8216 errmsg ("socket file name too long\n");
8219 vec_add1 (file_name, 0);
8221 M(CREATE_VHOST_USER_IF, create_vhost_user_if);
8223 mp->is_server = is_server;
8224 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
8225 vec_free(file_name);
8226 if (custom_dev_instance != ~0) {
8228 mp->custom_dev_instance = ntohl(custom_dev_instance);
8230 mp->use_custom_mac = use_custom_mac;
8231 clib_memcpy(mp->mac_address, hwaddr, 6);
8238 static int api_modify_vhost_user_if (vat_main_t * vam)
8240 unformat_input_t * i = vam->input;
8241 vl_api_modify_vhost_user_if_t *mp;
8245 u8 file_name_set = 0;
8246 u32 custom_dev_instance = ~0;
8247 u8 sw_if_index_set = 0;
8248 u32 sw_if_index = (u32)~0;
8250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8251 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8252 sw_if_index_set = 1;
8253 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8254 sw_if_index_set = 1;
8255 else if (unformat (i, "socket %s", &file_name)) {
8258 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
8260 else if (unformat (i, "server"))
8266 if (sw_if_index_set == 0) {
8267 errmsg ("missing sw_if_index or interface name\n");
8271 if (file_name_set == 0) {
8272 errmsg ("missing socket file name\n");
8276 if (vec_len (file_name) > 255) {
8277 errmsg ("socket file name too long\n");
8280 vec_add1 (file_name, 0);
8282 M(MODIFY_VHOST_USER_IF, modify_vhost_user_if);
8284 mp->sw_if_index = ntohl(sw_if_index);
8285 mp->is_server = is_server;
8286 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
8287 vec_free(file_name);
8288 if (custom_dev_instance != ~0) {
8290 mp->custom_dev_instance = ntohl(custom_dev_instance);
8298 static int api_delete_vhost_user_if (vat_main_t * vam)
8300 unformat_input_t * i = vam->input;
8301 vl_api_delete_vhost_user_if_t *mp;
8303 u32 sw_if_index = ~0;
8304 u8 sw_if_index_set = 0;
8306 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8307 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8308 sw_if_index_set = 1;
8309 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8310 sw_if_index_set = 1;
8315 if (sw_if_index_set == 0) {
8316 errmsg ("missing sw_if_index or interface name\n");
8321 M(DELETE_VHOST_USER_IF, delete_vhost_user_if);
8323 mp->sw_if_index = ntohl(sw_if_index);
8330 static void vl_api_sw_interface_vhost_user_details_t_handler
8331 (vl_api_sw_interface_vhost_user_details_t * mp)
8333 vat_main_t * vam = &vat_main;
8335 fformat(vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
8336 (char *)mp->interface_name,
8337 ntohl(mp->sw_if_index), ntohl(mp->virtio_net_hdr_sz),
8338 clib_net_to_host_u64(mp->features), mp->is_server,
8339 ntohl(mp->num_regions), (char *)mp->sock_filename);
8340 fformat(vam->ofp, " Status: '%s'\n", strerror(ntohl(mp->sock_errno)));
8343 static void vl_api_sw_interface_vhost_user_details_t_handler_json
8344 (vl_api_sw_interface_vhost_user_details_t * mp)
8346 vat_main_t * vam = &vat_main;
8347 vat_json_node_t *node = NULL;
8349 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8350 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8351 vat_json_init_array(&vam->json_tree);
8353 node = vat_json_array_add(&vam->json_tree);
8355 vat_json_init_object(node);
8356 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8357 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
8358 vat_json_object_add_uint(node, "virtio_net_hdr_sz", ntohl(mp->virtio_net_hdr_sz));
8359 vat_json_object_add_uint(node, "features", clib_net_to_host_u64(mp->features));
8360 vat_json_object_add_uint(node, "is_server", mp->is_server);
8361 vat_json_object_add_string_copy(node, "sock_filename", mp->sock_filename);
8362 vat_json_object_add_uint(node, "num_regions", ntohl(mp->num_regions));
8363 vat_json_object_add_uint(node, "sock_errno", ntohl(mp->sock_errno));
8366 static int api_sw_interface_vhost_user_dump (vat_main_t * vam)
8368 vl_api_sw_interface_vhost_user_dump_t *mp;
8370 fformat(vam->ofp, "Interface name idx hdr_sz features server regions filename\n");
8372 /* Get list of vhost-user interfaces */
8373 M(SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
8376 /* Use a control ping for synchronization */
8378 vl_api_control_ping_t * mp;
8379 M(CONTROL_PING, control_ping);
8385 static int api_show_version (vat_main_t * vam)
8387 vl_api_show_version_t *mp;
8390 M(SHOW_VERSION, show_version);
8398 static int api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
8400 unformat_input_t * line_input = vam->input;
8401 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
8403 ip4_address_t local4, remote4;
8404 ip6_address_t local6, remote6;
8406 u8 ipv4_set = 0, ipv6_set = 0;
8409 u32 encap_vrf_id = 0;
8410 u32 decap_vrf_id = 0;
8415 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8416 if (unformat (line_input, "del"))
8418 else if (unformat (line_input, "local %U",
8419 unformat_ip4_address, &local4))
8424 else if (unformat (line_input, "remote %U",
8425 unformat_ip4_address, &remote4))
8430 else if (unformat (line_input, "local %U",
8431 unformat_ip6_address, &local6))
8436 else if (unformat (line_input, "remote %U",
8437 unformat_ip6_address, &remote6))
8442 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
8444 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
8446 else if (unformat (line_input, "vni %d", &vni))
8448 else if (unformat(line_input, "next-ip4"))
8450 else if (unformat(line_input, "next-ip6"))
8452 else if (unformat(line_input, "next-ethernet"))
8454 else if (unformat(line_input, "next-nsh"))
8457 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
8462 if (local_set == 0) {
8463 errmsg ("tunnel local address not specified\n");
8466 if (remote_set == 0) {
8467 errmsg ("tunnel remote address not specified\n");
8470 if (ipv4_set && ipv6_set) {
8471 errmsg ("both IPv4 and IPv6 addresses specified");
8476 errmsg ("vni not specified\n");
8480 M(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
8484 clib_memcpy(&mp->local, &local6, sizeof(local6));
8485 clib_memcpy(&mp->remote, &remote6, sizeof(remote6));
8487 clib_memcpy(&mp->local, &local4, sizeof(local4));
8488 clib_memcpy(&mp->remote, &remote4, sizeof(remote4));
8491 mp->encap_vrf_id = ntohl(encap_vrf_id);
8492 mp->decap_vrf_id = ntohl(decap_vrf_id);
8493 mp->protocol = ntohl(protocol);
8494 mp->vni = ntohl(vni);
8495 mp->is_add = is_add;
8496 mp->is_ipv6 = ipv6_set;
8503 static void vl_api_vxlan_gpe_tunnel_details_t_handler
8504 (vl_api_vxlan_gpe_tunnel_details_t * mp)
8506 vat_main_t * vam = &vat_main;
8508 fformat(vam->ofp, "%11d%24U%24U%13d%12d%14d%14d\n",
8509 ntohl(mp->sw_if_index),
8510 format_ip46_address, &(mp->local[0]),
8511 format_ip46_address, &(mp->remote[0]),
8513 ntohl(mp->protocol),
8514 ntohl(mp->encap_vrf_id),
8515 ntohl(mp->decap_vrf_id));
8518 static void vl_api_vxlan_gpe_tunnel_details_t_handler_json
8519 (vl_api_vxlan_gpe_tunnel_details_t * mp)
8521 vat_main_t * vam = &vat_main;
8522 vat_json_node_t *node = NULL;
8524 struct in6_addr ip6;
8526 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8527 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8528 vat_json_init_array(&vam->json_tree);
8530 node = vat_json_array_add(&vam->json_tree);
8532 vat_json_init_object(node);
8533 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8535 clib_memcpy(&ip6, &(mp->local[0]), sizeof(ip6));
8536 vat_json_object_add_ip6(node, "local", ip6);
8537 clib_memcpy(&ip6, &(mp->remote[0]), sizeof(ip6));
8538 vat_json_object_add_ip6(node, "remote", ip6);
8540 clib_memcpy(&ip4, &(mp->local[0]), sizeof(ip4));
8541 vat_json_object_add_ip4(node, "local", ip4);
8542 clib_memcpy(&ip4, &(mp->remote[0]), sizeof(ip4));
8543 vat_json_object_add_ip4(node, "remote", ip4);
8545 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
8546 vat_json_object_add_uint(node, "protocol", ntohl(mp->protocol));
8547 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
8548 vat_json_object_add_uint(node, "decap_vrf_id", ntohl(mp->decap_vrf_id));
8549 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
8552 static int api_vxlan_gpe_tunnel_dump (vat_main_t * vam)
8554 unformat_input_t * i = vam->input;
8555 vl_api_vxlan_gpe_tunnel_dump_t *mp;
8558 u8 sw_if_index_set = 0;
8560 /* Parse args required to build the message */
8561 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8562 if (unformat (i, "sw_if_index %d", &sw_if_index))
8563 sw_if_index_set = 1;
8568 if (sw_if_index_set == 0) {
8572 if (!vam->json_output) {
8573 fformat(vam->ofp, "%11s%24s%24s%13s%15s%14s%14s\n",
8574 "sw_if_index", "local", "remote", "vni",
8575 "protocol","encap_vrf_id", "decap_vrf_id");
8578 /* Get list of vxlan-tunnel interfaces */
8579 M(VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump);
8581 mp->sw_if_index = htonl(sw_if_index);
8585 /* Use a control ping for synchronization */
8587 vl_api_control_ping_t * mp;
8588 M(CONTROL_PING, control_ping);
8594 u8 * format_l2_fib_mac_address (u8 * s, va_list * args)
8596 u8 * a = va_arg (*args, u8 *);
8598 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
8599 a[2], a[3], a[4], a[5], a[6], a[7]);
8602 static void vl_api_l2_fib_table_entry_t_handler
8603 (vl_api_l2_fib_table_entry_t * mp)
8605 vat_main_t * vam = &vat_main;
8607 fformat(vam->ofp, "%3" PRIu32 " %U %3" PRIu32
8609 ntohl(mp->bd_id), format_l2_fib_mac_address, &mp->mac,
8610 ntohl(mp->sw_if_index), mp->static_mac, mp->filter_mac,
8614 static void vl_api_l2_fib_table_entry_t_handler_json
8615 (vl_api_l2_fib_table_entry_t * mp)
8617 vat_main_t * vam = &vat_main;
8618 vat_json_node_t *node = NULL;
8620 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8621 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8622 vat_json_init_array(&vam->json_tree);
8624 node = vat_json_array_add(&vam->json_tree);
8626 vat_json_init_object(node);
8627 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
8628 vat_json_object_add_uint(node, "mac", clib_net_to_host_u64(mp->mac));
8629 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8630 vat_json_object_add_uint(node, "static_mac", mp->static_mac);
8631 vat_json_object_add_uint(node, "filter_mac", mp->filter_mac);
8632 vat_json_object_add_uint(node, "bvi_mac", mp->bvi_mac);
8635 static int api_l2_fib_table_dump (vat_main_t * vam)
8637 unformat_input_t * i = vam->input;
8638 vl_api_l2_fib_table_dump_t *mp;
8643 /* Parse args required to build the message */
8644 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8645 if (unformat (i, "bd_id %d", &bd_id))
8651 if (bd_id_set == 0) {
8652 errmsg ("missing bridge domain\n");
8656 fformat(vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI\n");
8658 /* Get list of l2 fib entries */
8659 M(L2_FIB_TABLE_DUMP, l2_fib_table_dump);
8661 mp->bd_id = ntohl(bd_id);
8664 /* Use a control ping for synchronization */
8666 vl_api_control_ping_t * mp;
8667 M(CONTROL_PING, control_ping);
8675 api_interface_name_renumber (vat_main_t * vam)
8677 unformat_input_t * line_input = vam->input;
8678 vl_api_interface_name_renumber_t *mp;
8679 u32 sw_if_index = ~0;
8681 u32 new_show_dev_instance = ~0;
8683 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8684 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
8687 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
8689 else if (unformat (line_input, "new_show_dev_instance %d",
8690 &new_show_dev_instance))
8696 if (sw_if_index == ~0) {
8697 errmsg ("missing interface name or sw_if_index\n");
8701 if (new_show_dev_instance == ~0) {
8702 errmsg ("missing new_show_dev_instance\n");
8706 M(INTERFACE_NAME_RENUMBER, interface_name_renumber);
8708 mp->sw_if_index = ntohl (sw_if_index);
8709 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
8715 api_want_ip4_arp_events (vat_main_t * vam)
8717 unformat_input_t * line_input = vam->input;
8718 vl_api_want_ip4_arp_events_t * mp;
8720 ip4_address_t address;
8721 int address_set = 0;
8722 u32 enable_disable = 1;
8724 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8725 if (unformat (line_input, "address %U",
8726 unformat_ip4_address, &address))
8728 else if (unformat (line_input, "del"))
8734 if (address_set == 0) {
8735 errmsg ("missing addresses\n");
8739 M(WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
8740 mp->enable_disable = enable_disable;
8742 mp->address = address.as_u32;
8747 static int api_input_acl_set_interface (vat_main_t * vam)
8749 unformat_input_t * i = vam->input;
8750 vl_api_input_acl_set_interface_t *mp;
8753 int sw_if_index_set;
8754 u32 ip4_table_index = ~0;
8755 u32 ip6_table_index = ~0;
8756 u32 l2_table_index = ~0;
8759 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8760 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8761 sw_if_index_set = 1;
8762 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8763 sw_if_index_set = 1;
8764 else if (unformat (i, "del"))
8766 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8768 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8770 else if (unformat (i, "l2-table %d", &l2_table_index))
8773 clib_warning ("parse error '%U'", format_unformat_error, i);
8778 if (sw_if_index_set == 0) {
8779 errmsg ("missing interface name or sw_if_index\n");
8783 M(INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
8785 mp->sw_if_index = ntohl(sw_if_index);
8786 mp->ip4_table_index = ntohl(ip4_table_index);
8787 mp->ip6_table_index = ntohl(ip6_table_index);
8788 mp->l2_table_index = ntohl(l2_table_index);
8789 mp->is_add = is_add;
8797 api_ip_address_dump (vat_main_t * vam)
8799 unformat_input_t * i = vam->input;
8800 vl_api_ip_address_dump_t * mp;
8801 u32 sw_if_index = ~0;
8802 u8 sw_if_index_set = 0;
8807 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8808 if (unformat (i, "sw_if_index %d", &sw_if_index))
8809 sw_if_index_set = 1;
8810 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8811 sw_if_index_set = 1;
8812 else if (unformat (i, "ipv4"))
8814 else if (unformat (i, "ipv6"))
8820 if (ipv4_set && ipv6_set) {
8821 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8825 if ((!ipv4_set) && (!ipv6_set)) {
8826 errmsg ("no ipv4 nor ipv6 flag set\n");
8830 if (sw_if_index_set == 0) {
8831 errmsg ("missing interface name or sw_if_index\n");
8835 vam->current_sw_if_index = sw_if_index;
8836 vam->is_ipv6 = ipv6_set;
8838 M(IP_ADDRESS_DUMP, ip_address_dump);
8839 mp->sw_if_index = ntohl(sw_if_index);
8840 mp->is_ipv6 = ipv6_set;
8843 /* Use a control ping for synchronization */
8845 vl_api_control_ping_t * mp;
8846 M(CONTROL_PING, control_ping);
8853 api_ip_dump (vat_main_t * vam)
8855 vl_api_ip_dump_t * mp;
8856 unformat_input_t * in = vam->input;
8863 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT) {
8864 if (unformat (in, "ipv4"))
8866 else if (unformat (in, "ipv6"))
8872 if (ipv4_set && ipv6_set) {
8873 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8877 if ((!ipv4_set) && (!ipv6_set)) {
8878 errmsg ("no ipv4 nor ipv6 flag set\n");
8883 vam->is_ipv6 = is_ipv6;
8886 for (i = 0; i < vec_len(vam->ip_details_by_sw_if_index[is_ipv6]); i++) {
8887 vec_free(vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
8889 vec_free(vam->ip_details_by_sw_if_index[is_ipv6]);
8891 M(IP_DUMP, ip_dump);
8892 mp->is_ipv6 = ipv6_set;
8895 /* Use a control ping for synchronization */
8897 vl_api_control_ping_t * mp;
8898 M(CONTROL_PING, control_ping);
8905 api_ipsec_spd_add_del (vat_main_t * vam)
8908 unformat_input_t * i = vam->input;
8909 vl_api_ipsec_spd_add_del_t *mp;
8914 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8915 if (unformat (i, "spd_id %d", &spd_id))
8917 else if (unformat (i, "del"))
8920 clib_warning ("parse error '%U'", format_unformat_error, i);
8925 errmsg ("spd_id must be set\n");
8929 M(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
8931 mp->spd_id = ntohl(spd_id);
8932 mp->is_add = is_add;
8938 clib_warning ("unsupported (no dpdk)");
8944 api_ipsec_interface_add_del_spd (vat_main_t * vam)
8947 unformat_input_t * i = vam->input;
8948 vl_api_ipsec_interface_add_del_spd_t *mp;
8951 u8 sw_if_index_set = 0;
8952 u32 spd_id = (u32) ~0;
8955 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8956 if (unformat (i, "del"))
8958 else if (unformat (i, "spd_id %d", &spd_id))
8960 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8961 sw_if_index_set = 1;
8962 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8963 sw_if_index_set = 1;
8965 clib_warning ("parse error '%U'", format_unformat_error, i);
8971 if (spd_id == (u32) ~0) {
8972 errmsg ("spd_id must be set\n");
8976 if (sw_if_index_set == 0) {
8977 errmsg ("missing interface name or sw_if_index\n");
8981 M(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
8983 mp->spd_id = ntohl(spd_id);
8984 mp->sw_if_index = ntohl (sw_if_index);
8985 mp->is_add = is_add;
8991 clib_warning ("unsupported (no dpdk)");
8997 api_ipsec_spd_add_del_entry (vat_main_t * vam)
9000 unformat_input_t * i = vam->input;
9001 vl_api_ipsec_spd_add_del_entry_t *mp;
9003 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
9004 u32 spd_id, sa_id, protocol = 0, policy = 0;
9006 u32 rport_start = 0, rport_stop = (u32) ~0;
9007 u32 lport_start = 0, lport_stop = (u32) ~0;
9008 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
9009 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
9011 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
9012 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~0;
9013 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
9014 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
9015 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~0;
9016 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~0;
9018 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9019 if (unformat (i, "del"))
9021 if (unformat (i, "outbound"))
9023 if (unformat (i, "inbound"))
9025 else if (unformat (i, "spd_id %d", &spd_id))
9027 else if (unformat (i, "sa_id %d", &sa_id))
9029 else if (unformat (i, "priority %d", &priority))
9031 else if (unformat (i, "protocol %d", &protocol))
9033 else if (unformat (i, "lport_start %d", &lport_start))
9035 else if (unformat (i, "lport_stop %d", &lport_stop))
9037 else if (unformat (i, "rport_start %d", &rport_start))
9039 else if (unformat (i, "rport_stop %d", &rport_stop))
9041 else if (unformat (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
9046 else if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
9051 else if (unformat (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
9056 else if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
9061 else if (unformat (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
9066 else if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
9071 else if (unformat (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
9076 else if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
9081 else if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
9083 if (policy == IPSEC_POLICY_ACTION_RESOLVE) {
9084 clib_warning ("unsupported action: 'resolve'");
9089 clib_warning ("parse error '%U'", format_unformat_error, i);
9095 M(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
9097 mp->spd_id = ntohl(spd_id);
9098 mp->priority = ntohl(priority);
9099 mp->is_outbound = is_outbound;
9101 mp->is_ipv6 = is_ipv6;
9102 if (is_ipv6 || is_ip_any) {
9103 clib_memcpy (mp->remote_address_start, &raddr6_start, sizeof(ip6_address_t));
9104 clib_memcpy (mp->remote_address_stop, &raddr6_stop, sizeof(ip6_address_t));
9105 clib_memcpy (mp->local_address_start, &laddr6_start, sizeof(ip6_address_t));
9106 clib_memcpy (mp->local_address_stop, &laddr6_stop, sizeof(ip6_address_t));
9108 clib_memcpy (mp->remote_address_start, &raddr4_start, sizeof(ip4_address_t));
9109 clib_memcpy (mp->remote_address_stop, &raddr4_stop, sizeof(ip4_address_t));
9110 clib_memcpy (mp->local_address_start, &laddr4_start, sizeof(ip4_address_t));
9111 clib_memcpy (mp->local_address_stop, &laddr4_stop, sizeof(ip4_address_t));
9113 mp->protocol = (u8) protocol;
9114 mp->local_port_start = ntohs((u16) lport_start);
9115 mp->local_port_stop = ntohs((u16) lport_stop);
9116 mp->remote_port_start = ntohs((u16) rport_start);
9117 mp->remote_port_stop = ntohs((u16) rport_stop);
9118 mp->policy = (u8) policy;
9119 mp->sa_id = ntohl(sa_id);
9120 mp->is_add = is_add;
9121 mp->is_ip_any = is_ip_any;
9126 clib_warning ("unsupported (no dpdk)");
9132 api_ipsec_sad_add_del_entry (vat_main_t * vam)
9135 unformat_input_t * i = vam->input;
9136 vl_api_ipsec_sad_add_del_entry_t *mp;
9142 u8 protocol = IPSEC_PROTOCOL_AH;
9143 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
9144 u32 crypto_alg = 0, integ_alg = 0;
9145 ip4_address_t tun_src4;
9146 ip4_address_t tun_dst4;
9147 ip6_address_t tun_src6;
9148 ip6_address_t tun_dst6;
9150 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9151 if (unformat (i, "del"))
9153 else if (unformat (i, "sad_id %d", &sad_id))
9155 else if (unformat (i, "spi %d", &spi))
9157 else if (unformat (i, "esp"))
9158 protocol = IPSEC_PROTOCOL_ESP;
9159 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4)) {
9163 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4)) {
9167 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6)) {
9171 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6)) {
9175 else if (unformat (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg)) {
9176 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
9177 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256) {
9178 clib_warning ("unsupported crypto-alg: '%U'",
9179 format_ipsec_crypto_alg, crypto_alg);
9183 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
9185 else if (unformat (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg)) {
9186 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
9187 integ_alg > IPSEC_INTEG_ALG_SHA_512_256) {
9188 clib_warning ("unsupported integ-alg: '%U'",
9189 format_ipsec_integ_alg, integ_alg);
9193 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
9196 clib_warning ("parse error '%U'", format_unformat_error, i);
9202 M(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
9204 mp->sad_id = ntohl(sad_id);
9205 mp->is_add = is_add;
9206 mp->protocol = protocol;
9207 mp->spi = ntohl(spi);
9208 mp->is_tunnel = is_tunnel;
9209 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
9210 mp->crypto_algorithm = crypto_alg;
9211 mp->integrity_algorithm = integ_alg;
9212 mp->crypto_key_length = vec_len(ck);
9213 mp->integrity_key_length = vec_len(ik);
9215 if (mp->crypto_key_length > sizeof(mp->crypto_key))
9216 mp->crypto_key_length = sizeof(mp->crypto_key);
9218 if (mp->integrity_key_length > sizeof(mp->integrity_key))
9219 mp->integrity_key_length = sizeof(mp->integrity_key);
9221 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
9222 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
9225 if (is_tunnel_ipv6) {
9226 clib_memcpy (mp->tunnel_src_address, &tun_src6, sizeof(ip6_address_t));
9227 clib_memcpy (mp->tunnel_dst_address, &tun_dst6, sizeof(ip6_address_t));
9229 clib_memcpy (mp->tunnel_src_address, &tun_src4, sizeof(ip4_address_t));
9230 clib_memcpy (mp->tunnel_dst_address, &tun_dst4, sizeof(ip4_address_t));
9238 clib_warning ("unsupported (no dpdk)");
9244 api_ipsec_sa_set_key (vat_main_t * vam)
9247 unformat_input_t * i = vam->input;
9248 vl_api_ipsec_sa_set_key_t *mp;
9253 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9254 if (unformat (i, "sa_id %d", &sa_id))
9256 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
9258 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
9261 clib_warning ("parse error '%U'", format_unformat_error, i);
9266 M(IPSEC_SA_SET_KEY, ipsec_set_sa_key);
9268 mp->sa_id = ntohl(sa_id);
9269 mp->crypto_key_length = vec_len(ck);
9270 mp->integrity_key_length = vec_len(ik);
9272 if (mp->crypto_key_length > sizeof(mp->crypto_key))
9273 mp->crypto_key_length = sizeof(mp->crypto_key);
9275 if (mp->integrity_key_length > sizeof(mp->integrity_key))
9276 mp->integrity_key_length = sizeof(mp->integrity_key);
9278 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
9279 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
9285 clib_warning ("unsupported (no dpdk)");
9291 api_ikev2_profile_add_del (vat_main_t * vam)
9294 unformat_input_t * i = vam->input;
9295 vl_api_ikev2_profile_add_del_t * mp;
9300 const char * valid_chars = "a-zA-Z0-9_";
9302 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9303 if (unformat (i, "del"))
9305 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9308 errmsg ("parse error '%U'", format_unformat_error, i);
9313 if (!vec_len (name)) {
9314 errmsg ("profile name must be specified");
9318 if (vec_len (name) > 64) {
9319 errmsg ("profile name too long");
9323 M(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
9325 clib_memcpy(mp->name, name, vec_len (name));
9326 mp->is_add = is_add;
9333 clib_warning ("unsupported (no dpdk)");
9339 api_ikev2_profile_set_auth (vat_main_t * vam)
9342 unformat_input_t * i = vam->input;
9343 vl_api_ikev2_profile_set_auth_t * mp;
9347 u32 auth_method = 0;
9350 const char * valid_chars = "a-zA-Z0-9_";
9352 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9353 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9355 else if (unformat (i, "auth_method %U",
9356 unformat_ikev2_auth_method, &auth_method))
9358 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
9360 else if (unformat (i, "auth_data %v", &data))
9363 errmsg ("parse error '%U'", format_unformat_error, i);
9368 if (!vec_len (name)) {
9369 errmsg ("profile name must be specified");
9373 if (vec_len (name) > 64) {
9374 errmsg ("profile name too long");
9378 if (!vec_len(data)) {
9379 errmsg ("auth_data must be specified");
9384 errmsg ("auth_method must be specified");
9388 M(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
9390 mp->is_hex = is_hex;
9391 mp->auth_method = (u8) auth_method;
9392 mp->data_len = vec_len (data);
9393 clib_memcpy (mp->name, name, vec_len (name));
9394 clib_memcpy (mp->data, data, vec_len (data));
9402 clib_warning ("unsupported (no dpdk)");
9408 api_ikev2_profile_set_id (vat_main_t * vam)
9411 unformat_input_t * i = vam->input;
9412 vl_api_ikev2_profile_set_id_t * mp;
9420 const char * valid_chars = "a-zA-Z0-9_";
9422 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9423 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9425 else if (unformat (i, "id_type %U",
9426 unformat_ikev2_id_type, &id_type))
9428 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
9430 data = vec_new(u8, 4);
9431 clib_memcpy(data, ip4.as_u8, 4);
9433 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
9435 else if (unformat (i, "id_data %v", &data))
9437 else if (unformat (i, "local"))
9439 else if (unformat (i, "remote"))
9442 errmsg ("parse error '%U'", format_unformat_error, i);
9447 if (!vec_len (name)) {
9448 errmsg ("profile name must be specified");
9452 if (vec_len (name) > 64) {
9453 errmsg ("profile name too long");
9457 if (!vec_len(data)) {
9458 errmsg ("id_data must be specified");
9463 errmsg ("id_type must be specified");
9467 M(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
9469 mp->is_local = is_local;
9470 mp->id_type = (u8) id_type;
9471 mp->data_len = vec_len (data);
9472 clib_memcpy (mp->name, name, vec_len (name));
9473 clib_memcpy (mp->data, data, vec_len (data));
9481 clib_warning ("unsupported (no dpdk)");
9487 api_ikev2_profile_set_ts (vat_main_t * vam)
9490 unformat_input_t * i = vam->input;
9491 vl_api_ikev2_profile_set_ts_t * mp;
9495 u32 proto = 0, start_port = 0, end_port = (u32) ~0;
9496 ip4_address_t start_addr, end_addr;
9498 const char * valid_chars = "a-zA-Z0-9_";
9500 start_addr.as_u32 = 0;
9501 end_addr.as_u32 = (u32) ~0;
9503 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9504 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9506 else if (unformat (i, "protocol %d", &proto))
9508 else if (unformat (i, "start_port %d", &start_port))
9510 else if (unformat (i, "end_port %d", &end_port))
9512 else if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
9514 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
9516 else if (unformat (i, "local"))
9518 else if (unformat (i, "remote"))
9521 errmsg ("parse error '%U'", format_unformat_error, i);
9526 if (!vec_len (name)) {
9527 errmsg ("profile name must be specified");
9531 if (vec_len (name) > 64) {
9532 errmsg ("profile name too long");
9536 M(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
9538 mp->is_local = is_local;
9539 mp->proto = (u8) proto;
9540 mp->start_port = (u16) start_port;
9541 mp->end_port = (u16) end_port;
9542 mp->start_addr = start_addr.as_u32;
9543 mp->end_addr = end_addr.as_u32;
9544 clib_memcpy (mp->name, name, vec_len (name));
9551 clib_warning ("unsupported (no dpdk)");
9557 api_ikev2_set_local_key (vat_main_t * vam)
9560 unformat_input_t * i = vam->input;
9561 vl_api_ikev2_set_local_key_t * mp;
9565 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9566 if (unformat (i, "file %v", &file))
9569 errmsg ("parse error '%U'", format_unformat_error, i);
9574 if (!vec_len (file)) {
9575 errmsg ("RSA key file must be specified");
9579 if (vec_len (file) > 256) {
9580 errmsg ("file name too long");
9584 M(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
9586 clib_memcpy (mp->key_file, file, vec_len (file));
9593 clib_warning ("unsupported (no dpdk)");
9601 static int api_map_add_domain (vat_main_t * vam)
9603 unformat_input_t *i = vam->input;
9604 vl_api_map_add_domain_t *mp;
9607 ip4_address_t ip4_prefix;
9608 ip6_address_t ip6_prefix;
9609 ip6_address_t ip6_src;
9611 u32 ip6_prefix_len, ip4_prefix_len, ea_bits_len, psid_offset,
9613 u8 is_translation = 0;
9615 u8 ip6_src_len = 128;
9617 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9618 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
9619 &ip4_prefix, &ip4_prefix_len))
9621 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
9622 &ip6_prefix, &ip6_prefix_len))
9624 else if (unformat (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src, &ip6_src_len))
9626 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
9628 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
9630 else if (unformat (i, "psid-offset %d", &psid_offset))
9632 else if (unformat (i, "psid-len %d", &psid_length))
9634 else if (unformat (i, "mtu %d", &mtu))
9636 else if (unformat (i, "map-t"))
9639 clib_warning ("parse error '%U'", format_unformat_error, i);
9644 if (num_m_args != 6) {
9645 errmsg("mandatory argument(s) missing\n");
9649 /* Construct the API message */
9650 M(MAP_ADD_DOMAIN, map_add_domain);
9652 clib_memcpy(mp->ip4_prefix, &ip4_prefix, sizeof(ip4_prefix));
9653 mp->ip4_prefix_len = ip4_prefix_len;
9655 clib_memcpy(mp->ip6_prefix, &ip6_prefix, sizeof(ip6_prefix));
9656 mp->ip6_prefix_len = ip6_prefix_len;
9658 clib_memcpy(mp->ip6_src, &ip6_src, sizeof(ip6_src));
9659 mp->ip6_src_prefix_len = ip6_src_len;
9661 mp->ea_bits_len = ea_bits_len;
9662 mp->psid_offset = psid_offset;
9663 mp->psid_length = psid_length;
9664 mp->is_translation = is_translation;
9665 mp->mtu = htons(mtu);
9670 /* Wait for a reply, return good/bad news */
9674 static int api_map_del_domain (vat_main_t * vam)
9676 unformat_input_t *i = vam->input;
9677 vl_api_map_del_domain_t *mp;
9683 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9684 if (unformat (i, "index %d", &index))
9687 clib_warning ("parse error '%U'", format_unformat_error, i);
9692 if (num_m_args != 1) {
9693 errmsg("mandatory argument(s) missing\n");
9697 /* Construct the API message */
9698 M(MAP_DEL_DOMAIN, map_del_domain);
9700 mp->index = ntohl(index);
9705 /* Wait for a reply, return good/bad news */
9709 static int api_map_add_del_rule (vat_main_t * vam)
9711 unformat_input_t *i = vam->input;
9712 vl_api_map_add_del_rule_t *mp;
9715 ip6_address_t ip6_dst;
9716 u32 num_m_args = 0, index, psid;
9718 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9719 if (unformat (i, "index %d", &index))
9721 else if (unformat (i, "psid %d", &psid))
9723 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
9725 else if (unformat (i, "del")) {
9728 clib_warning ("parse error '%U'", format_unformat_error, i);
9733 /* Construct the API message */
9734 M(MAP_ADD_DEL_RULE, map_add_del_rule);
9736 mp->index = ntohl(index);
9737 mp->is_add = is_add;
9738 clib_memcpy(mp->ip6_dst, &ip6_dst, sizeof(ip6_dst));
9739 mp->psid = ntohs(psid);
9744 /* Wait for a reply, return good/bad news */
9748 static int api_map_domain_dump (vat_main_t * vam)
9750 vl_api_map_domain_dump_t *mp;
9753 /* Construct the API message */
9754 M(MAP_DOMAIN_DUMP, map_domain_dump);
9759 /* Use a control ping for synchronization */
9761 vl_api_control_ping_t * mp;
9762 M(CONTROL_PING, control_ping);
9768 static int api_map_rule_dump (vat_main_t * vam)
9770 unformat_input_t *i = vam->input;
9771 vl_api_map_rule_dump_t *mp;
9773 u32 domain_index = ~0;
9775 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9776 if (unformat (i, "index %u", &domain_index))
9782 if (domain_index == ~0) {
9783 clib_warning("parse error: domain index expected");
9787 /* Construct the API message */
9788 M(MAP_RULE_DUMP, map_rule_dump);
9790 mp->domain_index = htonl(domain_index);
9795 /* Use a control ping for synchronization */
9797 vl_api_control_ping_t * mp;
9798 M(CONTROL_PING, control_ping);
9804 static void vl_api_map_add_domain_reply_t_handler
9805 (vl_api_map_add_domain_reply_t * mp)
9807 vat_main_t * vam = &vat_main;
9808 i32 retval = ntohl(mp->retval);
9810 if (vam->async_mode) {
9811 vam->async_errors += (retval < 0);
9813 vam->retval = retval;
9814 vam->result_ready = 1;
9818 static void vl_api_map_add_domain_reply_t_handler_json
9819 (vl_api_map_add_domain_reply_t * mp)
9821 vat_main_t * vam = &vat_main;
9822 vat_json_node_t node;
9824 vat_json_init_object(&node);
9825 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
9826 vat_json_object_add_uint(&node, "index", ntohl(mp->index));
9828 vat_json_print(vam->ofp, &node);
9829 vat_json_free(&node);
9831 vam->retval = ntohl(mp->retval);
9832 vam->result_ready = 1;
9836 api_get_first_msg_id (vat_main_t * vam)
9838 vl_api_get_first_msg_id_t * mp;
9840 unformat_input_t * i = vam->input;
9844 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9845 if (unformat (i, "client %s", &name))
9851 if (name_set == 0) {
9852 errmsg ("missing client name\n");
9857 if (vec_len (name) > 63) {
9858 errmsg ("client name too long\n");
9862 M(GET_FIRST_MSG_ID, get_first_msg_id);
9863 clib_memcpy (mp->name, name, vec_len(name));
9869 static int api_cop_interface_enable_disable (vat_main_t * vam)
9871 unformat_input_t * line_input = vam->input;
9872 vl_api_cop_interface_enable_disable_t * mp;
9874 u32 sw_if_index = ~0;
9875 u8 enable_disable = 1;
9877 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9878 if (unformat (line_input, "disable"))
9880 if (unformat (line_input, "enable"))
9882 else if (unformat (line_input, "%U", unformat_sw_if_index,
9885 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9891 if (sw_if_index == ~0) {
9892 errmsg ("missing interface name or sw_if_index\n");
9896 /* Construct the API message */
9897 M(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
9898 mp->sw_if_index = ntohl(sw_if_index);
9899 mp->enable_disable = enable_disable;
9903 /* Wait for the reply */
9907 static int api_cop_whitelist_enable_disable (vat_main_t * vam)
9909 unformat_input_t * line_input = vam->input;
9910 vl_api_cop_whitelist_enable_disable_t * mp;
9912 u32 sw_if_index = ~0;
9913 u8 ip4=0, ip6=0, default_cop=0;
9916 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9917 if (unformat (line_input, "ip4"))
9919 else if (unformat (line_input, "ip6"))
9921 else if (unformat (line_input, "default"))
9923 else if (unformat (line_input, "%U", unformat_sw_if_index,
9926 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9928 else if (unformat (line_input, "fib-id %d", &fib_id))
9934 if (sw_if_index == ~0) {
9935 errmsg ("missing interface name or sw_if_index\n");
9939 /* Construct the API message */
9940 M(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
9941 mp->sw_if_index = ntohl(sw_if_index);
9942 mp->fib_id = ntohl(fib_id);
9945 mp->default_cop = default_cop;
9949 /* Wait for the reply */
9953 static int api_get_node_graph (vat_main_t * vam)
9955 vl_api_get_node_graph_t * mp;
9958 M(GET_NODE_GRAPH, get_node_graph);
9962 /* Wait for the reply */
9967 api_lisp_add_del_locator_set(vat_main_t * vam)
9969 unformat_input_t * input = vam->input;
9970 vl_api_lisp_add_del_locator_set_t *mp;
9973 u8 *locator_set_name = NULL;
9974 u8 locator_set_name_set = 0;
9976 /* Parse args required to build the message */
9977 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9978 if (unformat(input, "del")) {
9980 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9981 locator_set_name_set = 1;
9986 if (locator_set_name_set == 0) {
9987 errmsg ("missing locator-set name");
9991 if (vec_len(locator_set_name) > 64) {
9992 errmsg ("locator-set name too long\n");
9993 vec_free(locator_set_name);
9996 vec_add1(locator_set_name, 0);
9998 /* Construct the API message */
9999 M(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
10001 mp->is_add = is_add;
10002 clib_memcpy(mp->locator_set_name, locator_set_name,
10003 vec_len(locator_set_name));
10004 vec_free(locator_set_name);
10009 /* Wait for a reply... */
10017 api_lisp_add_del_locator(vat_main_t * vam)
10019 unformat_input_t * input = vam->input;
10020 vl_api_lisp_add_del_locator_t *mp;
10022 u32 tmp_if_index = ~0;
10023 u32 sw_if_index = ~0;
10024 u8 sw_if_index_set = 0;
10025 u8 sw_if_index_if_name_set = 0;
10027 u8 priority_set = 0;
10031 u8 *locator_set_name = NULL;
10032 u8 locator_set_name_set = 0;
10034 /* Parse args required to build the message */
10035 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10036 if (unformat(input, "del")) {
10038 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
10039 locator_set_name_set = 1;
10040 } else if (unformat(input, "iface %U", unformat_sw_if_index, vam,
10042 sw_if_index_if_name_set = 1;
10043 sw_if_index = tmp_if_index;
10044 } else if (unformat(input,"sw_if_index %d", &tmp_if_index)) {
10045 sw_if_index_set = 1;
10046 sw_if_index = tmp_if_index;
10047 } else if (unformat(input, "p %d", &priority)) {
10049 } else if (unformat(input, "w %d", &weight)) {
10055 if (locator_set_name_set == 0) {
10056 errmsg ("missing locator-set name");
10060 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0) {
10061 errmsg ("missing sw_if_index");
10062 vec_free(locator_set_name);
10066 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0) {
10067 errmsg ("cannot use both params interface name and sw_if_index");
10068 vec_free(locator_set_name);
10072 if (priority_set == 0) {
10073 errmsg ("missing locator-set priority\n");
10074 vec_free(locator_set_name);
10078 if (weight_set == 0) {
10079 errmsg ("missing locator-set weight\n");
10080 vec_free(locator_set_name);
10084 if (vec_len(locator_set_name) > 64) {
10085 errmsg ("locator-set name too long\n");
10086 vec_free(locator_set_name);
10089 vec_add1(locator_set_name, 0);
10091 /* Construct the API message */
10092 M(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
10094 mp->is_add = is_add;
10095 mp->sw_if_index = ntohl(sw_if_index);
10096 mp->priority = priority;
10097 mp->weight = weight;
10098 clib_memcpy(mp->locator_set_name, locator_set_name,
10099 vec_len(locator_set_name));
10100 vec_free(locator_set_name);
10105 /* Wait for a reply... */
10113 api_lisp_add_del_local_eid(vat_main_t * vam)
10115 unformat_input_t * input = vam->input;
10116 vl_api_lisp_add_del_local_eid_t *mp;
10121 u8 eid_type = (u8)~0;
10122 ip4_address_t eidv4;
10123 ip6_address_t eidv6;
10125 u32 tmp_eid_lenght = ~0;
10126 u8 eid_lenght = ~0;
10127 u8 *locator_set_name = NULL;
10128 u8 locator_set_name_set = 0;
10131 /* Parse args required to build the message */
10132 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10133 if (unformat(input, "del")) {
10135 } else if (unformat(input, "vni &d", &vni)) {
10137 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
10138 &eidv4, &tmp_eid_lenght)) {
10139 eid_lenght = tmp_eid_lenght;
10141 eid_type = 0; /* ipv4 type */
10142 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
10143 &eidv6, &tmp_eid_lenght)) {
10144 eid_lenght = tmp_eid_lenght;
10146 eid_type = 1; /* ipv6 type */
10147 } else if (unformat(input, "eid %U", unformat_ethernet_address, mac)) {
10148 eid_type = 2; /* mac type */
10149 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
10150 locator_set_name_set = 1;
10155 if (locator_set_name_set == 0) {
10156 errmsg ("missing locator-set name\n");
10160 if ((u8)~0 == eid_type) {
10161 errmsg ("EID address not set!");
10162 vec_free(locator_set_name);
10166 if (vec_len(locator_set_name) > 64) {
10167 errmsg ("locator-set name too long\n");
10168 vec_free(locator_set_name);
10171 vec_add1(locator_set_name, 0);
10173 if (eidv4_set && eidv6_set) {
10174 errmsg ("both eid v4 and v6 addresses set\n");
10175 vec_free(locator_set_name);
10179 if (eidv4_set && eid_lenght > 32) {
10180 errmsg ("eid prefix to big\n");
10181 vec_free(locator_set_name);
10185 if (eidv6_set && eid_lenght > 128) {
10186 errmsg ("eid prefix to big\n");
10187 vec_free(locator_set_name);
10191 /* Construct the API message */
10192 M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
10194 mp->is_add = is_add;
10195 switch (eid_type) {
10197 clib_memcpy (mp->eid, &eidv4, sizeof(eidv4));
10200 clib_memcpy (mp->eid, &eidv6, sizeof(eidv6));
10203 clib_memcpy (mp->eid, mac, 6);
10206 mp->eid_type = eid_type;
10207 mp->prefix_len = eid_lenght;
10208 mp->vni = clib_host_to_net_u32(vni);
10209 clib_memcpy(mp->locator_set_name, locator_set_name,
10210 vec_len(locator_set_name));
10211 vec_free(locator_set_name);
10216 /* Wait for a reply... */
10224 api_lisp_gpe_add_del_fwd_entry(vat_main_t * vam)
10226 unformat_input_t * input = vam->input;
10227 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
10230 u8 eidv4_set = 0, slocv4_set = 0, dlocv4_set = 0;
10231 u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0;
10232 ip4_address_t eidv4, slocv4, dlocv4;
10233 ip6_address_t eidv6, slocv6, dlocv6;
10234 u32 tmp_eid_lenght = ~0;
10235 u8 eid_lenght = ~0;
10237 /* Parse args required to build the message */
10238 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10239 if (unformat(input, "del")) {
10241 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
10242 &eidv4, &tmp_eid_lenght)) {
10243 eid_lenght = tmp_eid_lenght;
10245 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
10246 &eidv6, &tmp_eid_lenght)) {
10247 eid_lenght = tmp_eid_lenght;
10249 } else if (unformat(input, "sloc %U", unformat_ip4_address, &slocv4)) {
10251 } else if (unformat(input, "sloc %U", unformat_ip6_address, &slocv6)) {
10253 } else if (unformat(input, "dloc %U", unformat_ip4_address, &dlocv4)) {
10255 } else if (unformat(input, "dloc %U", unformat_ip6_address, &dlocv6)) {
10261 if (eidv4_set && eidv6_set) {
10262 errmsg ("both eid v4 and v6 addresses set\n");
10266 if (!eidv4_set && !eidv6_set) {
10267 errmsg ("eid addresses not set\n");
10271 if (slocv4_set && slocv6_set) {
10272 errmsg ("both source v4 and v6 addresses set\n");
10276 if (!slocv4_set && !slocv6_set) {
10277 errmsg ("source addresses not set\n");
10281 if (dlocv4_set && dlocv6_set) {
10282 errmsg ("both destination v4 and v6 addresses set\n");
10286 if (dlocv4_set && dlocv6_set) {
10287 errmsg ("destination addresses not set\n");
10291 if (!(slocv4_set == dlocv4_set && slocv6_set == dlocv6_set)) {
10292 errmsg ("mixing type of source and destination address\n");
10296 /* Construct the API message */
10297 M(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
10299 mp->is_add = is_add;
10301 mp->eid_is_ipv6 = 1;
10302 clib_memcpy(mp->eid_ip_address, &eidv6, sizeof(eidv6));
10304 mp->eid_is_ipv6 = 0;
10305 clib_memcpy(mp->eid_ip_address, &eidv4, sizeof(eidv4));
10307 mp->eid_prefix_len = eid_lenght;
10309 mp->address_is_ipv6 = 1;
10310 clib_memcpy(mp->source_ip_address, &slocv6, sizeof(slocv6));
10311 clib_memcpy(mp->destination_ip_address, &dlocv6, sizeof(dlocv6));
10313 mp->address_is_ipv6 = 0;
10314 clib_memcpy(mp->source_ip_address, &slocv4, sizeof(slocv4));
10315 clib_memcpy(mp->destination_ip_address, &dlocv4, sizeof(dlocv4));
10321 /* Wait for a reply... */
10329 api_lisp_add_del_map_resolver(vat_main_t * vam)
10331 unformat_input_t * input = vam->input;
10332 vl_api_lisp_add_del_map_resolver_t *mp;
10337 ip4_address_t ipv4;
10338 ip6_address_t ipv6;
10340 /* Parse args required to build the message */
10341 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10342 if (unformat(input, "del")) {
10344 } else if (unformat(input, "%U", unformat_ip4_address, &ipv4)) {
10346 } else if (unformat(input, "%U", unformat_ip6_address, &ipv6)) {
10352 if (ipv4_set && ipv6_set) {
10353 errmsg ("both eid v4 and v6 addresses set\n");
10357 if (!ipv4_set && !ipv6_set) {
10358 errmsg ("eid addresses not set\n");
10362 /* Construct the API message */
10363 M(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
10365 mp->is_add = is_add;
10368 clib_memcpy(mp->ip_address, &ipv6, sizeof(ipv6));
10371 clib_memcpy(mp->ip_address, &ipv4, sizeof(ipv4));
10377 /* Wait for a reply... */
10385 api_lisp_gpe_enable_disable (vat_main_t * vam)
10387 unformat_input_t * input = vam->input;
10388 vl_api_lisp_gpe_enable_disable_t *mp;
10393 /* Parse args required to build the message */
10394 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10395 if (unformat(input, "enable")) {
10398 } else if (unformat(input, "disable")) {
10406 errmsg("Value not set\n");
10410 /* Construct the API message */
10411 M(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
10418 /* Wait for a reply... */
10426 api_lisp_enable_disable (vat_main_t * vam)
10428 unformat_input_t * input = vam->input;
10429 vl_api_lisp_enable_disable_t *mp;
10434 /* Parse args required to build the message */
10435 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10437 if (unformat (input, "enable"))
10442 else if (unformat (input, "disable"))
10452 errmsg ("Value not set\n");
10456 /* Construct the API message */
10457 M(LISP_ENABLE_DISABLE, lisp_enable_disable);
10464 /* Wait for a reply... */
10471 /** Used for transferring locators via VPP API */
10472 typedef CLIB_PACKED(struct
10474 u8 is_ip4; /**< is locator an IPv4 address? */
10475 u8 addr[16]; /**< IPv4/IPv6 address */
10479 * Enable/disable LISP proxy ITR.
10481 * @param vam vpp API test context
10482 * @return return code
10485 api_lisp_pitr_set_locator_set (vat_main_t * vam)
10488 u8 ls_name_set = 0;
10489 unformat_input_t * input = vam->input;
10490 vl_api_lisp_pitr_set_locator_set_t * mp;
10494 /* Parse args required to build the message */
10495 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10497 if (unformat (input, "del"))
10499 else if (unformat (input, "locator-set %s", &ls_name))
10503 errmsg ("parse error '%U'", format_unformat_error, input);
10510 errmsg ("locator-set name not set!");
10514 M(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
10516 mp->is_add = is_add;
10517 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
10518 vec_free (ls_name);
10523 /* wait for reply */
10531 * Add/delete mapping between vni and vrf
10534 api_lisp_eid_table_add_del_map (vat_main_t * vam)
10537 unformat_input_t * input = vam->input;
10538 vl_api_lisp_eid_table_add_del_map_t *mp;
10539 u8 is_add = 1, vni_set = 0, vrf_set = 0;
10542 /* Parse args required to build the message */
10543 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10545 if (unformat (input, "del"))
10547 else if (unformat(input, "vrf %d", &vrf))
10549 else if (unformat(input, "vni %d", &vni))
10555 if (!vni_set || !vrf_set)
10557 errmsg ("missing arguments!");
10561 M(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map);
10563 mp->is_add = is_add;
10564 mp->vni = htonl (vni);
10565 mp->vrf = htonl (vrf);
10570 /* wait for reply */
10578 * Add/del remote mapping to/from LISP control plane
10580 * @param vam vpp API test context
10581 * @return return code
10584 api_lisp_add_del_remote_mapping (vat_main_t * vam)
10586 unformat_input_t * input = vam->input;
10587 vl_api_lisp_add_del_remote_mapping_t *mp;
10590 ip4_address_t seid4, deid4, rloc4;
10591 ip6_address_t seid6, deid6, rloc6;
10592 u8 deid_mac[6] = {0};
10593 u8 seid_mac[6] = {0};
10594 u8 deid_type, seid_type;
10595 u32 seid_len = 0, deid_len = 0, len;
10596 u8 is_add = 1, del_all = 0;
10598 rloc_t * rlocs = 0, rloc;
10600 seid_type = deid_type = (u8)~0;
10602 /* Parse args required to build the message */
10603 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10604 if (unformat(input, "del-all")) {
10606 } else if (unformat(input, "del")) {
10608 } else if (unformat(input, "add")) {
10610 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10612 deid_type = 0; /* ipv4 */
10614 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10616 deid_type = 1; /* ipv6 */
10618 } else if (unformat(input, "deid %U", unformat_ethernet_address,
10620 deid_type = 2; /* mac */
10621 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10623 seid_type = 0; /* ipv4 */
10625 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10627 seid_type = 1; /* ipv6 */
10629 } else if (unformat(input, "seid %U", unformat_ethernet_address,
10631 seid_type = 2; /* mac */
10632 } else if (unformat(input, "vni %d", &vni)) {
10634 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10636 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10637 vec_add1 (rlocs, rloc);
10638 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10640 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10641 vec_add1 (rlocs, rloc);
10642 } else if (unformat(input, "action %d", &action)) {
10645 clib_warning ("parse error '%U'", format_unformat_error, input);
10650 if ((u8)~0 == deid_type) {
10651 errmsg ("missing params!");
10655 if (seid_type != deid_type) {
10656 errmsg ("source and destination EIDs are of different types!");
10660 if (is_add && (~0 == action)
10661 && 0 == vec_len (rlocs)) {
10662 errmsg ("no action set for negative map-reply!");
10666 M(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
10667 mp->is_add = is_add;
10668 mp->vni = htonl (vni);
10669 mp->seid_len = seid_len;
10670 mp->action = (u8) action;
10671 mp->deid_len = deid_len;
10672 mp->del_all = del_all;
10673 mp->eid_type = deid_type;
10675 switch (mp->eid_type) {
10677 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10678 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10681 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10682 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10685 clib_memcpy (mp->seid, seid_mac, 6);
10686 clib_memcpy (mp->deid, deid_mac, 6);
10689 errmsg ("unknown EID type %d!", mp->eid_type);
10693 mp->rloc_num = vec_len (rlocs);
10694 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10700 /* Wait for a reply... */
10708 * Add/del LISP adjacency. Saves mapping in LISP control plane and updates
10709 * forwarding entries in data-plane accordingly.
10711 * @param vam vpp API test context
10712 * @return return code
10715 api_lisp_add_del_adjacency (vat_main_t * vam)
10717 unformat_input_t * input = vam->input;
10718 vl_api_lisp_add_del_adjacency_t *mp;
10721 ip4_address_t seid4, deid4, rloc4;
10722 ip6_address_t seid6, deid6, rloc6;
10723 u8 deid_mac[6] = {0};
10724 u8 seid_mac[6] = {0};
10725 u8 deid_type, seid_type;
10726 u32 seid_len = 0, deid_len = 0, len;
10729 rloc_t * rlocs = 0, rloc;
10731 memset(mp, 0, sizeof(mp[0]));
10732 seid_type = deid_type = (u8)~0;
10734 /* Parse args required to build the message */
10735 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10736 if (unformat(input, "del")) {
10738 } else if (unformat(input, "add")) {
10740 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10742 deid_type = 0; /* ipv4 */
10744 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10746 deid_type = 1; /* ipv6 */
10748 } else if (unformat(input, "deid %U", unformat_ethernet_address,
10750 deid_type = 2; /* mac */
10751 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10753 seid_type = 0; /* ipv4 */
10755 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10757 seid_type = 1; /* ipv6 */
10759 } else if (unformat(input, "seid %U", unformat_ethernet_address,
10761 seid_type = 2; /* mac */
10762 } else if (unformat(input, "vni %d", &vni)) {
10764 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10766 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10767 vec_add1 (rlocs, rloc);
10768 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10770 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10771 vec_add1 (rlocs, rloc);
10772 } else if (unformat(input, "action %d", &action)) {
10775 clib_warning ("parse error '%U'", format_unformat_error, input);
10780 if ((u8)~0 == deid_type) {
10781 errmsg ("missing params!");
10785 if (seid_type != deid_type) {
10786 errmsg ("source and destination EIDs are of different types!");
10790 if (is_add && (~0 == action)
10791 && 0 == vec_len (rlocs)) {
10792 errmsg ("no action set for negative map-reply!");
10796 M(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency);
10797 mp->is_add = is_add;
10798 mp->vni = htonl (vni);
10799 mp->seid_len = seid_len;
10800 mp->action = (u8) action;
10801 mp->deid_len = deid_len;
10802 mp->eid_type = deid_type;
10804 switch (mp->eid_type) {
10806 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10807 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10810 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10811 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10814 clib_memcpy (mp->seid, seid_mac, 6);
10815 clib_memcpy (mp->deid, deid_mac, 6);
10818 errmsg ("unknown EID type %d!", mp->eid_type);
10822 mp->rloc_num = vec_len (rlocs);
10823 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10829 /* Wait for a reply... */
10837 api_lisp_gpe_add_del_iface(vat_main_t * vam)
10839 unformat_input_t * input = vam->input;
10840 vl_api_lisp_gpe_add_del_iface_t *mp;
10846 /* Parse args required to build the message */
10847 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10848 if (unformat(input, "up")) {
10851 } else if (unformat(input, "down")) {
10854 } else if (unformat(input, "table_id %d", &table_id)) {
10856 } else if (unformat(input, "vni %d", &vni)) {
10863 errmsg("Value not set\n");
10867 /* Construct the API message */
10868 M(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
10870 mp->is_add = is_add;
10871 mp->table_id = table_id;
10877 /* Wait for a reply... */
10885 * Add/del map request itr rlocs from LISP control plane and updates
10887 * @param vam vpp API test context
10888 * @return return code
10891 api_lisp_add_del_map_request_itr_rlocs(vat_main_t * vam)
10893 unformat_input_t * input = vam->input;
10894 vl_api_lisp_add_del_map_request_itr_rlocs_t *mp;
10896 u8 *locator_set_name = 0;
10897 u8 locator_set_name_set = 0;
10900 /* Parse args required to build the message */
10901 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10902 if (unformat(input, "del")) {
10904 } else if (unformat(input, "%_%v%_", &locator_set_name)) {
10905 locator_set_name_set = 1;
10907 clib_warning ("parse error '%U'", format_unformat_error, input);
10912 if (is_add && !locator_set_name_set) {
10913 errmsg ("itr-rloc is not set!");
10917 if (is_add && vec_len(locator_set_name) > 64) {
10918 errmsg ("itr-rloc locator-set name too long\n");
10919 vec_free(locator_set_name);
10923 M(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, lisp_add_del_map_request_itr_rlocs);
10924 mp->is_add = is_add;
10926 clib_memcpy (mp->locator_set_name , locator_set_name,
10927 vec_len(locator_set_name));
10929 memset(mp->locator_set_name, 0, sizeof(mp->locator_set_name));
10931 vec_free (locator_set_name);
10936 /* Wait for a reply... */
10944 api_lisp_locator_set_dump(vat_main_t *vam)
10946 vl_api_lisp_locator_set_dump_t *mp;
10949 if (!vam->json_output) {
10950 fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n",
10951 "Locator-set", "Locator", "Priority", "Weight");
10954 M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
10958 /* Use a control ping for synchronization */
10960 vl_api_control_ping_t * mp;
10961 M(CONTROL_PING, control_ping);
10964 /* Wait for a reply... */
10972 api_lisp_local_eid_table_dump(vat_main_t *vam)
10974 unformat_input_t * i = vam->input;
10975 vl_api_lisp_local_eid_table_dump_t *mp;
10977 struct in_addr ip4;
10978 struct in6_addr ip6;
10980 u8 eid_type = ~0, eid_set;
10981 u32 prefix_length = ~0, t, vni = 0;
10983 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10984 if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t)) {
10988 } else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t)) {
10992 } else if (unformat (i, "eid %U", unformat_ethernet_address, mac)) {
10995 } else if (unformat (i, "vni %d", &t))
10998 errmsg ("parse error '%U'", format_unformat_error, i);
11003 if (!vam->json_output) {
11004 fformat(vam->ofp, "%=20s%=30s\n",
11005 "Locator-set", "Eid");
11008 M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
11012 mp->vni = htonl (vni);
11013 mp->eid_type = eid_type;
11014 switch (eid_type) {
11016 mp->prefix_length = prefix_length;
11017 clib_memcpy (mp->eid, &ip4, sizeof (ip4));
11020 mp->prefix_length = prefix_length;
11021 clib_memcpy (mp->eid, &ip6, sizeof (ip6));
11024 clib_memcpy (mp->eid, mac, sizeof (mac));
11027 errmsg ("unknown EID type %d!", eid_type);
11035 /* Use a control ping for synchronization */
11037 vl_api_control_ping_t * mp;
11038 M(CONTROL_PING, control_ping);
11041 /* Wait for a reply... */
11049 api_lisp_gpe_tunnel_dump(vat_main_t *vam)
11051 vl_api_lisp_gpe_tunnel_dump_t *mp;
11054 if (!vam->json_output) {
11055 fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
11056 "%=16s%=16s%=16s%=16s%=16s\n",
11057 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
11058 "Decap next", "Lisp version", "Flags", "Next protocol",
11059 "ver_res", "res", "iid");
11062 M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
11066 /* Use a control ping for synchronization */
11068 vl_api_control_ping_t * mp;
11069 M(CONTROL_PING, control_ping);
11072 /* Wait for a reply... */
11080 api_lisp_map_resolver_dump(vat_main_t *vam)
11082 vl_api_lisp_map_resolver_dump_t *mp;
11085 if (!vam->json_output) {
11086 fformat(vam->ofp, "%=20s\n",
11090 M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
11094 /* Use a control ping for synchronization */
11096 vl_api_control_ping_t * mp;
11097 M(CONTROL_PING, control_ping);
11100 /* Wait for a reply... */
11108 api_lisp_enable_disable_status_dump(vat_main_t *vam)
11110 vl_api_lisp_enable_disable_status_dump_t *mp;
11113 if (!vam->json_output) {
11114 fformat(vam->ofp, "%=20s\n",
11118 M(LISP_ENABLE_DISABLE_STATUS_DUMP,
11119 lisp_enable_disable_status_dump);
11123 /* Use a control ping for synchronization */
11125 vl_api_control_ping_t * mp;
11126 M(CONTROL_PING, control_ping);
11129 /* Wait for a reply... */
11137 api_lisp_get_map_request_itr_rlocs(vat_main_t *vam)
11139 vl_api_lisp_get_map_request_itr_rlocs_t *mp;
11142 if (!vam->json_output) {
11143 fformat(vam->ofp, "%=20s\n",
11147 M(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs);
11150 /* Wait for a reply... */
11158 api_af_packet_create (vat_main_t * vam)
11160 unformat_input_t * i = vam->input;
11161 vl_api_af_packet_create_t * mp;
11163 u8 * host_if_name = 0;
11165 u8 random_hw_addr = 1;
11167 memset (hw_addr, 0, sizeof (hw_addr));
11169 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11170 if (unformat (i, "name %s", &host_if_name))
11171 vec_add1 (host_if_name, 0);
11172 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
11173 random_hw_addr = 0;
11178 if (!vec_len (host_if_name)) {
11179 errmsg ("host-interface name must be specified");
11183 if (vec_len (host_if_name) > 64) {
11184 errmsg ("host-interface name too long");
11188 M(AF_PACKET_CREATE, af_packet_create);
11190 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11191 clib_memcpy (mp->hw_addr, hw_addr, 6);
11192 mp->use_random_hw_addr = random_hw_addr;
11193 vec_free (host_if_name);
11195 S; W2(fprintf(vam->ofp," new sw_if_index = %d ", vam->sw_if_index));
11201 api_af_packet_delete (vat_main_t * vam)
11203 unformat_input_t * i = vam->input;
11204 vl_api_af_packet_delete_t * mp;
11206 u8 * host_if_name = 0;
11208 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11209 if (unformat (i, "name %s", &host_if_name))
11210 vec_add1 (host_if_name, 0);
11215 if (!vec_len (host_if_name)) {
11216 errmsg ("host-interface name must be specified");
11220 if (vec_len (host_if_name) > 64) {
11221 errmsg ("host-interface name too long");
11225 M(AF_PACKET_DELETE, af_packet_delete);
11227 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
11228 vec_free (host_if_name);
11236 api_policer_add_del (vat_main_t * vam)
11238 unformat_input_t * i = vam->input;
11239 vl_api_policer_add_del_t * mp;
11251 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11252 if (unformat (i, "del"))
11254 else if (unformat (i, "name %s", &name))
11255 vec_add1 (name, 0);
11256 else if (unformat (i, "cir %u", &cir))
11258 else if (unformat (i, "eir %u", &eir))
11260 else if (unformat (i, "cb %u", &cb))
11262 else if (unformat (i, "eb %u", &eb))
11264 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
11267 else if (unformat (i, "round_type %U", unformat_policer_round_type,
11270 else if (unformat (i, "type %U", unformat_policer_type, &type))
11276 if (!vec_len (name)) {
11277 errmsg ("policer name must be specified");
11281 if (vec_len (name) > 64) {
11282 errmsg ("policer name too long");
11286 M(POLICER_ADD_DEL, policer_add_del);
11288 clib_memcpy (mp->name, name, vec_len (name));
11290 mp->is_add = is_add;
11295 mp->rate_type = rate_type;
11296 mp->round_type = round_type;
11305 api_policer_dump(vat_main_t *vam)
11307 unformat_input_t * i = vam->input;
11308 vl_api_policer_dump_t *mp;
11310 u8 *match_name = 0;
11311 u8 match_name_valid = 0;
11313 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11314 if (unformat (i, "name %s", &match_name)) {
11315 vec_add1 (match_name, 0);
11316 match_name_valid = 1;
11321 M(POLICER_DUMP, policer_dump);
11322 mp->match_name_valid = match_name_valid;
11323 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
11324 vec_free (match_name);
11328 /* Use a control ping for synchronization */
11330 vl_api_control_ping_t * mp;
11331 M(CONTROL_PING, control_ping);
11334 /* Wait for a reply... */
11342 api_netmap_create (vat_main_t * vam)
11344 unformat_input_t * i = vam->input;
11345 vl_api_netmap_create_t * mp;
11349 u8 random_hw_addr = 1;
11353 memset (hw_addr, 0, sizeof (hw_addr));
11355 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11356 if (unformat (i, "name %s", &if_name))
11357 vec_add1 (if_name, 0);
11358 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
11359 random_hw_addr = 0;
11360 else if (unformat (i, "pipe"))
11362 else if (unformat (i, "master"))
11364 else if (unformat (i, "slave"))
11370 if (!vec_len (if_name)) {
11371 errmsg ("interface name must be specified");
11375 if (vec_len (if_name) > 64) {
11376 errmsg ("interface name too long");
11380 M(NETMAP_CREATE, netmap_create);
11382 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
11383 clib_memcpy (mp->hw_addr, hw_addr, 6);
11384 mp->use_random_hw_addr = random_hw_addr;
11385 mp->is_pipe = is_pipe;
11386 mp->is_master = is_master;
11387 vec_free (if_name);
11395 api_netmap_delete (vat_main_t * vam)
11397 unformat_input_t * i = vam->input;
11398 vl_api_netmap_delete_t * mp;
11402 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
11403 if (unformat (i, "name %s", &if_name))
11404 vec_add1 (if_name, 0);
11409 if (!vec_len (if_name)) {
11410 errmsg ("interface name must be specified");
11414 if (vec_len (if_name) > 64) {
11415 errmsg ("interface name too long");
11419 M(NETMAP_DELETE, netmap_delete);
11421 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
11422 vec_free (if_name);
11429 static void vl_api_mpls_gre_tunnel_details_t_handler
11430 (vl_api_mpls_gre_tunnel_details_t * mp)
11432 vat_main_t * vam = &vat_main;
11434 i32 len = ntohl(mp->nlabels);
11436 if (mp->l2_only == 0) {
11437 fformat(vam->ofp, "[%d]: src %U, dst %U, adj %U/%d, labels ",
11438 ntohl(mp->tunnel_index),
11439 format_ip4_address, &mp->tunnel_src,
11440 format_ip4_address, &mp->tunnel_dst,
11441 format_ip4_address, &mp->intfc_address,
11442 ntohl(mp->mask_width));
11443 for (i = 0; i < len; i++) {
11444 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11446 fformat(vam->ofp, "\n");
11447 fformat(vam->ofp, " inner fib index %d, outer fib index %d\n",
11448 ntohl(mp->inner_fib_index), ntohl(mp->outer_fib_index));
11450 fformat(vam->ofp, "[%d]: src %U, dst %U, key %U, labels ",
11451 ntohl(mp->tunnel_index),
11452 format_ip4_address, &mp->tunnel_src,
11453 format_ip4_address, &mp->tunnel_dst,
11454 format_ip4_address, &mp->intfc_address);
11455 for (i = 0; i < len; i++) {
11456 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11458 fformat(vam->ofp, "\n");
11459 fformat(vam->ofp, " l2 interface %d, outer fib index %d\n",
11460 ntohl(mp->hw_if_index), ntohl(mp->outer_fib_index));
11464 static void vl_api_mpls_gre_tunnel_details_t_handler_json
11465 (vl_api_mpls_gre_tunnel_details_t * mp)
11467 vat_main_t * vam = &vat_main;
11468 vat_json_node_t *node = NULL;
11469 struct in_addr ip4;
11471 i32 len = ntohl(mp->nlabels);
11473 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11474 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11475 vat_json_init_array(&vam->json_tree);
11477 node = vat_json_array_add(&vam->json_tree);
11479 vat_json_init_object(node);
11480 vat_json_object_add_uint(node, "tunnel_index", ntohl(mp->tunnel_index));
11481 clib_memcpy(&ip4, &(mp->intfc_address), sizeof(ip4));
11482 vat_json_object_add_ip4(node, "intfc_address", ip4);
11483 vat_json_object_add_uint(node, "inner_fib_index", ntohl(mp->inner_fib_index));
11484 vat_json_object_add_uint(node, "mask_width", ntohl(mp->mask_width));
11485 vat_json_object_add_uint(node, "encap_index", ntohl(mp->encap_index));
11486 vat_json_object_add_uint(node, "hw_if_index", ntohl(mp->hw_if_index));
11487 vat_json_object_add_uint(node, "l2_only", ntohl(mp->l2_only));
11488 clib_memcpy(&ip4, &(mp->tunnel_src), sizeof(ip4));
11489 vat_json_object_add_ip4(node, "tunnel_src", ip4);
11490 clib_memcpy(&ip4, &(mp->tunnel_dst), sizeof(ip4));
11491 vat_json_object_add_ip4(node, "tunnel_dst", ip4);
11492 vat_json_object_add_uint(node, "outer_fib_index", ntohl(mp->outer_fib_index));
11493 vat_json_object_add_uint(node, "label_count", len);
11494 for (i = 0; i < len; i++) {
11495 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11499 static int api_mpls_gre_tunnel_dump (vat_main_t * vam)
11501 vl_api_mpls_gre_tunnel_dump_t *mp;
11505 /* Parse args required to build the message */
11506 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT) {
11507 if (!unformat (vam->input, "tunnel_index %d", &index)) {
11513 fformat(vam->ofp, " tunnel_index %d\n", index);
11515 M(MPLS_GRE_TUNNEL_DUMP, mpls_gre_tunnel_dump);
11516 mp->tunnel_index = htonl(index);
11519 /* Use a control ping for synchronization */
11521 vl_api_control_ping_t * mp;
11522 M(CONTROL_PING, control_ping);
11528 static void vl_api_mpls_eth_tunnel_details_t_handler
11529 (vl_api_mpls_eth_tunnel_details_t * mp)
11531 vat_main_t * vam = &vat_main;
11533 i32 len = ntohl(mp->nlabels);
11535 fformat(vam->ofp, "[%d]: dst %U, adj %U/%d, labels ",
11536 ntohl(mp->tunnel_index),
11537 format_ethernet_address, &mp->tunnel_dst_mac,
11538 format_ip4_address, &mp->intfc_address,
11539 ntohl(mp->mask_width));
11540 for (i = 0; i < len; i++) {
11541 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11543 fformat(vam->ofp, "\n");
11544 fformat(vam->ofp, " tx on %d, rx fib index %d\n",
11545 ntohl(mp->tx_sw_if_index),
11546 ntohl(mp->inner_fib_index));
11549 static void vl_api_mpls_eth_tunnel_details_t_handler_json
11550 (vl_api_mpls_eth_tunnel_details_t * mp)
11552 vat_main_t * vam = &vat_main;
11553 vat_json_node_t *node = NULL;
11554 struct in_addr ip4;
11556 i32 len = ntohl(mp->nlabels);
11558 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11559 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11560 vat_json_init_array(&vam->json_tree);
11562 node = vat_json_array_add(&vam->json_tree);
11564 vat_json_init_object(node);
11565 vat_json_object_add_uint(node, "tunnel_index", ntohl(mp->tunnel_index));
11566 clib_memcpy(&ip4, &(mp->intfc_address), sizeof(ip4));
11567 vat_json_object_add_ip4(node, "intfc_address", ip4);
11568 vat_json_object_add_uint(node, "inner_fib_index", ntohl(mp->inner_fib_index));
11569 vat_json_object_add_uint(node, "mask_width", ntohl(mp->mask_width));
11570 vat_json_object_add_uint(node, "encap_index", ntohl(mp->encap_index));
11571 vat_json_object_add_uint(node, "hw_if_index", ntohl(mp->hw_if_index));
11572 vat_json_object_add_uint(node, "l2_only", ntohl(mp->l2_only));
11573 vat_json_object_add_string_copy(node, "tunnel_dst_mac",
11574 format(0, "%U", format_ethernet_address, &mp->tunnel_dst_mac));
11575 vat_json_object_add_uint(node, "tx_sw_if_index", ntohl(mp->tx_sw_if_index));
11576 vat_json_object_add_uint(node, "label_count", len);
11577 for (i = 0; i < len; i++) {
11578 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11582 static int api_mpls_eth_tunnel_dump (vat_main_t * vam)
11584 vl_api_mpls_eth_tunnel_dump_t *mp;
11588 /* Parse args required to build the message */
11589 while (unformat_check_input (vam->input) != UNFORMAT_END_OF_INPUT) {
11590 if (!unformat (vam->input, "tunnel_index %d", &index)) {
11596 fformat(vam->ofp, " tunnel_index %d\n", index);
11598 M(MPLS_ETH_TUNNEL_DUMP, mpls_eth_tunnel_dump);
11599 mp->tunnel_index = htonl(index);
11602 /* Use a control ping for synchronization */
11604 vl_api_control_ping_t * mp;
11605 M(CONTROL_PING, control_ping);
11611 static void vl_api_mpls_fib_encap_details_t_handler
11612 (vl_api_mpls_fib_encap_details_t * mp)
11614 vat_main_t * vam = &vat_main;
11616 i32 len = ntohl(mp->nlabels);
11618 fformat(vam->ofp, "table %d, dest %U, label ",
11619 ntohl(mp->fib_index),
11620 format_ip4_address, &mp->dest,
11622 for (i = 0; i < len; i++) {
11623 fformat(vam->ofp, "%u ", ntohl(mp->labels[i]));
11625 fformat(vam->ofp, "\n");
11628 static void vl_api_mpls_fib_encap_details_t_handler_json
11629 (vl_api_mpls_fib_encap_details_t * mp)
11631 vat_main_t * vam = &vat_main;
11632 vat_json_node_t *node = NULL;
11634 i32 len = ntohl(mp->nlabels);
11635 struct in_addr ip4;
11637 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11638 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11639 vat_json_init_array(&vam->json_tree);
11641 node = vat_json_array_add(&vam->json_tree);
11643 vat_json_init_object(node);
11644 vat_json_object_add_uint(node, "table", ntohl(mp->fib_index));
11645 vat_json_object_add_uint(node, "entry_index", ntohl(mp->entry_index));
11646 clib_memcpy(&ip4, &(mp->dest), sizeof(ip4));
11647 vat_json_object_add_ip4(node, "dest", ip4);
11648 vat_json_object_add_uint(node, "s_bit", ntohl(mp->s_bit));
11649 vat_json_object_add_uint(node, "label_count", len);
11650 for (i = 0; i < len; i++) {
11651 vat_json_object_add_uint(node, "label", ntohl(mp->labels[i]));
11655 static int api_mpls_fib_encap_dump (vat_main_t * vam)
11657 vl_api_mpls_fib_encap_dump_t *mp;
11660 M(MPLS_FIB_ENCAP_DUMP, mpls_fib_encap_dump);
11663 /* Use a control ping for synchronization */
11665 vl_api_control_ping_t * mp;
11666 M(CONTROL_PING, control_ping);
11672 static void vl_api_mpls_fib_decap_details_t_handler
11673 (vl_api_mpls_fib_decap_details_t * mp)
11675 vat_main_t * vam = &vat_main;
11677 fformat(vam->ofp, "RX table %d, TX table/intfc %u, swif_tag '%s', label %u, s_bit %u\n",
11678 ntohl(mp->rx_table_id),
11679 ntohl(mp->tx_table_id),
11685 static void vl_api_mpls_fib_decap_details_t_handler_json
11686 (vl_api_mpls_fib_decap_details_t * mp)
11688 vat_main_t * vam = &vat_main;
11689 vat_json_node_t *node = NULL;
11690 struct in_addr ip4;
11692 if (VAT_JSON_ARRAY != vam->json_tree.type) {
11693 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
11694 vat_json_init_array(&vam->json_tree);
11696 node = vat_json_array_add(&vam->json_tree);
11698 vat_json_init_object(node);
11699 vat_json_object_add_uint(node, "table", ntohl(mp->fib_index));
11700 vat_json_object_add_uint(node, "entry_index", ntohl(mp->entry_index));
11701 clib_memcpy(&ip4, &(mp->dest), sizeof(ip4));
11702 vat_json_object_add_ip4(node, "dest", ip4);
11703 vat_json_object_add_uint(node, "s_bit", ntohl(mp->s_bit));
11704 vat_json_object_add_uint(node, "label", ntohl(mp->label));
11705 vat_json_object_add_uint(node, "rx_table_id", ntohl(mp->rx_table_id));
11706 vat_json_object_add_uint(node, "tx_table_id", ntohl(mp->tx_table_id));
11707 vat_json_object_add_string_copy(node, "swif_tag", mp->swif_tag);
11710 static int api_mpls_fib_decap_dump (vat_main_t * vam)
11712 vl_api_mpls_fib_decap_dump_t *mp;
11715 M(MPLS_FIB_DECAP_DUMP, mpls_fib_decap_dump);
11718 /* Use a control ping for synchronization */
11720 vl_api_control_ping_t * mp;
11721 M(CONTROL_PING, control_ping);
11727 int api_classify_table_ids (vat_main_t *vam)
11729 vl_api_classify_table_ids_t *mp;
11732 /* Construct the API message */
11733 M(CLASSIFY_TABLE_IDS, classify_table_ids);
11741 int api_classify_table_by_interface (vat_main_t *vam)
11743 unformat_input_t * input = vam->input;
11744 vl_api_classify_table_by_interface_t *mp;
11747 u32 sw_if_index = ~0;
11748 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11749 if (unformat (input, "%U", unformat_sw_if_index, vam, &sw_if_index))
11751 else if (unformat (input, "sw_if_index %d", &sw_if_index))
11756 if (sw_if_index == ~0) {
11757 errmsg ("missing interface name or sw_if_index\n");
11761 /* Construct the API message */
11762 M(CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface);
11764 mp->sw_if_index = ntohl(sw_if_index);
11771 int api_classify_table_info (vat_main_t *vam)
11773 unformat_input_t * input = vam->input;
11774 vl_api_classify_table_info_t *mp;
11778 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11779 if (unformat (input, "table_id %d", &table_id))
11784 if (table_id == ~0) {
11785 errmsg ("missing table id\n");
11789 /* Construct the API message */
11790 M(CLASSIFY_TABLE_INFO, classify_table_info);
11792 mp->table_id = ntohl(table_id);
11799 int api_classify_session_dump (vat_main_t *vam)
11801 unformat_input_t * input = vam->input;
11802 vl_api_classify_session_dump_t *mp;
11806 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
11807 if (unformat (input, "table_id %d", &table_id))
11812 if (table_id == ~0) {
11813 errmsg ("missing table id\n");
11817 /* Construct the API message */
11818 M(CLASSIFY_SESSION_DUMP, classify_session_dump);
11820 mp->table_id = ntohl(table_id);
11823 /* Use a control ping for synchronization */
11825 vl_api_control_ping_t * mp;
11826 M(CONTROL_PING, control_ping);
11834 static int q_or_quit (vat_main_t * vam)
11836 longjmp (vam->jump_buf, 1);
11837 return 0; /* not so much */
11839 static int q (vat_main_t * vam) {return q_or_quit (vam);}
11840 static int quit (vat_main_t * vam) {return q_or_quit (vam);}
11842 static int comment (vat_main_t * vam)
11847 static int cmd_cmp (void * a1, void * a2)
11852 return strcmp ((char *)(c1[0]), (char *)(c2[0]));
11855 static int help (vat_main_t * vam)
11860 unformat_input_t * i = vam->input;
11863 if (unformat (i, "%s", &name)) {
11868 hs = hash_get_mem (vam->help_by_name, name);
11870 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
11872 fformat (vam->ofp, "No such msg / command '%s'\n", name);
11877 fformat(vam->ofp, "Help is available for the following:\n");
11879 hash_foreach_pair (p, vam->function_by_name,
11881 vec_add1 (cmds, (u8 *)(p->key));
11884 vec_sort_with_function (cmds, cmd_cmp);
11886 for (j = 0; j < vec_len(cmds); j++)
11887 fformat (vam->ofp, "%s\n", cmds[j]);
11893 static int set (vat_main_t * vam)
11895 u8 * name = 0, * value = 0;
11896 unformat_input_t * i = vam->input;
11898 if (unformat (i, "%s", &name)) {
11899 /* The input buffer is a vector, not a string. */
11900 value = vec_dup (i->buffer);
11901 vec_delete (value, i->index, 0);
11902 /* Almost certainly has a trailing newline */
11903 if (value[vec_len(value)-1] == '\n')
11904 value[vec_len(value)-1] = 0;
11905 /* Make sure it's a proper string, one way or the other */
11906 vec_add1 (value, 0);
11907 (void) clib_macro_set_value (&vam->macro_main,
11908 (char *)name, (char *)value);
11911 errmsg ("usage: set <name> <value>\n");
11918 static int unset (vat_main_t * vam)
11922 if (unformat (vam->input, "%s", &name))
11923 if (clib_macro_unset (&vam->macro_main, (char *)name) == 1)
11924 errmsg ("unset: %s wasn't set\n", name);
11935 static int macro_sort_cmp (void * a1, void * a2)
11937 macro_sort_t * s1 = a1;
11938 macro_sort_t * s2 = a2;
11940 return strcmp ((char *)(s1->name), (char *)(s2->name));
11943 static int dump_macro_table (vat_main_t * vam)
11945 macro_sort_t * sort_me = 0, * sm;
11949 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
11951 vec_add2 (sort_me, sm, 1);
11952 sm->name = (u8 *)(p->key);
11953 sm->value = (u8 *) (p->value[0]);
11956 vec_sort_with_function (sort_me, macro_sort_cmp);
11958 if (vec_len(sort_me))
11959 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
11961 fformat (vam->ofp, "The macro table is empty...\n");
11963 for (i = 0; i < vec_len (sort_me); i++)
11964 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name,
11969 static int dump_node_table (vat_main_t * vam)
11972 vlib_node_t * node, * next_node;
11974 if (vec_len (vam->graph_nodes) == 0) {
11975 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
11979 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
11980 node = vam->graph_nodes[i];
11981 fformat (vam->ofp, "[%d] %s\n", i, node->name);
11982 for (j = 0; j < vec_len (node->next_nodes); j++) {
11983 if (node->next_nodes[j] != ~0) {
11984 next_node = vam->graph_nodes[node->next_nodes[j]];
11985 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
11992 static int search_node_table (vat_main_t * vam)
11994 unformat_input_t * line_input = vam->input;
11997 vlib_node_t * node, * next_node;
12000 if (vam->graph_node_index_by_name == 0) {
12001 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
12005 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
12006 if (unformat (line_input, "%s", &node_to_find)) {
12007 vec_add1 (node_to_find, 0);
12008 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
12010 fformat (vam->ofp, "%s not found...\n", node_to_find);
12013 node = vam->graph_nodes[p[0]];
12014 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
12015 for (j = 0; j < vec_len (node->next_nodes); j++) {
12016 if (node->next_nodes[j] != ~0) {
12017 next_node = vam->graph_nodes[node->next_nodes[j]];
12018 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
12024 clib_warning ("parse error '%U'", format_unformat_error,
12030 vec_free(node_to_find);
12038 static int script (vat_main_t * vam)
12041 char * save_current_file;
12042 unformat_input_t save_input;
12043 jmp_buf save_jump_buf;
12044 u32 save_line_number;
12046 FILE * new_fp, * save_ifp;
12048 if (unformat (vam->input, "%s", &s)) {
12049 new_fp = fopen ((char *)s, "r");
12051 errmsg ("Couldn't open script file %s\n", s);
12056 errmsg ("Missing script name\n");
12060 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
12061 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
12062 save_ifp = vam->ifp;
12063 save_line_number = vam->input_line_number;
12064 save_current_file = (char *) vam->current_file;
12066 vam->input_line_number = 0;
12068 vam->current_file = s;
12071 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
12072 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
12073 vam->ifp = save_ifp;
12074 vam->input_line_number = save_line_number;
12075 vam->current_file = (u8 *) save_current_file;
12081 static int echo (vat_main_t * vam)
12083 fformat (vam->ofp, "%v", vam->input->buffer);
12087 /* List of API message constructors, CLI names map to api_xxx */
12088 #define foreach_vpe_api_msg \
12089 _(create_loopback,"[mac <mac-addr>]") \
12090 _(sw_interface_dump,"") \
12091 _(sw_interface_set_flags, \
12092 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
12093 _(sw_interface_add_del_address, \
12094 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
12095 _(sw_interface_set_table, \
12096 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
12097 _(sw_interface_set_vpath, \
12098 "<intfc> | sw_if_index <id> enable | disable") \
12099 _(sw_interface_set_l2_xconnect, \
12100 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12101 "enable | disable") \
12102 _(sw_interface_set_l2_bridge, \
12103 "rx <intfc> | rx_sw_if_index <id> bd_id <bridge-domain-id>\n" \
12104 "[shg <split-horizon-group>] [bvi]\n" \
12105 "enable | disable") \
12106 _(bridge_domain_add_del, \
12107 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
12108 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
12110 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi]\n") \
12112 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
12114 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
12116 "tapname <name> mac <mac-addr> | random-mac") \
12118 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
12120 "<vpp-if-name> | sw_if_index <id>") \
12121 _(sw_interface_tap_dump, "") \
12122 _(ip_add_del_route, \
12123 "<addr>/<mask> via <addr> [vrf <n>]\n" \
12124 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
12125 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
12126 "[multipath] [count <n>]") \
12127 _(proxy_arp_add_del, \
12128 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
12129 _(proxy_arp_intfc_enable_disable, \
12130 "<intfc> | sw_if_index <id> enable | disable") \
12131 _(mpls_add_del_encap, \
12132 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
12133 _(mpls_add_del_decap, \
12134 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
12135 _(mpls_gre_add_del_tunnel, \
12136 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
12137 "adj <ip4-address>/<mask-width> [del]") \
12138 _(sw_interface_set_unnumbered, \
12139 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
12140 _(ip_neighbor_add_del, \
12141 "<intfc> | sw_if_index <id> dst <ip46-address> mac <mac-addr>") \
12142 _(reset_vrf, "vrf <id> [ipv6]") \
12143 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
12144 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
12145 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
12146 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
12147 "[outer_vlan_id_any][inner_vlan_id_any]") \
12148 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
12149 _(reset_fib, "vrf <n> [ipv6]") \
12150 _(dhcp_proxy_config, \
12151 "svr <v46-address> src <v46-address>\n" \
12152 "insert-cid <n> [del]") \
12153 _(dhcp_proxy_config_2, \
12154 "svr <v46-address> src <v46-address>\n" \
12155 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
12156 _(dhcp_proxy_set_vss, \
12157 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
12158 _(dhcp_client_config, \
12159 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
12160 _(set_ip_flow_hash, \
12161 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
12162 _(sw_interface_ip6_enable_disable, \
12163 "<intfc> | sw_if_index <id> enable | disable") \
12164 _(sw_interface_ip6_set_link_local_address, \
12165 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
12166 _(sw_interface_ip6nd_ra_prefix, \
12167 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
12168 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
12169 "[nolink] [isno]") \
12170 _(sw_interface_ip6nd_ra_config, \
12171 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
12172 "[life <n>] [count <n>] [interval <n>] [suppress]\n" \
12173 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
12174 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
12175 _(l2_patch_add_del, \
12176 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
12177 "enable | disable") \
12178 _(mpls_ethernet_add_del_tunnel, \
12179 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
12180 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
12181 _(mpls_ethernet_add_del_tunnel_2, \
12182 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
12183 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
12184 _(sr_tunnel_add_del, \
12185 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
12186 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
12187 "[policy <policy_name>]") \
12188 _(sr_policy_add_del, \
12189 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
12190 _(sr_multicast_map_add_del, \
12191 "address [ip6 multicast address] sr-policy [policy name] [del]") \
12192 _(classify_add_del_table, \
12193 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
12194 "[del] mask <mask-value>\n" \
12195 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
12196 _(classify_add_del_session, \
12197 "[hit-next|l2-hit-next|acl-hit-next] <name|nn> table-index <nn>\n" \
12198 "skip_n <nn> match_n <nn> match [hex] [l2] [l3 [ip4|ip6]]") \
12199 _(classify_set_interface_ip_table, \
12200 "<intfc> | sw_if_index <nn> table <nn>") \
12201 _(classify_set_interface_l2_tables, \
12202 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
12203 " [other-table <nn>]") \
12204 _(get_node_index, "node <node-name") \
12205 _(add_node_next, "node <node-name> next <next-node-name>") \
12206 _(l2tpv3_create_tunnel, \
12207 "client_address <ip6-addr> our_address <ip6-addr>\n" \
12208 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
12209 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
12210 _(l2tpv3_set_tunnel_cookies, \
12211 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
12212 "[new_remote_cookie <nn>]\n") \
12213 _(l2tpv3_interface_enable_disable, \
12214 "<intfc> | sw_if_index <nn> enable | disable") \
12215 _(l2tpv3_set_lookup_key, \
12216 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
12217 _(sw_if_l2tpv3_tunnel_dump, "") \
12218 _(vxlan_add_del_tunnel, \
12219 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
12220 " [decap-next l2|ip4|ip6] [del]") \
12221 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12222 _(gre_add_del_tunnel, \
12223 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
12224 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12225 _(l2_fib_clear_table, "") \
12226 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
12227 _(l2_interface_vlan_tag_rewrite, \
12228 "<intfc> | sw_if_index <nn> \n" \
12229 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
12230 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
12231 _(create_vhost_user_if, \
12232 "socket <filename> [server] [renumber <dev_instance>] " \
12233 "[mac <mac_address>]") \
12234 _(modify_vhost_user_if, \
12235 "<intfc> | sw_if_index <nn> socket <filename>\n" \
12236 "[server] [renumber <dev_instance>]") \
12237 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
12238 _(sw_interface_vhost_user_dump, "") \
12239 _(show_version, "") \
12240 _(vxlan_gpe_add_del_tunnel, \
12241 "local <addr> remote <addr> vni <nn>\n" \
12242 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
12243 "[next-ethernet] [next-nsh]\n") \
12244 _(vxlan_gpe_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
12245 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
12246 _(interface_name_renumber, \
12247 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
12248 _(input_acl_set_interface, \
12249 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
12250 " [l2-table <nn>] [del]") \
12251 _(want_ip4_arp_events, "address <ip4-address> [del]") \
12252 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
12253 _(ip_dump, "ipv4 | ipv6") \
12254 _(ipsec_spd_add_del, "spd_id <n> [del]") \
12255 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
12257 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
12258 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
12259 " integ_alg <alg> integ_key <hex>") \
12260 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
12261 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
12262 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
12263 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
12264 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
12265 _(ikev2_profile_add_del, "name <profile_name> [del]") \
12266 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
12267 "(auth_data 0x<data> | auth_data <data>)") \
12268 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
12269 "(id_data 0x<data> | id_data <data>) (local|remote)") \
12270 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
12271 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
12272 "(local|remote)") \
12273 _(ikev2_set_local_key, "file <absolute_file_path>") \
12274 _(delete_loopback,"sw_if_index <nn>") \
12275 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
12276 _(map_add_domain, \
12277 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
12278 "ip6-src <ip6addr> " \
12279 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
12280 _(map_del_domain, "index <n>") \
12281 _(map_add_del_rule, \
12282 "index <n> psid <n> dst <ip6addr> [del]") \
12283 _(map_domain_dump, "") \
12284 _(map_rule_dump, "index <map-domain>") \
12285 _(want_interface_events, "enable|disable") \
12286 _(want_stats,"enable|disable") \
12287 _(get_first_msg_id, "client <name>") \
12288 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
12289 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
12290 "fib-id <nn> [ip4][ip6][default]") \
12291 _(get_node_graph, " ") \
12292 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
12293 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
12294 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
12295 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
12296 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
12297 " vrf_id <nn> add | pop | none") \
12298 _(trace_profile_del, "") \
12299 _(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \
12300 _(lisp_add_del_locator, "locator-set <locator_name> " \
12301 "iface <intf> | sw_if_index <sw_if_index> " \
12302 "p <priority> w <weight> [del]") \
12303 _(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \
12304 "locator-set <locator_name> [del]") \
12305 _(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \
12306 "sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \
12307 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
12308 _(lisp_gpe_enable_disable, "enable|disable") \
12309 _(lisp_enable_disable, "enable|disable") \
12310 _(lisp_gpe_add_del_iface, "up|down") \
12311 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> seid" \
12312 " <src-eid> rloc <locator> " \
12313 "[rloc <loc> ... ] action <action>") \
12314 _(lisp_add_del_adjacency, "add|del vni <vni> deid <dest-eid> seid" \
12315 " <src-eid> rloc <locator> " \
12316 "[rloc <loc> ... ] action <action>") \
12317 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
12318 _(lisp_add_del_map_request_itr_rlocs, "<loc-set-name> [del]") \
12319 _(lisp_eid_table_add_del_map, "[del] vni <vni> vrf <vrf>") \
12320 _(lisp_locator_set_dump, "") \
12321 _(lisp_local_eid_table_dump, "") \
12322 _(lisp_gpe_tunnel_dump, "") \
12323 _(lisp_map_resolver_dump, "") \
12324 _(lisp_enable_disable_status_dump, "") \
12325 _(lisp_get_map_request_itr_rlocs, "") \
12326 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
12327 _(af_packet_delete, "name <host interface name>") \
12328 _(policer_add_del, "name <policer name> <params> [del]") \
12329 _(policer_dump, "[name <policer name>]") \
12330 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
12331 "[master|slave]") \
12332 _(netmap_delete, "name <interface name>") \
12333 _(mpls_gre_tunnel_dump, "tunnel_index <tunnel-id>") \
12334 _(mpls_eth_tunnel_dump, "tunnel_index <tunnel-id>") \
12335 _(mpls_fib_encap_dump, "") \
12336 _(mpls_fib_decap_dump, "") \
12337 _(classify_table_ids, "") \
12338 _(classify_table_by_interface, "sw_if_index <sw_if_index>") \
12339 _(classify_table_info, "table_id <nn>") \
12340 _(classify_session_dump, "table_id <nn>")
12342 /* List of command functions, CLI names map directly to functions */
12343 #define foreach_cli_function \
12344 _(comment, "usage: comment <ignore-rest-of-line>") \
12345 _(dump_interface_table, "usage: dump_interface_table") \
12346 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
12347 _(dump_ipv4_table, "usage: dump_ipv4_table") \
12348 _(dump_ipv6_table, "usage: dump_ipv6_table") \
12349 _(dump_stats_table, "usage: dump_stats_table") \
12350 _(dump_macro_table, "usage: dump_macro_table ") \
12351 _(dump_node_table, "usage: dump_node_table") \
12352 _(echo, "usage: echo <message>") \
12353 _(exec, "usage: exec <vpe-debug-CLI-command>") \
12354 _(help, "usage: help") \
12355 _(q, "usage: quit") \
12356 _(quit, "usage: quit") \
12357 _(search_node_table, "usage: search_node_table <name>...") \
12358 _(set, "usage: set <variable-name> <value>") \
12359 _(script, "usage: script <file-name>") \
12360 _(unset, "usage: unset <variable-name>")
12363 static void vl_api_##n##_t_handler_uni \
12364 (vl_api_##n##_t * mp) \
12366 vat_main_t * vam = &vat_main; \
12367 if (vam->json_output) { \
12368 vl_api_##n##_t_handler_json(mp); \
12370 vl_api_##n##_t_handler(mp); \
12373 foreach_vpe_api_reply_msg;
12376 void vat_api_hookup (vat_main_t *vam)
12379 vl_msg_api_set_handlers(VL_API_##N, #n, \
12380 vl_api_##n##_t_handler_uni, \
12382 vl_api_##n##_t_endian, \
12383 vl_api_##n##_t_print, \
12384 sizeof(vl_api_##n##_t), 1);
12385 foreach_vpe_api_reply_msg;
12388 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
12390 vam->sw_if_index_by_interface_name =
12391 hash_create_string (0, sizeof (uword));
12393 vam->function_by_name =
12394 hash_create_string (0, sizeof(uword));
12396 vam->help_by_name =
12397 hash_create_string (0, sizeof(uword));
12399 /* API messages we can send */
12400 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
12401 foreach_vpe_api_msg;
12405 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
12406 foreach_vpe_api_msg;
12409 /* CLI functions */
12410 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
12411 foreach_cli_function;
12415 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
12416 foreach_cli_function;
12420 #undef vl_api_version
12421 #define vl_api_version(n,v) static u32 vpe_api_version = v;
12422 #include <vpp-api/vpe.api.h>
12423 #undef vl_api_version
12425 void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
12428 * Send the main API signature in slot 0. This bit of code must
12429 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
12431 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);