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 <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>
38 #include <vnet/ipsec/ipsec.h>
39 #include <vnet/ipsec/ikev2.h>
43 #include <vnet/map/map.h>
44 #include <vnet/cop/cop.h>
45 #include <vnet/ip/ip6_hop_by_hop.h>
46 #include <vnet/policer/xlate.h>
48 #include "vat/json_format.h"
50 #define vl_typedefs /* define message structures */
51 #include <api/vpe_all_api_h.h>
54 /* declare message handlers for each api */
56 #define vl_endianfun /* define message structures */
57 #include <api/vpe_all_api_h.h>
60 /* instantiate all the print functions we know about */
61 #define vl_print(handle, ...)
63 #include <api/vpe_all_api_h.h>
66 uword unformat_sw_if_index (unformat_input_t * input, va_list * args)
68 vat_main_t * vam = va_arg (*args, vat_main_t *);
69 u32 * result = va_arg (*args, u32 *);
73 if (!unformat (input, "%s", &if_name))
76 p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
83 /* Parse an IP4 address %d.%d.%d.%d. */
84 uword unformat_ip4_address (unformat_input_t * input, va_list * args)
86 u8 * result = va_arg (*args, u8 *);
89 if (! unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
92 if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
105 unformat_ethernet_address (unformat_input_t * input, va_list * args)
107 u8 * result = va_arg (*args, u8 *);
110 if (! unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
111 &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
115 for (i = 0; i < 6; i++)
116 if (a[i] >= (1 << 8))
119 for (i = 0; i < 6; i++)
125 /* Returns ethernet type as an int in host byte order. */
127 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
130 u16 * result = va_arg (*args, u16 *);
134 if (unformat (input, "0x%x", &type)
135 || unformat (input, "%d", &type))
137 if (type >= (1 << 16))
145 /* Parse an IP6 address. */
146 uword unformat_ip6_address (unformat_input_t * input, va_list * args)
148 ip6_address_t * result = va_arg (*args, ip6_address_t *);
150 uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
151 uword c, n_colon, double_colon_index;
153 n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
154 double_colon_index = ARRAY_LEN (hex_quads);
155 while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
158 if (c >= '0' && c <= '9')
160 else if (c >= 'a' && c <= 'f')
161 hex_digit = c + 10 - 'a';
162 else if (c >= 'A' && c <= 'F')
163 hex_digit = c + 10 - 'A';
164 else if (c == ':' && n_colon < 2)
168 unformat_put_input (input);
172 /* Too many hex quads. */
173 if (n_hex_quads >= ARRAY_LEN (hex_quads))
178 hex_quad = (hex_quad << 4) | hex_digit;
180 /* Hex quad must fit in 16 bits. */
181 if (n_hex_digits >= 4)
188 /* Save position of :: */
191 /* More than one :: ? */
192 if (double_colon_index < ARRAY_LEN (hex_quads))
194 double_colon_index = n_hex_quads;
197 if (n_colon > 0 && n_hex_digits > 0)
199 hex_quads[n_hex_quads++] = hex_quad;
205 if (n_hex_digits > 0)
206 hex_quads[n_hex_quads++] = hex_quad;
211 /* Expand :: to appropriate number of zero hex quads. */
212 if (double_colon_index < ARRAY_LEN (hex_quads))
214 word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
216 for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
217 hex_quads[n_zero + i] = hex_quads[i];
219 for (i = 0; i < n_zero; i++)
220 hex_quads[double_colon_index + i] = 0;
222 n_hex_quads = ARRAY_LEN (hex_quads);
225 /* Too few hex quads given. */
226 if (n_hex_quads < ARRAY_LEN (hex_quads))
229 for (i = 0; i < ARRAY_LEN (hex_quads); i++)
230 result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
237 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
240 u32 * r = va_arg (*args, u32 *);
243 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
244 foreach_ipsec_policy_action
255 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
258 u32 * r = va_arg (*args, u32 *);
261 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
262 foreach_ipsec_crypto_alg
273 format_ipsec_crypto_alg (u8 * s, va_list * args)
276 u32 i = va_arg (*args, u32);
281 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
282 foreach_ipsec_crypto_alg
285 return format (s, "unknown");
287 return format (s, "%s", t);
289 return format (s, "Unimplemented");
294 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
297 u32 * r = va_arg (*args, u32 *);
300 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
301 foreach_ipsec_integ_alg
312 format_ipsec_integ_alg (u8 * s, va_list * args)
315 u32 i = va_arg (*args, u32);
320 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
321 foreach_ipsec_integ_alg
324 return format (s, "unknown");
326 return format (s, "%s", t);
328 return format (s, "Unsupported");
333 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
336 u32 * r = va_arg (*args, u32 *);
339 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
340 foreach_ikev2_auth_method
351 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
354 u32 * r = va_arg (*args, u32 *);
357 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
358 foreach_ikev2_id_type
369 unformat_policer_rate_type (unformat_input_t * input, va_list * args)
371 u8 * r = va_arg (*args, u8 *);
373 if (unformat (input, "kbps"))
374 *r = SSE2_QOS_RATE_KBPS;
375 else if (unformat(input, "pps"))
376 *r = SSE2_QOS_RATE_PPS;
383 unformat_policer_round_type (unformat_input_t * input, va_list * args)
385 u8 * r = va_arg (*args, u8 *);
387 if (unformat(input, "closest"))
388 *r = SSE2_QOS_ROUND_TO_CLOSEST;
389 else if (unformat (input, "up"))
390 *r = SSE2_QOS_ROUND_TO_UP;
391 else if (unformat (input, "down"))
392 *r = SSE2_QOS_ROUND_TO_DOWN;
399 unformat_policer_type (unformat_input_t * input, va_list * args)
401 u8 * r = va_arg (*args, u8 *);
403 if (unformat (input, "1r2c"))
404 *r = SSE2_QOS_POLICER_TYPE_1R2C;
405 else if (unformat (input, "1r3c"))
406 *r = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
407 else if (unformat (input, "2r3c-2698"))
408 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
409 else if (unformat (input, "2r3c-4115"))
410 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
411 else if (unformat (input, "2r3c-mef5cf1"))
412 *r = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
418 u8 * format_ip4_address (u8 * s, va_list * args)
420 u8 * a = va_arg (*args, u8 *);
421 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
424 u8 * format_ip6_address (u8 * s, va_list * args)
426 ip6_address_t * a = va_arg (*args, ip6_address_t *);
427 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
429 i_max_n_zero = ARRAY_LEN (a->as_u16);
431 i_first_zero = i_max_n_zero;
433 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
435 u32 is_zero = a->as_u16[i] == 0;
436 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
442 if ((! is_zero && n_zeros > max_n_zeros)
443 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
445 i_max_n_zero = i_first_zero;
446 max_n_zeros = n_zeros;
447 i_first_zero = ARRAY_LEN (a->as_u16);
452 last_double_colon = 0;
453 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
455 if (i == i_max_n_zero && max_n_zeros > 1)
457 s = format (s, "::");
458 i += max_n_zeros - 1;
459 last_double_colon = 1;
463 s = format (s, "%s%x",
464 (last_double_colon || i == 0) ? "" : ":",
465 clib_net_to_host_u16 (a->as_u16[i]));
466 last_double_colon = 0;
473 /* Format an IP46 address. */
474 u8 * format_ip46_address (u8 * s, va_list * args)
476 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
477 return ip46_address_is_ip4(ip46)?
478 format(s, "%U", format_ip4_address, &ip46->ip4):
479 format(s, "%U", format_ip6_address, &ip46->ip6);
482 u8 * format_ethernet_address (u8 * s, va_list * args)
484 u8 * a = va_arg (*args, u8 *);
486 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
487 a[0], a[1], a[2], a[3], a[4], a[5]);
490 void increment_v4_address (ip4_address_t * a)
494 v = ntohl(a->as_u32) + 1;
495 a->as_u32 = ntohl(v);
498 void increment_v6_address (ip6_address_t * a)
502 v0 = clib_net_to_host_u64 (a->as_u64[0]);
503 v1 = clib_net_to_host_u64 (a->as_u64[1]);
508 a->as_u64[0] = clib_net_to_host_u64 (v0);
509 a->as_u64[1] = clib_net_to_host_u64 (v1);
513 static void vl_api_create_loopback_reply_t_handler
514 (vl_api_create_loopback_reply_t * mp)
516 vat_main_t * vam = &vat_main;
517 i32 retval = ntohl(mp->retval);
519 vam->retval = retval;
520 vam->result_ready = 1;
521 vam->regenerate_interface_table = 1;
524 static void vl_api_create_loopback_reply_t_handler_json
525 (vl_api_create_loopback_reply_t * mp)
527 vat_main_t * vam = &vat_main;
528 vat_json_node_t node;
530 vat_json_init_object(&node);
531 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
532 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
534 vat_json_print(vam->ofp, &node);
535 vat_json_free(&node);
537 vam->retval = ntohl(mp->retval);
538 vam->result_ready = 1;
541 static void vl_api_create_vlan_subif_reply_t_handler
542 (vl_api_create_vlan_subif_reply_t * mp)
544 vat_main_t * vam = &vat_main;
545 i32 retval = ntohl(mp->retval);
547 vam->retval = retval;
548 vam->result_ready = 1;
549 vam->regenerate_interface_table = 1;
552 static void vl_api_create_vlan_subif_reply_t_handler_json
553 (vl_api_create_vlan_subif_reply_t * mp)
555 vat_main_t * vam = &vat_main;
556 vat_json_node_t node;
558 vat_json_init_object(&node);
559 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
560 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
562 vat_json_print(vam->ofp, &node);
563 vat_json_free(&node);
565 vam->retval = ntohl(mp->retval);
566 vam->result_ready = 1;
569 static void vl_api_create_subif_reply_t_handler
570 (vl_api_create_subif_reply_t * mp)
572 vat_main_t * vam = &vat_main;
573 i32 retval = ntohl(mp->retval);
575 vam->retval = retval;
576 vam->result_ready = 1;
577 vam->regenerate_interface_table = 1;
580 static void vl_api_create_subif_reply_t_handler_json
581 (vl_api_create_subif_reply_t * mp)
583 vat_main_t * vam = &vat_main;
584 vat_json_node_t node;
586 vat_json_init_object(&node);
587 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
588 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
590 vat_json_print(vam->ofp, &node);
591 vat_json_free(&node);
593 vam->retval = ntohl(mp->retval);
594 vam->result_ready = 1;
597 static void vl_api_interface_name_renumber_reply_t_handler
598 (vl_api_interface_name_renumber_reply_t * mp)
600 vat_main_t * vam = &vat_main;
601 i32 retval = ntohl(mp->retval);
603 vam->retval = retval;
604 vam->result_ready = 1;
605 vam->regenerate_interface_table = 1;
608 static void vl_api_interface_name_renumber_reply_t_handler_json
609 (vl_api_interface_name_renumber_reply_t * mp)
611 vat_main_t * vam = &vat_main;
612 vat_json_node_t node;
614 vat_json_init_object(&node);
615 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
617 vat_json_print(vam->ofp, &node);
618 vat_json_free(&node);
620 vam->retval = ntohl(mp->retval);
621 vam->result_ready = 1;
625 * Special-case: build the interface table, maintain
626 * the next loopback sw_if_index vbl.
628 static void vl_api_sw_interface_details_t_handler
629 (vl_api_sw_interface_details_t * mp)
631 vat_main_t * vam = &vat_main;
632 u8 * s = format (0, "%s%c", mp->interface_name, 0);
634 hash_set_mem (vam->sw_if_index_by_interface_name, s,
635 ntohl(mp->sw_if_index));
637 /* In sub interface case, fill the sub interface table entry */
638 if (mp->sw_if_index != mp->sup_sw_if_index) {
639 sw_interface_subif_t * sub = NULL;
641 vec_add2(vam->sw_if_subif_table, sub, 1);
643 vec_validate(sub->interface_name, strlen((char *)s) + 1);
644 strncpy((char *)sub->interface_name, (char *)s,
645 vec_len(sub->interface_name));
646 sub->sw_if_index = ntohl(mp->sw_if_index);
647 sub->sub_id = ntohl(mp->sub_id);
649 sub->sub_dot1ad = mp->sub_dot1ad;
650 sub->sub_number_of_tags = mp->sub_number_of_tags;
651 sub->sub_outer_vlan_id = ntohs(mp->sub_outer_vlan_id);
652 sub->sub_inner_vlan_id = ntohs(mp->sub_inner_vlan_id);
653 sub->sub_exact_match = mp->sub_exact_match;
654 sub->sub_default = mp->sub_default;
655 sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any;
656 sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
658 /* vlan tag rewrite */
659 sub->vtr_op = ntohl(mp->vtr_op);
660 sub->vtr_push_dot1q = ntohl(mp->vtr_push_dot1q);
661 sub->vtr_tag1 = ntohl(mp->vtr_tag1);
662 sub->vtr_tag2 = ntohl(mp->vtr_tag2);
666 static void vl_api_sw_interface_details_t_handler_json
667 (vl_api_sw_interface_details_t * mp)
669 vat_main_t * vam = &vat_main;
670 vat_json_node_t *node = NULL;
672 if (VAT_JSON_ARRAY != vam->json_tree.type) {
673 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
674 vat_json_init_array(&vam->json_tree);
676 node = vat_json_array_add(&vam->json_tree);
678 vat_json_init_object(node);
679 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
680 vat_json_object_add_uint(node, "sup_sw_if_index", ntohl(mp->sup_sw_if_index));
681 vat_json_object_add_uint(node, "l2_address_length", ntohl(mp->l2_address_length));
682 vat_json_object_add_bytes(node, "l2_address", mp->l2_address, sizeof(mp->l2_address));
683 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
684 vat_json_object_add_uint(node, "admin_up_down", mp->admin_up_down);
685 vat_json_object_add_uint(node, "link_up_down", mp->link_up_down);
686 vat_json_object_add_uint(node, "link_duplex", mp->link_duplex);
687 vat_json_object_add_uint(node, "link_speed", mp->link_speed);
688 vat_json_object_add_uint(node, "mtu", ntohs(mp->link_mtu));
689 vat_json_object_add_uint(node, "sub_id", ntohl(mp->sub_id));
690 vat_json_object_add_uint(node, "sub_dot1ad", mp->sub_dot1ad);
691 vat_json_object_add_uint(node, "sub_number_of_tags", mp->sub_number_of_tags);
692 vat_json_object_add_uint(node, "sub_outer_vlan_id", ntohs(mp->sub_outer_vlan_id));
693 vat_json_object_add_uint(node, "sub_inner_vlan_id", ntohs(mp->sub_inner_vlan_id));
694 vat_json_object_add_uint(node, "sub_exact_match", mp->sub_exact_match);
695 vat_json_object_add_uint(node, "sub_default", mp->sub_default);
696 vat_json_object_add_uint(node, "sub_outer_vlan_id_any", mp->sub_outer_vlan_id_any);
697 vat_json_object_add_uint(node, "sub_inner_vlan_id_any", mp->sub_inner_vlan_id_any);
698 vat_json_object_add_uint(node, "vtr_op", ntohl(mp->vtr_op));
699 vat_json_object_add_uint(node, "vtr_push_dot1q", ntohl(mp->vtr_push_dot1q));
700 vat_json_object_add_uint(node, "vtr_tag1", ntohl(mp->vtr_tag1));
701 vat_json_object_add_uint(node, "vtr_tag2", ntohl(mp->vtr_tag2));
704 static void vl_api_sw_interface_set_flags_t_handler
705 (vl_api_sw_interface_set_flags_t * mp)
707 vat_main_t * vam = &vat_main;
708 if (vam->interface_event_display)
709 errmsg ("interface flags: sw_if_index %d %s %s\n",
710 ntohl(mp->sw_if_index),
711 mp->admin_up_down ? "admin-up" : "admin-down",
712 mp->link_up_down ? "link-up" : "link-down");
715 static void vl_api_sw_interface_set_flags_t_handler_json
716 (vl_api_sw_interface_set_flags_t * mp)
718 /* JSON output not supported */
721 static void vl_api_cli_reply_t_handler
722 (vl_api_cli_reply_t * mp)
724 vat_main_t * vam = &vat_main;
725 i32 retval = ntohl(mp->retval);
727 vam->retval = retval;
728 vam->shmem_result = (u8 *) mp->reply_in_shmem;
729 vam->result_ready = 1;
732 static void vl_api_cli_reply_t_handler_json
733 (vl_api_cli_reply_t * mp)
735 vat_main_t * vam = &vat_main;
736 vat_json_node_t node;
737 api_main_t * am = &api_main;
741 vat_json_init_object(&node);
742 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
743 vat_json_object_add_uint(&node, "reply_in_shmem",
744 ntohl(mp->reply_in_shmem));
745 /* Toss the shared-memory original... */
746 pthread_mutex_lock (&am->vlib_rp->mutex);
747 oldheap = svm_push_data_heap (am->vlib_rp);
749 reply = (u8 *)(mp->reply_in_shmem);
752 svm_pop_heap (oldheap);
753 pthread_mutex_unlock (&am->vlib_rp->mutex);
755 vat_json_print(vam->ofp, &node);
756 vat_json_free(&node);
758 vam->retval = ntohl(mp->retval);
759 vam->result_ready = 1;
762 static void vl_api_classify_add_del_table_reply_t_handler
763 (vl_api_classify_add_del_table_reply_t * mp)
765 vat_main_t * vam = &vat_main;
766 i32 retval = ntohl(mp->retval);
767 if (vam->async_mode) {
768 vam->async_errors += (retval < 0);
770 vam->retval = retval;
771 vam->result_ready = 1;
773 ((mp->new_table_index != 0xFFFFFFFF) ||
774 (mp->skip_n_vectors != 0xFFFFFFFF) ||
775 (mp->match_n_vectors != 0xFFFFFFFF)))
777 * Note: this is just barely thread-safe, depends on
778 * the main thread spinning waiting for an answer...
780 errmsg ("new index %d, skip_n_vectors %d, match_n_vectors %d\n",
781 ntohl(mp->new_table_index),
782 ntohl(mp->skip_n_vectors), ntohl(mp->match_n_vectors));
786 static void vl_api_classify_add_del_table_reply_t_handler_json
787 (vl_api_classify_add_del_table_reply_t * mp)
789 vat_main_t * vam = &vat_main;
790 vat_json_node_t node;
792 vat_json_init_object(&node);
793 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
794 vat_json_object_add_uint(&node, "new_table_index", ntohl(mp->new_table_index));
795 vat_json_object_add_uint(&node, "skip_n_vectors", ntohl(mp->skip_n_vectors));
796 vat_json_object_add_uint(&node, "match_n_vectors", ntohl(mp->match_n_vectors));
798 vat_json_print(vam->ofp, &node);
799 vat_json_free(&node);
801 vam->retval = ntohl(mp->retval);
802 vam->result_ready = 1;
805 static void vl_api_get_node_index_reply_t_handler
806 (vl_api_get_node_index_reply_t * mp)
808 vat_main_t * vam = &vat_main;
809 i32 retval = ntohl(mp->retval);
810 if (vam->async_mode) {
811 vam->async_errors += (retval < 0);
813 vam->retval = retval;
814 vam->result_ready = 1;
816 errmsg ("node index %d\n", ntohl(mp->node_index));
820 static void vl_api_get_node_index_reply_t_handler_json
821 (vl_api_get_node_index_reply_t * mp)
823 vat_main_t * vam = &vat_main;
824 vat_json_node_t node;
826 vat_json_init_object(&node);
827 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
828 vat_json_object_add_uint(&node, "node_index", ntohl(mp->node_index));
830 vat_json_print(vam->ofp, &node);
831 vat_json_free(&node);
833 vam->retval = ntohl(mp->retval);
834 vam->result_ready = 1;
837 static void vl_api_add_node_next_reply_t_handler
838 (vl_api_add_node_next_reply_t * mp)
840 vat_main_t * vam = &vat_main;
841 i32 retval = ntohl(mp->retval);
842 if (vam->async_mode) {
843 vam->async_errors += (retval < 0);
845 vam->retval = retval;
846 vam->result_ready = 1;
848 errmsg ("next index %d\n", ntohl(mp->next_index));
852 static void vl_api_add_node_next_reply_t_handler_json
853 (vl_api_add_node_next_reply_t * mp)
855 vat_main_t * vam = &vat_main;
856 vat_json_node_t node;
858 vat_json_init_object(&node);
859 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
860 vat_json_object_add_uint(&node, "next_index", ntohl(mp->next_index));
862 vat_json_print(vam->ofp, &node);
863 vat_json_free(&node);
865 vam->retval = ntohl(mp->retval);
866 vam->result_ready = 1;
869 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler
870 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
872 vat_main_t * vam = &vat_main;
873 i32 retval = ntohl(mp->retval);
874 u32 sw_if_index = ntohl(mp->tunnel_sw_if_index);
876 if (retval >= 0 && sw_if_index != (u32)~0) {
877 errmsg ("tunnel_sw_if_index %d\n", sw_if_index);
879 vam->retval = retval;
880 vam->result_ready = 1;
883 static void vl_api_mpls_gre_add_del_tunnel_reply_t_handler_json
884 (vl_api_mpls_gre_add_del_tunnel_reply_t * mp)
886 vat_main_t * vam = &vat_main;
887 vat_json_node_t node;
889 vat_json_init_object(&node);
890 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
891 vat_json_object_add_uint(&node, "tunnel_sw_if_index", ntohl(mp->tunnel_sw_if_index));
893 vat_json_print(vam->ofp, &node);
894 vat_json_free(&node);
896 vam->retval = ntohl(mp->retval);
897 vam->result_ready = 1;
901 static void vl_api_show_version_reply_t_handler
902 (vl_api_show_version_reply_t * mp)
904 vat_main_t * vam = &vat_main;
905 i32 retval = ntohl(mp->retval);
908 errmsg (" program: %s\n", mp->program);
909 errmsg (" version: %s\n", mp->version);
910 errmsg (" build date: %s\n", mp->build_date);
911 errmsg ("build directory: %s\n", mp->build_directory);
913 vam->retval = retval;
914 vam->result_ready = 1;
917 static void vl_api_show_version_reply_t_handler_json
918 (vl_api_show_version_reply_t * mp)
920 vat_main_t * vam = &vat_main;
921 vat_json_node_t node;
923 vat_json_init_object(&node);
924 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
925 vat_json_object_add_string_copy(&node, "program", mp->program);
926 vat_json_object_add_string_copy(&node, "version", mp->version);
927 vat_json_object_add_string_copy(&node, "build_date", mp->build_date);
928 vat_json_object_add_string_copy(&node, "build_directory", mp->build_directory);
930 vat_json_print(vam->ofp, &node);
931 vat_json_free(&node);
933 vam->retval = ntohl(mp->retval);
934 vam->result_ready = 1;
937 static void vl_api_ip4_arp_event_t_handler
938 (vl_api_ip4_arp_event_t * mp)
940 vat_main_t * vam = &vat_main;
941 errmsg ("arp event: address %U new mac %U sw_if_index %d\n",
942 format_ip4_address, &mp->address,
943 format_ethernet_address, mp->new_mac, mp->sw_if_index);
946 static void vl_api_ip4_arp_event_t_handler_json
947 (vl_api_ip4_arp_event_t * mp)
949 /* JSON output not supported */
953 * Special-case: build the bridge domain table, maintain
954 * the next bd id vbl.
956 static void vl_api_bridge_domain_details_t_handler
957 (vl_api_bridge_domain_details_t * mp)
959 vat_main_t * vam = &vat_main;
960 u32 n_sw_ifs = ntohl (mp->n_sw_ifs);
962 fformat (vam->ofp, "\n%-3s %-3s %-3s %-3s %-3s %-3s\n",
963 " ID", "LRN", "FWD", "FLD", "BVI", "#IF");
965 fformat (vam->ofp, "%3d %3d %3d %3d %3d %3d\n",
966 ntohl (mp->bd_id), mp->learn, mp->forward,
967 mp->flood, ntohl (mp->bvi_sw_if_index), n_sw_ifs);
970 fformat (vam->ofp, "\n\n%s %s %s\n", "sw_if_index", "SHG",
974 static void vl_api_bridge_domain_details_t_handler_json
975 (vl_api_bridge_domain_details_t * mp)
977 vat_main_t * vam = &vat_main;
978 vat_json_node_t *node, *array = NULL;
980 if (VAT_JSON_ARRAY != vam->json_tree.type) {
981 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
982 vat_json_init_array(&vam->json_tree);
984 node = vat_json_array_add(&vam->json_tree);
986 vat_json_init_object(node);
987 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
988 vat_json_object_add_uint(node, "flood", mp->flood);
989 vat_json_object_add_uint(node, "forward", mp->forward);
990 vat_json_object_add_uint(node, "learn", mp->learn);
991 vat_json_object_add_uint(node, "bvi_sw_if_index", ntohl(mp->bvi_sw_if_index));
992 vat_json_object_add_uint(node, "n_sw_ifs", ntohl(mp->n_sw_ifs));
993 array = vat_json_object_add(node, "sw_if");
994 vat_json_init_array(array);
998 * Special-case: build the bridge domain sw if table.
1000 static void vl_api_bridge_domain_sw_if_details_t_handler
1001 (vl_api_bridge_domain_sw_if_details_t * mp)
1003 vat_main_t * vam = &vat_main;
1005 u8 * sw_if_name = 0;
1008 sw_if_index = ntohl (mp->sw_if_index);
1009 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
1011 if ((u32) p->value[0] == sw_if_index) {
1012 sw_if_name = (u8 *)(p->key);
1017 fformat (vam->ofp, "%7d %3d %s", sw_if_index,
1018 mp->shg, sw_if_name ? (char *)sw_if_name :
1019 "sw_if_index not found!");
1022 static void vl_api_bridge_domain_sw_if_details_t_handler_json
1023 (vl_api_bridge_domain_sw_if_details_t * mp)
1025 vat_main_t * vam = &vat_main;
1026 vat_json_node_t *node = NULL;
1027 uword last_index = 0;
1029 ASSERT(VAT_JSON_ARRAY == vam->json_tree.type);
1030 ASSERT(vec_len(vam->json_tree.array) >= 1);
1031 last_index = vec_len(vam->json_tree.array) - 1;
1032 node = &vam->json_tree.array[last_index];
1033 node = vat_json_object_get_element(node, "sw_if");
1034 ASSERT(NULL != node);
1035 node = vat_json_array_add(node);
1037 vat_json_init_object(node);
1038 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
1039 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
1040 vat_json_object_add_uint(node, "shg", mp->shg);
1043 static void vl_api_control_ping_reply_t_handler
1044 (vl_api_control_ping_reply_t * mp)
1046 vat_main_t * vam = &vat_main;
1047 i32 retval = ntohl(mp->retval);
1048 if (vam->async_mode) {
1049 vam->async_errors += (retval < 0);
1051 vam->retval = retval;
1052 vam->result_ready = 1;
1056 static void vl_api_control_ping_reply_t_handler_json
1057 (vl_api_control_ping_reply_t * mp)
1059 vat_main_t * vam = &vat_main;
1060 i32 retval = ntohl(mp->retval);
1062 if (VAT_JSON_NONE != vam->json_tree.type) {
1063 vat_json_print(vam->ofp, &vam->json_tree);
1064 vat_json_free(&vam->json_tree);
1065 vam->json_tree.type = VAT_JSON_NONE;
1068 vat_json_init_array(&vam->json_tree);
1069 vat_json_print(vam->ofp, &vam->json_tree);
1070 vam->json_tree.type = VAT_JSON_NONE;
1073 vam->retval = retval;
1074 vam->result_ready = 1;
1077 static void vl_api_l2_flags_reply_t_handler
1078 (vl_api_l2_flags_reply_t * mp)
1080 vat_main_t * vam = &vat_main;
1081 i32 retval = ntohl(mp->retval);
1082 if (vam->async_mode) {
1083 vam->async_errors += (retval < 0);
1085 vam->retval = retval;
1086 vam->result_ready = 1;
1090 static void vl_api_l2_flags_reply_t_handler_json
1091 (vl_api_l2_flags_reply_t * mp)
1093 vat_main_t * vam = &vat_main;
1094 vat_json_node_t node;
1096 vat_json_init_object(&node);
1097 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1098 vat_json_object_add_uint(&node, "resulting_feature_bitmap", ntohl(mp->resulting_feature_bitmap));
1100 vat_json_print(vam->ofp, &node);
1101 vat_json_free(&node);
1103 vam->retval = ntohl(mp->retval);
1104 vam->result_ready = 1;
1107 static void vl_api_bridge_flags_reply_t_handler
1108 (vl_api_bridge_flags_reply_t * mp)
1110 vat_main_t * vam = &vat_main;
1111 i32 retval = ntohl(mp->retval);
1112 if (vam->async_mode) {
1113 vam->async_errors += (retval < 0);
1115 vam->retval = retval;
1116 vam->result_ready = 1;
1120 static void vl_api_bridge_flags_reply_t_handler_json
1121 (vl_api_bridge_flags_reply_t * mp)
1123 vat_main_t * vam = &vat_main;
1124 vat_json_node_t node;
1126 vat_json_init_object(&node);
1127 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1128 vat_json_object_add_uint(&node, "resulting_feature_bitmap", ntohl(mp->resulting_feature_bitmap));
1130 vat_json_print(vam->ofp, &node);
1131 vat_json_free(&node);
1133 vam->retval = ntohl(mp->retval);
1134 vam->result_ready = 1;
1137 static void vl_api_tap_connect_reply_t_handler
1138 (vl_api_tap_connect_reply_t * mp)
1140 vat_main_t * vam = &vat_main;
1141 i32 retval = ntohl(mp->retval);
1142 if (vam->async_mode) {
1143 vam->async_errors += (retval < 0);
1145 vam->retval = retval;
1146 vam->result_ready = 1;
1150 static void vl_api_tap_connect_reply_t_handler_json
1151 (vl_api_tap_connect_reply_t * mp)
1153 vat_main_t * vam = &vat_main;
1154 vat_json_node_t node;
1156 vat_json_init_object(&node);
1157 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1158 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1160 vat_json_print(vam->ofp, &node);
1161 vat_json_free(&node);
1163 vam->retval = ntohl(mp->retval);
1164 vam->result_ready = 1;
1167 static void vl_api_tap_modify_reply_t_handler
1168 (vl_api_tap_modify_reply_t * mp)
1170 vat_main_t * vam = &vat_main;
1171 i32 retval = ntohl(mp->retval);
1172 if (vam->async_mode) {
1173 vam->async_errors += (retval < 0);
1175 vam->retval = retval;
1176 vam->result_ready = 1;
1180 static void vl_api_tap_modify_reply_t_handler_json
1181 (vl_api_tap_modify_reply_t * mp)
1183 vat_main_t * vam = &vat_main;
1184 vat_json_node_t node;
1186 vat_json_init_object(&node);
1187 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1188 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1190 vat_json_print(vam->ofp, &node);
1191 vat_json_free(&node);
1193 vam->retval = ntohl(mp->retval);
1194 vam->result_ready = 1;
1197 static void vl_api_tap_delete_reply_t_handler
1198 (vl_api_tap_delete_reply_t * mp)
1200 vat_main_t * vam = &vat_main;
1201 i32 retval = ntohl(mp->retval);
1202 if (vam->async_mode) {
1203 vam->async_errors += (retval < 0);
1205 vam->retval = retval;
1206 vam->result_ready = 1;
1210 static void vl_api_tap_delete_reply_t_handler_json
1211 (vl_api_tap_delete_reply_t * mp)
1213 vat_main_t * vam = &vat_main;
1214 vat_json_node_t node;
1216 vat_json_init_object(&node);
1217 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1219 vat_json_print(vam->ofp, &node);
1220 vat_json_free(&node);
1222 vam->retval = ntohl(mp->retval);
1223 vam->result_ready = 1;
1226 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler
1227 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1229 vat_main_t * vam = &vat_main;
1230 i32 retval = ntohl(mp->retval);
1231 if (vam->async_mode) {
1232 vam->async_errors += (retval < 0);
1234 vam->retval = retval;
1235 vam->result_ready = 1;
1239 static void vl_api_mpls_ethernet_add_del_tunnel_reply_t_handler_json
1240 (vl_api_mpls_ethernet_add_del_tunnel_reply_t * mp)
1242 vat_main_t * vam = &vat_main;
1243 vat_json_node_t node;
1245 vat_json_init_object(&node);
1246 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1247 vat_json_object_add_uint(&node, "tunnel_sw_if_index", ntohl(mp->tunnel_sw_if_index));
1249 vat_json_print(vam->ofp, &node);
1250 vat_json_free(&node);
1252 vam->retval = ntohl(mp->retval);
1253 vam->result_ready = 1;
1256 static void vl_api_l2tpv3_create_tunnel_reply_t_handler
1257 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1259 vat_main_t * vam = &vat_main;
1260 i32 retval = ntohl(mp->retval);
1261 if (vam->async_mode) {
1262 vam->async_errors += (retval < 0);
1264 vam->retval = retval;
1265 vam->result_ready = 1;
1269 static void vl_api_l2tpv3_create_tunnel_reply_t_handler_json
1270 (vl_api_l2tpv3_create_tunnel_reply_t * mp)
1272 vat_main_t * vam = &vat_main;
1273 vat_json_node_t node;
1275 vat_json_init_object(&node);
1276 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1277 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1279 vat_json_print(vam->ofp, &node);
1280 vat_json_free(&node);
1282 vam->retval = ntohl(mp->retval);
1283 vam->result_ready = 1;
1286 static void vl_api_vxlan_add_del_tunnel_reply_t_handler
1287 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1289 vat_main_t * vam = &vat_main;
1290 i32 retval = ntohl(mp->retval);
1291 if (vam->async_mode) {
1292 vam->async_errors += (retval < 0);
1294 vam->retval = retval;
1295 vam->result_ready = 1;
1299 static void vl_api_vxlan_add_del_tunnel_reply_t_handler_json
1300 (vl_api_vxlan_add_del_tunnel_reply_t * mp)
1302 vat_main_t * vam = &vat_main;
1303 vat_json_node_t node;
1305 vat_json_init_object(&node);
1306 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1307 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1309 vat_json_print(vam->ofp, &node);
1310 vat_json_free(&node);
1312 vam->retval = ntohl(mp->retval);
1313 vam->result_ready = 1;
1316 static void vl_api_gre_add_del_tunnel_reply_t_handler
1317 (vl_api_gre_add_del_tunnel_reply_t * mp)
1319 vat_main_t * vam = &vat_main;
1320 i32 retval = ntohl(mp->retval);
1321 if (vam->async_mode) {
1322 vam->async_errors += (retval < 0);
1324 vam->retval = retval;
1325 vam->result_ready = 1;
1329 static void vl_api_gre_add_del_tunnel_reply_t_handler_json
1330 (vl_api_gre_add_del_tunnel_reply_t * mp)
1332 vat_main_t * vam = &vat_main;
1333 vat_json_node_t node;
1335 vat_json_init_object(&node);
1336 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1337 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1339 vat_json_print(vam->ofp, &node);
1340 vat_json_free(&node);
1342 vam->retval = ntohl(mp->retval);
1343 vam->result_ready = 1;
1346 static void vl_api_create_vhost_user_if_reply_t_handler
1347 (vl_api_create_vhost_user_if_reply_t * mp)
1349 vat_main_t * vam = &vat_main;
1350 i32 retval = ntohl(mp->retval);
1351 if (vam->async_mode) {
1352 vam->async_errors += (retval < 0);
1354 vam->retval = retval;
1355 vam->result_ready = 1;
1359 static void vl_api_create_vhost_user_if_reply_t_handler_json
1360 (vl_api_create_vhost_user_if_reply_t * mp)
1362 vat_main_t * vam = &vat_main;
1363 vat_json_node_t node;
1365 vat_json_init_object(&node);
1366 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1367 vat_json_object_add_uint(&node, "sw_if_index", ntohl(mp->sw_if_index));
1369 vat_json_print(vam->ofp, &node);
1370 vat_json_free(&node);
1372 vam->retval = ntohl(mp->retval);
1373 vam->result_ready = 1;
1376 static void vl_api_ip_address_details_t_handler
1377 (vl_api_ip_address_details_t * mp)
1379 vat_main_t * vam = &vat_main;
1380 static ip_address_details_t empty_ip_address_details = {{0}};
1381 ip_address_details_t * address = NULL;
1382 ip_details_t * current_ip_details = NULL;
1383 ip_details_t * details = NULL;
1385 details = vam->ip_details_by_sw_if_index[vam->is_ipv6];
1387 if (!details || vam->current_sw_if_index >= vec_len(details)
1388 || !details[vam->current_sw_if_index].present) {
1389 errmsg ("ip address details arrived but not stored\n");
1390 errmsg ("ip_dump should be called first\n");
1394 current_ip_details = vec_elt_at_index(details,
1395 vam->current_sw_if_index);
1397 #define addresses (current_ip_details->addr)
1399 vec_validate_init_empty(addresses, vec_len(addresses),
1400 empty_ip_address_details);
1402 address = vec_elt_at_index(addresses, vec_len(addresses) - 1);
1404 clib_memcpy(&address->ip, &mp->ip, sizeof(address->ip));
1405 address->prefix_length = mp->prefix_length;
1409 static void vl_api_ip_address_details_t_handler_json
1410 (vl_api_ip_address_details_t * mp)
1412 vat_main_t * vam = &vat_main;
1413 vat_json_node_t *node = NULL;
1414 struct in6_addr ip6;
1417 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1418 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1419 vat_json_init_array(&vam->json_tree);
1421 node = vat_json_array_add(&vam->json_tree);
1423 vat_json_init_object(node);
1425 clib_memcpy(&ip6, mp->ip, sizeof(ip6));
1426 vat_json_object_add_ip6(node, "ip", ip6);
1428 clib_memcpy(&ip4, mp->ip, sizeof(ip4));
1429 vat_json_object_add_ip4(node, "ip", ip4);
1431 vat_json_object_add_uint(node, "prefix_length", mp->prefix_length);
1434 static void vl_api_ip_details_t_handler (vl_api_ip_details_t * mp)
1436 vat_main_t * vam = &vat_main;
1437 static ip_details_t empty_ip_details = {0};
1438 ip_details_t * ip = NULL;
1439 u32 sw_if_index = ~0;
1441 sw_if_index = ntohl(mp->sw_if_index);
1443 vec_validate_init_empty(vam->ip_details_by_sw_if_index[vam->is_ipv6],
1444 sw_if_index, empty_ip_details);
1446 ip = vec_elt_at_index(vam->ip_details_by_sw_if_index[vam->is_ipv6],
1452 static void vl_api_ip_details_t_handler_json (vl_api_ip_details_t * mp)
1454 vat_main_t * vam = &vat_main;
1456 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1457 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1458 vat_json_init_array(&vam->json_tree);
1460 vat_json_array_add_uint(&vam->json_tree, clib_net_to_host_u32(mp->sw_if_index));
1463 static void vl_api_map_domain_details_t_handler_json
1464 (vl_api_map_domain_details_t * mp)
1466 vat_json_node_t * node = NULL;
1467 vat_main_t * vam = &vat_main;
1468 struct in6_addr ip6;
1471 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1472 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1473 vat_json_init_array(&vam->json_tree);
1476 node = vat_json_array_add(&vam->json_tree);
1477 vat_json_init_object(node);
1479 vat_json_object_add_uint(node, "domain_index", clib_net_to_host_u32(mp->domain_index));
1480 clib_memcpy(&ip6, mp->ip6_prefix, sizeof(ip6));
1481 vat_json_object_add_ip6(node, "ip6_prefix", ip6);
1482 clib_memcpy(&ip4, mp->ip4_prefix, sizeof(ip4));
1483 vat_json_object_add_ip4(node, "ip4_prefix", ip4);
1484 clib_memcpy(&ip6, mp->ip6_src, sizeof(ip6));
1485 vat_json_object_add_ip6(node, "ip6_src", ip6);
1486 vat_json_object_add_int(node, "ip6_prefix_len", mp->ip6_prefix_len);
1487 vat_json_object_add_int(node, "ip4_prefix_len", mp->ip4_prefix_len);
1488 vat_json_object_add_int(node, "ip6_src_len", mp->ip6_src_len);
1489 vat_json_object_add_int(node, "ea_bits_len", mp->ea_bits_len);
1490 vat_json_object_add_int(node, "psid_offset", mp->psid_offset);
1491 vat_json_object_add_int(node, "psid_length", mp->psid_length);
1492 vat_json_object_add_uint(node, "flags", mp->flags);
1493 vat_json_object_add_uint(node, "mtu", clib_net_to_host_u16(mp->mtu));
1494 vat_json_object_add_int(node, "is_translation", mp->is_translation);
1497 static void vl_api_map_domain_details_t_handler
1498 (vl_api_map_domain_details_t * mp)
1500 vat_main_t * vam = &vat_main;
1502 if (mp->is_translation) {
1503 fformat(vam->ofp, "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U/%d (ip6-src) index: %u\n",
1504 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1505 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1506 format_ip6_address, mp->ip6_src, mp->ip6_src_len, clib_net_to_host_u32(mp->domain_index));
1508 fformat(vam->ofp, "* %U/%d (ipv4-prefix) %U/%d (ipv6-prefix) %U (ip6-src) index: %u\n",
1509 format_ip4_address, mp->ip4_prefix, mp->ip4_prefix_len,
1510 format_ip6_address, mp->ip6_prefix, mp->ip6_prefix_len,
1511 format_ip6_address, mp->ip6_src, clib_net_to_host_u32(mp->domain_index));
1513 fformat(vam->ofp, " ea-len %d psid-offset %d psid-len %d mtu %d %s\n",
1514 mp->ea_bits_len, mp->psid_offset, mp->psid_length, mp->mtu, mp->is_translation? "map-t":"");
1517 static void vl_api_map_rule_details_t_handler_json
1518 (vl_api_map_rule_details_t * mp)
1520 struct in6_addr ip6;
1521 vat_json_node_t * node = NULL;
1522 vat_main_t * vam = &vat_main;
1524 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1525 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1526 vat_json_init_array(&vam->json_tree);
1529 node = vat_json_array_add(&vam->json_tree);
1530 vat_json_init_object(node);
1532 vat_json_object_add_uint(node, "psid", clib_net_to_host_u16(mp->psid));
1533 clib_memcpy(&ip6, mp->ip6_dst, sizeof(ip6));
1534 vat_json_object_add_ip6(node, "ip6_dst", ip6);
1537 static void vl_api_map_rule_details_t_handler
1538 (vl_api_map_rule_details_t * mp)
1540 vat_main_t * vam = &vat_main;
1541 fformat(vam->ofp, " %d (psid) %U (ip6-dst)\n", clib_net_to_host_u16(mp->psid),
1542 format_ip6_address, mp->ip6_dst);
1545 static void vl_api_dhcp_compl_event_t_handler
1546 (vl_api_dhcp_compl_event_t * mp)
1548 vat_main_t * vam = &vat_main;
1549 errmsg ("DHCP compl event: pid %d %s hostname %s host_addr %U "
1550 "router_addr %U host_mac %U\n",
1551 mp->pid, mp->is_ipv6 ? "ipv6":"ipv4", mp->hostname,
1552 format_ip4_address, &mp->host_address,
1553 format_ip4_address, &mp->router_address,
1554 format_ethernet_address, mp->host_mac);
1557 static void vl_api_dhcp_compl_event_t_handler_json
1558 (vl_api_dhcp_compl_event_t * mp)
1560 /* JSON output not supported */
1563 static void set_simple_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1566 vat_main_t * vam = &vat_main;
1567 static u64 default_counter = 0;
1569 vec_validate_init_empty(vam->simple_interface_counters, vnet_counter_type, NULL);
1570 vec_validate_init_empty(vam->simple_interface_counters[vnet_counter_type],
1571 sw_if_index, default_counter);
1572 vam->simple_interface_counters[vnet_counter_type][sw_if_index] = counter;
1575 static void set_combined_interface_counter (u8 vnet_counter_type, u32 sw_if_index,
1576 interface_counter_t counter)
1578 vat_main_t * vam = &vat_main;
1579 static interface_counter_t default_counter = {0, };
1581 vec_validate_init_empty(vam->combined_interface_counters, vnet_counter_type, NULL);
1582 vec_validate_init_empty(vam->combined_interface_counters[vnet_counter_type],
1583 sw_if_index, default_counter);
1584 vam->combined_interface_counters[vnet_counter_type][sw_if_index] = counter;
1587 static void vl_api_vnet_interface_counters_t_handler
1588 (vl_api_vnet_interface_counters_t *mp)
1593 static void vl_api_vnet_interface_counters_t_handler_json
1594 (vl_api_vnet_interface_counters_t *mp)
1596 interface_counter_t counter;
1601 u32 first_sw_if_index;
1604 count = ntohl(mp->count);
1605 first_sw_if_index = ntohl(mp->first_sw_if_index);
1607 if (!mp->is_combined) {
1608 v_packets = (u64*)&mp->data;
1609 for (i = 0; i < count; i++) {
1610 packets = clib_net_to_host_u64(clib_mem_unaligned(v_packets, u64));
1611 set_simple_interface_counter(mp->vnet_counter_type,
1612 first_sw_if_index + i, packets);
1616 v = (vlib_counter_t*)&mp->data;
1617 for (i = 0; i < count; i++) {
1618 counter.packets = clib_net_to_host_u64(
1619 clib_mem_unaligned(&v->packets, u64));
1620 counter.bytes = clib_net_to_host_u64(
1621 clib_mem_unaligned(&v->bytes, u64));
1622 set_combined_interface_counter(mp->vnet_counter_type,
1623 first_sw_if_index + i, counter);
1629 static u32 ip4_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1631 vat_main_t * vam = &vat_main;
1634 for (i = 0; i < vec_len(vam->ip4_fib_counters_vrf_id_by_index); i++) {
1635 if (vam->ip4_fib_counters_vrf_id_by_index[i] == vrf_id) {
1642 static u32 ip6_fib_counters_get_vrf_index_by_vrf_id (u32 vrf_id)
1644 vat_main_t * vam = &vat_main;
1647 for (i = 0; i < vec_len(vam->ip6_fib_counters_vrf_id_by_index); i++) {
1648 if (vam->ip6_fib_counters_vrf_id_by_index[i] == vrf_id) {
1655 static void vl_api_vnet_ip4_fib_counters_t_handler
1656 (vl_api_vnet_ip4_fib_counters_t *mp)
1661 static void vl_api_vnet_ip4_fib_counters_t_handler_json
1662 (vl_api_vnet_ip4_fib_counters_t *mp)
1664 vat_main_t * vam = &vat_main;
1665 vl_api_ip4_fib_counter_t *v;
1666 ip4_fib_counter_t *counter;
1673 vrf_id = ntohl(mp->vrf_id);
1674 vrf_index = ip4_fib_counters_get_vrf_index_by_vrf_id(vrf_id);
1675 if (~0 == vrf_index) {
1676 vrf_index = vec_len(vam->ip4_fib_counters_vrf_id_by_index);
1677 vec_validate(vam->ip4_fib_counters_vrf_id_by_index, vrf_index);
1678 vam->ip4_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1679 vec_validate(vam->ip4_fib_counters, vrf_index);
1680 vam->ip4_fib_counters[vrf_index] = NULL;
1683 vec_free(vam->ip4_fib_counters[vrf_index]);
1684 v = (vl_api_ip4_fib_counter_t*)&mp->c;
1685 count = ntohl(mp->count);
1686 for (i = 0; i < count; i++) {
1687 vec_validate(vam->ip4_fib_counters[vrf_index], i);
1688 counter = &vam->ip4_fib_counters[vrf_index][i];
1689 clib_memcpy(&ip4, &v->address, sizeof(ip4));
1690 counter->address = ip4;
1691 counter->address_length = v->address_length;
1692 counter->packets = clib_net_to_host_u64(v->packets);
1693 counter->bytes = clib_net_to_host_u64(v->bytes);
1698 static void vl_api_vnet_ip6_fib_counters_t_handler
1699 (vl_api_vnet_ip6_fib_counters_t *mp)
1704 static void vl_api_vnet_ip6_fib_counters_t_handler_json
1705 (vl_api_vnet_ip6_fib_counters_t *mp)
1707 vat_main_t * vam = &vat_main;
1708 vl_api_ip6_fib_counter_t *v;
1709 ip6_fib_counter_t *counter;
1710 struct in6_addr ip6;
1716 vrf_id = ntohl(mp->vrf_id);
1717 vrf_index = ip6_fib_counters_get_vrf_index_by_vrf_id(vrf_id);
1718 if (~0 == vrf_index) {
1719 vrf_index = vec_len(vam->ip6_fib_counters_vrf_id_by_index);
1720 vec_validate(vam->ip6_fib_counters_vrf_id_by_index, vrf_index);
1721 vam->ip6_fib_counters_vrf_id_by_index[vrf_index] = vrf_id;
1722 vec_validate(vam->ip6_fib_counters, vrf_index);
1723 vam->ip6_fib_counters[vrf_index] = NULL;
1726 vec_free(vam->ip6_fib_counters[vrf_index]);
1727 v = (vl_api_ip6_fib_counter_t*)&mp->c;
1728 count = ntohl(mp->count);
1729 for (i = 0; i < count; i++) {
1730 vec_validate(vam->ip6_fib_counters[vrf_index], i);
1731 counter = &vam->ip6_fib_counters[vrf_index][i];
1732 clib_memcpy(&ip6, &v->address, sizeof(ip6));
1733 counter->address = ip6;
1734 counter->address_length = v->address_length;
1735 counter->packets = clib_net_to_host_u64(v->packets);
1736 counter->bytes = clib_net_to_host_u64(v->bytes);
1741 static void vl_api_get_first_msg_id_reply_t_handler
1742 (vl_api_get_first_msg_id_reply_t * mp)
1744 vat_main_t * vam = &vat_main;
1745 i32 retval = ntohl(mp->retval);
1747 if (vam->async_mode) {
1748 vam->async_errors += (retval < 0);
1750 vam->retval = retval;
1751 vam->result_ready = 1;
1754 errmsg ("first message id %d\n", ntohs(mp->first_msg_id));
1758 static void vl_api_get_first_msg_id_reply_t_handler_json
1759 (vl_api_get_first_msg_id_reply_t * mp)
1761 vat_main_t * vam = &vat_main;
1762 vat_json_node_t node;
1764 vat_json_init_object(&node);
1765 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1766 vat_json_object_add_uint(&node, "first_msg_id",
1767 (uint) ntohs(mp->first_msg_id));
1769 vat_json_print(vam->ofp, &node);
1770 vat_json_free(&node);
1772 vam->retval = ntohl(mp->retval);
1773 vam->result_ready = 1;
1776 static void vl_api_get_node_graph_reply_t_handler
1777 (vl_api_get_node_graph_reply_t * mp)
1779 vat_main_t * vam = &vat_main;
1780 api_main_t * am = &api_main;
1781 i32 retval = ntohl(mp->retval);
1782 u8 * pvt_copy, * reply;
1787 if (vam->async_mode) {
1788 vam->async_errors += (retval < 0);
1790 vam->retval = retval;
1791 vam->result_ready = 1;
1794 /* "Should never happen..." */
1798 reply = (u8 *)(mp->reply_in_shmem);
1799 pvt_copy = vec_dup (reply);
1801 /* Toss the shared-memory original... */
1802 pthread_mutex_lock (&am->vlib_rp->mutex);
1803 oldheap = svm_push_data_heap (am->vlib_rp);
1807 svm_pop_heap (oldheap);
1808 pthread_mutex_unlock (&am->vlib_rp->mutex);
1810 if (vam->graph_nodes) {
1811 hash_free (vam->graph_node_index_by_name);
1813 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
1814 node = vam->graph_nodes[i];
1815 vec_free (node->name);
1816 vec_free (node->next_nodes);
1819 vec_free(vam->graph_nodes);
1822 vam->graph_node_index_by_name = hash_create_string (0, sizeof(uword));
1823 vam->graph_nodes = vlib_node_unserialize (pvt_copy);
1824 vec_free (pvt_copy);
1826 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
1827 node = vam->graph_nodes[i];
1828 hash_set_mem (vam->graph_node_index_by_name, node->name, i);
1832 static void vl_api_get_node_graph_reply_t_handler_json
1833 (vl_api_get_node_graph_reply_t * mp)
1835 vat_main_t * vam = &vat_main;
1836 api_main_t * am = &api_main;
1838 vat_json_node_t node;
1841 /* $$$$ make this real? */
1842 vat_json_init_object(&node);
1843 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
1844 vat_json_object_add_uint(&node, "reply_in_shmem", mp->reply_in_shmem);
1846 reply = (u8 *)(mp->reply_in_shmem);
1848 /* Toss the shared-memory original... */
1849 pthread_mutex_lock (&am->vlib_rp->mutex);
1850 oldheap = svm_push_data_heap (am->vlib_rp);
1854 svm_pop_heap (oldheap);
1855 pthread_mutex_unlock (&am->vlib_rp->mutex);
1857 vat_json_print(vam->ofp, &node);
1858 vat_json_free(&node);
1860 vam->retval = ntohl(mp->retval);
1861 vam->result_ready = 1;
1865 vl_api_lisp_locator_set_details_t_handler (
1866 vl_api_lisp_locator_set_details_t *mp)
1868 vat_main_t *vam = &vat_main;
1869 u8 * tmp_str = NULL;
1872 fformat(vam->ofp, "%=20s%=16d%=16d%=16d\n",
1873 mp->locator_set_name,
1874 ntohl(mp->sw_if_index),
1878 tmp_str = format(0,"%U/%d",
1879 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
1883 fformat(vam->ofp, "%=20s%=16s%=16d%=16d\n",
1884 mp->locator_set_name,
1893 vl_api_lisp_locator_set_details_t_handler_json (
1894 vl_api_lisp_locator_set_details_t *mp)
1896 vat_main_t *vam = &vat_main;
1897 vat_json_node_t *node = NULL;
1898 struct in6_addr ip6;
1901 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1902 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1903 vat_json_init_array(&vam->json_tree);
1905 node = vat_json_array_add(&vam->json_tree);
1907 vat_json_init_object(node);
1908 vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
1910 vat_json_object_add_uint(node, "locator", ntohl(mp->sw_if_index));
1913 clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
1914 vat_json_object_add_ip6(node, "locator", ip6);
1916 clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
1917 vat_json_object_add_ip4(node, "locator", ip4);
1919 vat_json_object_add_uint(node, "prefix-length", mp->prefix_len);
1921 vat_json_object_add_uint(node, "priority", mp->priority);
1922 vat_json_object_add_uint(node, "weight", mp->weight);
1926 vl_api_lisp_local_eid_table_details_t_handler (
1927 vl_api_lisp_local_eid_table_details_t *mp)
1929 vat_main_t *vam = &vat_main;
1932 prefix = format(0, "%U/%d",
1933 mp->eid_is_ipv6 ? format_ip6_address : format_ip4_address,
1935 mp->eid_prefix_len);
1937 fformat(vam->ofp, "%=20s%=30s\n",
1938 mp->locator_set_name, prefix);
1944 vl_api_lisp_local_eid_table_details_t_handler_json (
1945 vl_api_lisp_local_eid_table_details_t *mp)
1947 vat_main_t *vam = &vat_main;
1948 vat_json_node_t *node = NULL;
1949 struct in6_addr ip6;
1952 if (VAT_JSON_ARRAY != vam->json_tree.type) {
1953 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
1954 vat_json_init_array(&vam->json_tree);
1956 node = vat_json_array_add(&vam->json_tree);
1958 vat_json_init_object(node);
1959 vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name);
1960 if (mp->eid_is_ipv6) {
1961 clib_memcpy(&ip6, mp->eid_ip_address, sizeof(ip6));
1962 vat_json_object_add_ip6(node, "eid address", ip6);
1964 clib_memcpy(&ip4, mp->eid_ip_address, sizeof(ip4));
1965 vat_json_object_add_ip4(node, "eid address", ip4);
1967 vat_json_object_add_uint(node, "eid prefix len", mp->eid_prefix_len);
1971 format_decap_next (u8 * s, va_list * args)
1973 u32 next_index = va_arg (*args, u32);
1977 case LISP_GPE_INPUT_NEXT_DROP:
1978 return format (s, "drop");
1979 case LISP_GPE_INPUT_NEXT_IP4_INPUT:
1980 return format (s, "ip4");
1981 case LISP_GPE_INPUT_NEXT_IP6_INPUT:
1982 return format (s, "ip6");
1984 return format (s, "unknown %d", next_index);
1990 vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *mp)
1992 vat_main_t *vam = &vat_main;
1994 u8 *flag_str = NULL;
1996 iid_str = format(0, "%d (0x%x)", ntohl(mp->iid), ntohl(mp->iid));
1998 #define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n);
1999 foreach_lisp_gpe_flag_bit;
2002 fformat(vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U"
2003 "%=16d%=16d%=16sd=16d%=16s%=16s\n",
2005 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2007 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2009 ntohl(mp->encap_fib_id),
2010 ntohl(mp->decap_fib_id),
2011 format_decap_next, ntohl(mp->dcap_next),
2023 vl_api_lisp_gpe_tunnel_details_t_handler_json (
2024 vl_api_lisp_gpe_tunnel_details_t *mp)
2026 vat_main_t *vam = &vat_main;
2027 vat_json_node_t *node = NULL;
2028 struct in6_addr ip6;
2032 next_decap_str = format(0, "%U", format_decap_next, htonl(mp->dcap_next));
2034 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2035 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2036 vat_json_init_array(&vam->json_tree);
2038 node = vat_json_array_add(&vam->json_tree);
2040 vat_json_init_object(node);
2041 vat_json_object_add_uint(node, "tunel", mp->tunnels);
2043 clib_memcpy(&ip6, mp->source_ip, sizeof(ip6));
2044 vat_json_object_add_ip6(node, "source address", ip6);
2045 clib_memcpy(&ip6, mp->destination_ip, sizeof(ip6));
2046 vat_json_object_add_ip6(node, "destination address", ip6);
2048 clib_memcpy(&ip4, mp->source_ip, sizeof(ip4));
2049 vat_json_object_add_ip4(node, "source address", ip4);
2050 clib_memcpy(&ip4, mp->destination_ip, sizeof(ip4));
2051 vat_json_object_add_ip4(node, "destination address", ip4);
2053 vat_json_object_add_uint(node, "fib encap", ntohl(mp->encap_fib_id));
2054 vat_json_object_add_uint(node, "fib decap", ntohl(mp->decap_fib_id));
2055 vat_json_object_add_string_copy(node, "decap next", next_decap_str);
2056 vat_json_object_add_uint(node, "lisp version", mp->ver_res >> 6);
2057 vat_json_object_add_uint(node, "flags", mp->flags);
2058 vat_json_object_add_uint(node, "next protocol", mp->next_protocol);
2059 vat_json_object_add_uint(node, "ver_res", mp->ver_res);
2060 vat_json_object_add_uint(node, "res", mp->res);
2061 vat_json_object_add_uint(node, "iid", ntohl(mp->iid));
2063 vec_free(next_decap_str);
2067 vl_api_lisp_map_resolver_details_t_handler (
2068 vl_api_lisp_map_resolver_details_t *mp)
2070 vat_main_t *vam = &vat_main;
2072 fformat(vam->ofp, "%=20U\n",
2073 mp->is_ipv6 ? format_ip6_address : format_ip4_address,
2078 vl_api_lisp_map_resolver_details_t_handler_json (
2079 vl_api_lisp_map_resolver_details_t *mp)
2081 vat_main_t *vam = &vat_main;
2082 vat_json_node_t *node = NULL;
2083 struct in6_addr ip6;
2086 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2087 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2088 vat_json_init_array(&vam->json_tree);
2090 node = vat_json_array_add(&vam->json_tree);
2092 vat_json_init_object(node);
2094 clib_memcpy(&ip6, mp->ip_address, sizeof(ip6));
2095 vat_json_object_add_ip6(node, "map resolver", ip6);
2097 clib_memcpy(&ip4, mp->ip_address, sizeof(ip4));
2098 vat_json_object_add_ip4(node, "map resolver", ip4);
2103 vl_api_lisp_enable_disable_status_details_t_handler
2104 (vl_api_lisp_enable_disable_status_details_t *mp)
2106 vat_main_t *vam = &vat_main;
2108 fformat(vam->ofp, "feature: %s\ngpe: %s\n",
2109 mp->feature_status ? "enabled" : "disabled",
2110 mp->gpe_status ? "enabled" : "disabled");
2114 vl_api_lisp_enable_disable_status_details_t_handler_json
2115 (vl_api_lisp_enable_disable_status_details_t *mp)
2117 vat_main_t *vam = &vat_main;
2118 vat_json_node_t *node = NULL;
2119 u8 * gpe_status = NULL;
2120 u8 * feature_status = NULL;
2122 gpe_status = format (0, "%s", mp->gpe_status ? "enabled" : "disabled");
2123 feature_status = format (0, "%s",
2124 mp->feature_status ? "enabled" : "disabled");
2126 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2127 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2128 vat_json_init_array(&vam->json_tree);
2130 node = vat_json_array_add(&vam->json_tree);
2132 vat_json_init_object(node);
2133 vat_json_object_add_string_copy(node, "gpe_status", gpe_status);
2134 vat_json_object_add_string_copy(node, "feature_status", feature_status);
2136 vec_free (gpe_status);
2137 vec_free (feature_status);
2140 static u8 * format_policer_type (u8 * s, va_list * va)
2142 u32 i = va_arg (*va, u32);
2144 if (i == SSE2_QOS_POLICER_TYPE_1R2C)
2145 s = format (s, "1r2c");
2146 else if (i == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
2147 s = format (s, "1r3c");
2148 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
2149 s = format (s, "2r3c-2698");
2150 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
2151 s = format (s, "2r3c-4115");
2152 else if (i == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
2153 s = format (s, "2r3c-mef5cf1");
2155 s = format (s, "ILLEGAL");
2159 static u8 * format_policer_rate_type (u8 * s, va_list * va)
2161 u32 i = va_arg (*va, u32);
2163 if (i == SSE2_QOS_RATE_KBPS)
2164 s = format (s, "kbps");
2165 else if (i == SSE2_QOS_RATE_PPS)
2166 s = format(s, "pps");
2168 s = format (s, "ILLEGAL");
2172 static u8 * format_policer_round_type (u8 * s, va_list * va)
2174 u32 i = va_arg (*va, u32);
2176 if (i == SSE2_QOS_ROUND_TO_CLOSEST)
2177 s = format(s, "closest");
2178 else if (i == SSE2_QOS_ROUND_TO_UP)
2179 s = format (s, "up");
2180 else if (i == SSE2_QOS_ROUND_TO_DOWN)
2181 s = format (s, "down");
2183 s = format (s, "ILLEGAL");
2187 static void vl_api_policer_details_t_handler
2188 (vl_api_policer_details_t * mp)
2190 vat_main_t * vam = &vat_main;
2192 fformat (vam->ofp, "Name \"%s\", type %U, cir %u, eir %u, cb %u, eb %u, "
2193 "rate type %U, round type %U, %s rate, %s color-aware, "
2194 "cir %u tok/period, pir %u tok/period, scale %u, cur lim %u, "
2195 "cur bkt %u, ext lim %u, ext bkt %u, last update %llu\n",
2197 format_policer_type, mp->type,
2202 format_policer_rate_type, mp->rate_type,
2203 format_policer_round_type, mp->round_type,
2204 mp->single_rate ? "single" : "dual",
2205 mp->color_aware ? "is" : "not",
2206 ntohl(mp->cir_tokens_per_period),
2207 ntohl(mp->pir_tokens_per_period),
2209 ntohl(mp->current_limit),
2210 ntohl(mp->current_bucket),
2211 ntohl(mp->extended_limit),
2212 ntohl(mp->extended_bucket),
2213 clib_net_to_host_u64(mp->last_update_time));
2216 static void vl_api_policer_details_t_handler_json
2217 (vl_api_policer_details_t * mp)
2219 vat_main_t * vam = &vat_main;
2220 vat_json_node_t *node;
2221 u8 *rate_type_str, *round_type_str, *type_str;
2223 rate_type_str = format(0, "%U", format_policer_rate_type, mp->rate_type);
2224 round_type_str = format(0, "%U", format_policer_round_type, mp->round_type);
2225 type_str = format(0, "%U", format_policer_type, mp->type);
2227 if (VAT_JSON_ARRAY != vam->json_tree.type) {
2228 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
2229 vat_json_init_array(&vam->json_tree);
2231 node = vat_json_array_add(&vam->json_tree);
2233 vat_json_init_object(node);
2234 vat_json_object_add_string_copy(node, "name", mp->name);
2235 vat_json_object_add_uint(node, "cir", ntohl(mp->cir));
2236 vat_json_object_add_uint(node, "eir", ntohl(mp->eir));
2237 vat_json_object_add_uint(node, "cb", ntohl(mp->cb));
2238 vat_json_object_add_uint(node, "eb", ntohl(mp->eb));
2239 vat_json_object_add_string_copy(node, "rate_type", rate_type_str);
2240 vat_json_object_add_string_copy(node, "round_type", round_type_str);
2241 vat_json_object_add_string_copy(node, "type", type_str);
2242 vat_json_object_add_uint(node, "single_rate", mp->single_rate);
2243 vat_json_object_add_uint(node, "color_aware", mp->color_aware);
2244 vat_json_object_add_uint(node, "scale", ntohl(mp->scale));
2245 vat_json_object_add_uint(node, "cir_tokens_per_period",
2246 ntohl(mp->cir_tokens_per_period));
2247 vat_json_object_add_uint(node, "eir_tokens_per_period",
2248 ntohl(mp->pir_tokens_per_period));
2249 vat_json_object_add_uint(node, "current_limit", ntohl(mp->current_limit));
2250 vat_json_object_add_uint(node, "current_bucket", ntohl(mp->current_bucket));
2251 vat_json_object_add_uint(node, "extended_limit", ntohl(mp->extended_limit));
2252 vat_json_object_add_uint(node, "extended_bucket",
2253 ntohl(mp->extended_bucket));
2254 vat_json_object_add_uint(node, "last_update_time",
2255 ntohl(mp->last_update_time));
2257 vec_free(rate_type_str);
2258 vec_free(round_type_str);
2263 #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler
2264 #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler
2265 #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler
2266 #define vl_api_vnet_ip6_fib_counters_t_print vl_noop_handler
2269 * Generate boilerplate reply handlers, which
2270 * dig the return value out of the xxx_reply_t API message,
2271 * stick it into vam->retval, and set vam->result_ready
2273 * Could also do this by pointing N message decode slots at
2274 * a single function, but that could break in subtle ways.
2277 #define foreach_standard_reply_retval_handler \
2278 _(sw_interface_set_flags_reply) \
2279 _(sw_interface_add_del_address_reply) \
2280 _(sw_interface_set_table_reply) \
2281 _(sw_interface_set_vpath_reply) \
2282 _(sw_interface_set_l2_bridge_reply) \
2283 _(bridge_domain_add_del_reply) \
2284 _(sw_interface_set_l2_xconnect_reply) \
2285 _(l2fib_add_del_reply) \
2286 _(ip_add_del_route_reply) \
2287 _(proxy_arp_add_del_reply) \
2288 _(proxy_arp_intfc_enable_disable_reply) \
2289 _(mpls_add_del_encap_reply) \
2290 _(mpls_add_del_decap_reply) \
2291 _(mpls_ethernet_add_del_tunnel_2_reply) \
2292 _(sw_interface_set_unnumbered_reply) \
2293 _(ip_neighbor_add_del_reply) \
2294 _(reset_vrf_reply) \
2295 _(oam_add_del_reply) \
2296 _(reset_fib_reply) \
2297 _(dhcp_proxy_config_reply) \
2298 _(dhcp_proxy_config_2_reply) \
2299 _(dhcp_proxy_set_vss_reply) \
2300 _(dhcp_client_config_reply) \
2301 _(set_ip_flow_hash_reply) \
2302 _(sw_interface_ip6_enable_disable_reply) \
2303 _(sw_interface_ip6_set_link_local_address_reply) \
2304 _(sw_interface_ip6nd_ra_prefix_reply) \
2305 _(sw_interface_ip6nd_ra_config_reply) \
2306 _(set_arp_neighbor_limit_reply) \
2307 _(l2_patch_add_del_reply) \
2308 _(sr_tunnel_add_del_reply) \
2309 _(sr_policy_add_del_reply) \
2310 _(sr_multicast_map_add_del_reply) \
2311 _(classify_add_del_session_reply) \
2312 _(classify_set_interface_ip_table_reply) \
2313 _(classify_set_interface_l2_tables_reply) \
2314 _(l2tpv3_set_tunnel_cookies_reply) \
2315 _(l2tpv3_interface_enable_disable_reply) \
2316 _(l2tpv3_set_lookup_key_reply) \
2317 _(l2_fib_clear_table_reply) \
2318 _(l2_interface_efp_filter_reply) \
2319 _(l2_interface_vlan_tag_rewrite_reply) \
2320 _(modify_vhost_user_if_reply) \
2321 _(delete_vhost_user_if_reply) \
2322 _(want_ip4_arp_events_reply) \
2323 _(input_acl_set_interface_reply) \
2324 _(ipsec_spd_add_del_reply) \
2325 _(ipsec_interface_add_del_spd_reply) \
2326 _(ipsec_spd_add_del_entry_reply) \
2327 _(ipsec_sad_add_del_entry_reply) \
2328 _(ipsec_sa_set_key_reply) \
2329 _(ikev2_profile_add_del_reply) \
2330 _(ikev2_profile_set_auth_reply) \
2331 _(ikev2_profile_set_id_reply) \
2332 _(ikev2_profile_set_ts_reply) \
2333 _(ikev2_set_local_key_reply) \
2334 _(delete_loopback_reply) \
2335 _(bd_ip_mac_add_del_reply) \
2336 _(map_del_domain_reply) \
2337 _(map_add_del_rule_reply) \
2338 _(want_interface_events_reply) \
2339 _(want_stats_reply) \
2340 _(cop_interface_enable_disable_reply) \
2341 _(cop_whitelist_enable_disable_reply) \
2342 _(sw_interface_clear_stats_reply) \
2343 _(trace_profile_add_reply) \
2344 _(trace_profile_apply_reply) \
2345 _(trace_profile_del_reply) \
2346 _(lisp_add_del_locator_set_reply) \
2347 _(lisp_add_del_locator_reply) \
2348 _(lisp_add_del_local_eid_reply) \
2349 _(lisp_gpe_add_del_fwd_entry_reply) \
2350 _(lisp_add_del_map_resolver_reply) \
2351 _(lisp_gpe_enable_disable_reply) \
2352 _(lisp_gpe_add_del_iface_reply) \
2353 _(lisp_enable_disable_reply) \
2354 _(lisp_pitr_set_locator_set_reply) \
2355 _(vxlan_gpe_add_del_tunnel_reply) \
2356 _(af_packet_create_reply) \
2357 _(af_packet_delete_reply) \
2358 _(policer_add_del_reply) \
2359 _(netmap_create_reply) \
2360 _(netmap_delete_reply)
2363 static void vl_api_##n##_t_handler \
2364 (vl_api_##n##_t * mp) \
2366 vat_main_t * vam = &vat_main; \
2367 i32 retval = ntohl(mp->retval); \
2368 if (vam->async_mode) { \
2369 vam->async_errors += (retval < 0); \
2371 vam->retval = retval; \
2372 vam->result_ready = 1; \
2375 foreach_standard_reply_retval_handler;
2379 static void vl_api_##n##_t_handler_json \
2380 (vl_api_##n##_t * mp) \
2382 vat_main_t * vam = &vat_main; \
2383 vat_json_node_t node; \
2384 vat_json_init_object(&node); \
2385 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
2386 vat_json_print(vam->ofp, &node); \
2387 vam->retval = ntohl(mp->retval); \
2388 vam->result_ready = 1; \
2390 foreach_standard_reply_retval_handler;
2394 * Table of message reply handlers, must include boilerplate handlers
2398 #define foreach_vpe_api_reply_msg \
2399 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
2400 _(SW_INTERFACE_DETAILS, sw_interface_details) \
2401 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
2402 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
2403 _(CONTROL_PING_REPLY, control_ping_reply) \
2404 _(CLI_REPLY, cli_reply) \
2405 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
2406 sw_interface_add_del_address_reply) \
2407 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
2408 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
2409 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
2410 sw_interface_set_l2_xconnect_reply) \
2411 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
2412 sw_interface_set_l2_bridge_reply) \
2413 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
2414 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
2415 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
2416 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
2417 _(L2_FLAGS_REPLY, l2_flags_reply) \
2418 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
2419 _(TAP_CONNECT_REPLY, tap_connect_reply) \
2420 _(TAP_MODIFY_REPLY, tap_modify_reply) \
2421 _(TAP_DELETE_REPLY, tap_delete_reply) \
2422 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
2423 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
2424 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
2425 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
2426 proxy_arp_intfc_enable_disable_reply) \
2427 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
2428 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
2429 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
2430 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
2431 mpls_ethernet_add_del_tunnel_reply) \
2432 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
2433 mpls_ethernet_add_del_tunnel_2_reply) \
2434 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
2435 sw_interface_set_unnumbered_reply) \
2436 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
2437 _(RESET_VRF_REPLY, reset_vrf_reply) \
2438 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
2439 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2440 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
2441 _(RESET_FIB_REPLY, reset_fib_reply) \
2442 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
2443 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
2444 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
2445 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
2446 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2447 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2448 sw_interface_ip6_enable_disable_reply) \
2449 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
2450 sw_interface_ip6_set_link_local_address_reply) \
2451 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
2452 sw_interface_ip6nd_ra_prefix_reply) \
2453 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
2454 sw_interface_ip6nd_ra_config_reply) \
2455 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
2456 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2457 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
2458 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
2459 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
2460 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
2461 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
2462 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
2463 classify_set_interface_ip_table_reply) \
2464 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
2465 classify_set_interface_l2_tables_reply) \
2466 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2467 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2468 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
2469 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
2470 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
2471 l2tpv3_interface_enable_disable_reply) \
2472 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
2473 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
2474 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
2475 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
2476 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
2477 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
2478 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2479 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2480 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2481 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
2482 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
2483 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
2484 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
2485 _(SHOW_VERSION_REPLY, show_version_reply) \
2486 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
2487 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
2488 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2489 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
2490 _(IP4_ARP_EVENT, ip4_arp_event) \
2491 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
2492 _(IP_ADDRESS_DETAILS, ip_address_details) \
2493 _(IP_DETAILS, ip_details) \
2494 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
2495 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
2496 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
2497 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
2498 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
2499 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
2500 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
2501 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
2502 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
2503 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
2504 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
2505 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
2506 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
2507 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
2508 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
2509 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
2510 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
2511 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
2512 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
2513 _(MAP_DOMAIN_DETAILS, map_domain_details) \
2514 _(MAP_RULE_DETAILS, map_rule_details) \
2515 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
2516 _(WANT_STATS_REPLY, want_stats_reply) \
2517 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
2518 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
2519 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
2520 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
2521 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
2522 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
2523 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
2524 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
2525 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
2526 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
2527 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
2528 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
2529 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
2530 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
2531 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
2532 _(LISP_PITR_SET_LOCATOR_SET_REPLY, lisp_pitr_set_locator_set_reply) \
2533 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
2534 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
2535 _(LISP_LOCAL_EID_TABLE_DETAILS, lisp_local_eid_table_details) \
2536 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
2537 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
2538 _(LISP_ENABLE_DISABLE_STATUS_DETAILS, \
2539 lisp_enable_disable_status_details) \
2540 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
2541 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
2542 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
2543 _(POLICER_DETAILS, policer_details) \
2544 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
2545 _(NETMAP_DELETE_REPLY, netmap_delete_reply)
2547 /* M: construct, but don't yet send a message */
2551 vam->result_ready = 0; \
2552 mp = vl_msg_api_alloc(sizeof(*mp)); \
2553 memset (mp, 0, sizeof (*mp)); \
2554 mp->_vl_msg_id = ntohs (VL_API_##T); \
2555 mp->client_index = vam->my_client_index; \
2560 vam->result_ready = 0; \
2561 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
2562 memset (mp, 0, sizeof (*mp)); \
2563 mp->_vl_msg_id = ntohs (VL_API_##T); \
2564 mp->client_index = vam->my_client_index; \
2568 /* S: send a message */
2569 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
2571 /* W: wait for results, with timeout */
2574 timeout = vat_time_now (vam) + 1.0; \
2576 while (vat_time_now (vam) < timeout) { \
2577 if (vam->result_ready == 1) { \
2578 return (vam->retval); \
2590 #define STR_VTR_OP_CASE(op) \
2591 case L2_VTR_ ## op: \
2594 static const char *str_vtr_op(u32 vtr_op)
2597 STR_VTR_OP_CASE(DISABLED);
2598 STR_VTR_OP_CASE(PUSH_1);
2599 STR_VTR_OP_CASE(PUSH_2);
2600 STR_VTR_OP_CASE(POP_1);
2601 STR_VTR_OP_CASE(POP_2);
2602 STR_VTR_OP_CASE(TRANSLATE_1_1);
2603 STR_VTR_OP_CASE(TRANSLATE_1_2);
2604 STR_VTR_OP_CASE(TRANSLATE_2_1);
2605 STR_VTR_OP_CASE(TRANSLATE_2_2);
2611 static int dump_sub_interface_table (vat_main_t * vam)
2613 const sw_interface_subif_t * sub = NULL;
2615 if (vam->json_output) {
2616 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2621 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
2622 "Interface", "sw_if_index",
2623 "sub id", "dot1ad", "tags", "outer id",
2624 "inner id", "exact", "default",
2625 "outer any", "inner any");
2627 vec_foreach (sub, vam->sw_if_subif_table) {
2629 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
2630 sub->interface_name,
2632 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
2633 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
2634 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
2635 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
2636 if (sub->vtr_op != L2_VTR_DISABLED) {
2638 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
2639 "tag1: %d tag2: %d ]\n",
2640 str_vtr_op(sub->vtr_op), sub->vtr_push_dot1q,
2641 sub->vtr_tag1, sub->vtr_tag2);
2648 static int name_sort_cmp (void * a1, void * a2)
2650 name_sort_t * n1 = a1;
2651 name_sort_t * n2 = a2;
2653 return strcmp ((char *)n1->name, (char *)n2->name);
2656 static int dump_interface_table (vat_main_t * vam)
2659 name_sort_t * nses = 0, * ns;
2661 if (vam->json_output) {
2662 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2666 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2668 vec_add2 (nses, ns, 1);
2669 ns->name = (u8 *)(p->key);
2670 ns->value = (u32) p->value[0];
2673 vec_sort_with_function (nses, name_sort_cmp);
2675 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
2676 vec_foreach (ns, nses) {
2677 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
2683 static int dump_ip_table (vat_main_t * vam, int is_ipv6)
2685 const ip_details_t * det = NULL;
2686 const ip_address_details_t * address = NULL;
2697 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6]) {
2699 if (!det->present) {
2707 "Address", "Prefix length");
2711 vec_foreach (address, det->addr) {
2714 is_ipv6 ? format_ip6_address : format_ip4_address,
2716 address->prefix_length);
2723 static int dump_ipv4_table (vat_main_t * vam)
2725 if (vam->json_output) {
2726 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2730 return dump_ip_table (vam, 0);
2733 static int dump_ipv6_table (vat_main_t * vam)
2735 if (vam->json_output) {
2736 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2740 return dump_ip_table (vam, 1);
2743 static char* counter_type_to_str (u8 counter_type, u8 is_combined)
2746 switch(counter_type) {
2747 case VNET_INTERFACE_COUNTER_DROP:
2749 case VNET_INTERFACE_COUNTER_PUNT:
2751 case VNET_INTERFACE_COUNTER_IP4:
2753 case VNET_INTERFACE_COUNTER_IP6:
2755 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
2757 case VNET_INTERFACE_COUNTER_RX_MISS:
2759 case VNET_INTERFACE_COUNTER_RX_ERROR:
2761 case VNET_INTERFACE_COUNTER_TX_ERROR:
2764 return "INVALID-COUNTER-TYPE";
2767 switch(counter_type) {
2768 case VNET_INTERFACE_COUNTER_RX:
2770 case VNET_INTERFACE_COUNTER_TX:
2773 return "INVALID-COUNTER-TYPE";
2778 static int dump_stats_table (vat_main_t * vam)
2780 vat_json_node_t node;
2781 vat_json_node_t *msg_array;
2782 vat_json_node_t *msg;
2783 vat_json_node_t *counter_array;
2784 vat_json_node_t *counter;
2785 interface_counter_t c;
2787 ip4_fib_counter_t *c4;
2788 ip6_fib_counter_t *c6;
2791 if (!vam->json_output) {
2792 clib_warning ("dump_stats_table supported only in JSON format");
2796 vat_json_init_object(&node);
2798 /* interface counters */
2799 msg_array = vat_json_object_add(&node, "interface_counters");
2800 vat_json_init_array(msg_array);
2801 for (i = 0; i < vec_len(vam->simple_interface_counters); i++) {
2802 msg = vat_json_array_add(msg_array);
2803 vat_json_init_object(msg);
2804 vat_json_object_add_string_copy(msg, "vnet_counter_type",
2805 (u8*)counter_type_to_str(i, 0));
2806 vat_json_object_add_int(msg, "is_combined", 0);
2807 counter_array = vat_json_object_add(msg, "data");
2808 vat_json_init_array(counter_array);
2809 for (j = 0; j < vec_len(vam->simple_interface_counters[i]); j++) {
2810 packets = vam->simple_interface_counters[i][j];
2811 vat_json_array_add_uint(counter_array, packets);
2814 for (i = 0; i < vec_len(vam->combined_interface_counters); i++) {
2815 msg = vat_json_array_add(msg_array);
2816 vat_json_init_object(msg);
2817 vat_json_object_add_string_copy(msg, "vnet_counter_type",
2818 (u8*)counter_type_to_str(i, 1));
2819 vat_json_object_add_int(msg, "is_combined", 1);
2820 counter_array = vat_json_object_add(msg, "data");
2821 vat_json_init_array(counter_array);
2822 for (j = 0; j < vec_len(vam->combined_interface_counters[i]); j++) {
2823 c = vam->combined_interface_counters[i][j];
2824 counter = vat_json_array_add(counter_array);
2825 vat_json_init_object(counter);
2826 vat_json_object_add_uint(counter, "packets", c.packets);
2827 vat_json_object_add_uint(counter, "bytes", c.bytes);
2831 /* ip4 fib counters */
2832 msg_array = vat_json_object_add(&node, "ip4_fib_counters");
2833 vat_json_init_array(msg_array);
2834 for (i = 0; i < vec_len(vam->ip4_fib_counters); i++) {
2835 msg = vat_json_array_add(msg_array);
2836 vat_json_init_object(msg);
2837 vat_json_object_add_uint(msg, "vrf_id", vam->ip4_fib_counters_vrf_id_by_index[i]);
2838 counter_array = vat_json_object_add(msg, "c");
2839 vat_json_init_array(counter_array);
2840 for (j = 0; j < vec_len(vam->ip4_fib_counters[i]); j++) {
2841 counter = vat_json_array_add(counter_array);
2842 vat_json_init_object(counter);
2843 c4 = &vam->ip4_fib_counters[i][j];
2844 vat_json_object_add_ip4(counter, "address", c4->address);
2845 vat_json_object_add_uint(counter, "address_length", c4->address_length);
2846 vat_json_object_add_uint(counter, "packets", c4->packets);
2847 vat_json_object_add_uint(counter, "bytes", c4->bytes);
2851 /* ip6 fib counters */
2852 msg_array = vat_json_object_add(&node, "ip6_fib_counters");
2853 vat_json_init_array(msg_array);
2854 for (i = 0; i < vec_len(vam->ip6_fib_counters); i++) {
2855 msg = vat_json_array_add(msg_array);
2856 vat_json_init_object(msg);
2857 vat_json_object_add_uint(msg, "vrf_id", vam->ip6_fib_counters_vrf_id_by_index[i]);
2858 counter_array = vat_json_object_add(msg, "c");
2859 vat_json_init_array(counter_array);
2860 for (j = 0; j < vec_len(vam->ip6_fib_counters[i]); j++) {
2861 counter = vat_json_array_add(counter_array);
2862 vat_json_init_object(counter);
2863 c6 = &vam->ip6_fib_counters[i][j];
2864 vat_json_object_add_ip6(counter, "address", c6->address);
2865 vat_json_object_add_uint(counter, "address_length", c6->address_length);
2866 vat_json_object_add_uint(counter, "packets", c6->packets);
2867 vat_json_object_add_uint(counter, "bytes", c6->bytes);
2871 vat_json_print(vam->ofp, &node);
2872 vat_json_free(&node);
2877 int exec (vat_main_t * vam)
2879 api_main_t * am = &api_main;
2880 vl_api_cli_request_t *mp;
2884 unformat_input_t * i = vam->input;
2886 if (vec_len(i->buffer) == 0)
2889 if (vam->exec_mode == 0 && unformat (i, "mode")) {
2893 if (vam->exec_mode == 1 &&
2894 (unformat (i, "exit") || unformat (i, "quit"))) {
2900 M(CLI_REQUEST, cli_request);
2903 * Copy cmd into shared memory.
2904 * In order for the CLI command to work, it
2905 * must be a vector ending in \n, not a C-string ending
2908 pthread_mutex_lock (&am->vlib_rp->mutex);
2909 oldheap = svm_push_data_heap (am->vlib_rp);
2911 vec_validate (cmd, vec_len(vam->input->buffer)-1);
2912 clib_memcpy (cmd, vam->input->buffer, vec_len(vam->input->buffer));
2914 svm_pop_heap (oldheap);
2915 pthread_mutex_unlock (&am->vlib_rp->mutex);
2917 mp->cmd_in_shmem = (u64) cmd;
2919 timeout = vat_time_now (vam) + 10.0;
2921 while (vat_time_now (vam) < timeout) {
2922 if (vam->result_ready == 1) {
2924 if (vam->shmem_result != NULL)
2925 fformat (vam->ofp, "%s", vam->shmem_result);
2926 pthread_mutex_lock (&am->vlib_rp->mutex);
2927 oldheap = svm_push_data_heap (am->vlib_rp);
2929 free_me = (u8 *)vam->shmem_result;
2932 svm_pop_heap (oldheap);
2933 pthread_mutex_unlock (&am->vlib_rp->mutex);
2940 static int api_create_loopback (vat_main_t * vam)
2942 unformat_input_t * i = vam->input;
2943 vl_api_create_loopback_t *mp;
2948 memset (mac_address, 0, sizeof (mac_address));
2950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2952 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
2958 /* Construct the API message */
2959 M(CREATE_LOOPBACK, create_loopback);
2961 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
2966 static int api_delete_loopback (vat_main_t * vam)
2968 unformat_input_t * i = vam->input;
2969 vl_api_delete_loopback_t *mp;
2971 u32 sw_if_index = ~0;
2973 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2975 if (unformat (i, "sw_if_index %d", &sw_if_index))
2981 if (sw_if_index == ~0)
2983 errmsg ("missing sw_if_index\n");
2987 /* Construct the API message */
2988 M(DELETE_LOOPBACK, delete_loopback);
2989 mp->sw_if_index = ntohl (sw_if_index);
2994 static int api_want_stats (vat_main_t * vam)
2996 unformat_input_t * i = vam->input;
2997 vl_api_want_stats_t * mp;
3001 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3003 if (unformat (i, "enable"))
3005 else if (unformat (i, "disable"))
3013 errmsg ("missing enable|disable\n");
3017 M(WANT_STATS, want_stats);
3018 mp->enable_disable = enable;
3023 static int api_want_interface_events (vat_main_t * vam)
3025 unformat_input_t * i = vam->input;
3026 vl_api_want_interface_events_t * mp;
3030 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3032 if (unformat (i, "enable"))
3034 else if (unformat (i, "disable"))
3042 errmsg ("missing enable|disable\n");
3046 M(WANT_INTERFACE_EVENTS, want_interface_events);
3047 mp->enable_disable = enable;
3049 vam->interface_event_display = enable;
3055 /* Note: non-static, called once to set up the initial intfc table */
3056 int api_sw_interface_dump (vat_main_t * vam)
3058 vl_api_sw_interface_dump_t *mp;
3061 name_sort_t * nses = 0, * ns;
3062 sw_interface_subif_t * sub = NULL;
3064 /* Toss the old name table */
3065 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3067 vec_add2 (nses, ns, 1);
3068 ns->name = (u8 *)(p->key);
3069 ns->value = (u32) p->value[0];
3072 hash_free (vam->sw_if_index_by_interface_name);
3074 vec_foreach (ns, nses)
3075 vec_free (ns->name);
3079 vec_foreach (sub, vam->sw_if_subif_table) {
3080 vec_free (sub->interface_name);
3082 vec_free (vam->sw_if_subif_table);
3084 /* recreate the interface name hash table */
3085 vam->sw_if_index_by_interface_name
3086 = hash_create_string (0, sizeof(uword));
3088 /* Get list of ethernets */
3089 M(SW_INTERFACE_DUMP, sw_interface_dump);
3090 mp->name_filter_valid = 1;
3091 strncpy ((char *) mp->name_filter, "Ether", sizeof(mp->name_filter)-1);
3094 /* and local / loopback interfaces */
3095 M(SW_INTERFACE_DUMP, sw_interface_dump);
3096 mp->name_filter_valid = 1;
3097 strncpy ((char *) mp->name_filter, "lo", sizeof(mp->name_filter)-1);
3100 /* and vxlan tunnel interfaces */
3101 M(SW_INTERFACE_DUMP, sw_interface_dump);
3102 mp->name_filter_valid = 1;
3103 strncpy ((char *) mp->name_filter, "vxlan", sizeof(mp->name_filter)-1);
3106 /* and host (af_packet) interfaces */
3107 M(SW_INTERFACE_DUMP, sw_interface_dump);
3108 mp->name_filter_valid = 1;
3109 strncpy ((char *) mp->name_filter, "host", sizeof(mp->name_filter)-1);
3112 /* and l2tpv3 tunnel interfaces */
3113 M(SW_INTERFACE_DUMP, sw_interface_dump);
3114 mp->name_filter_valid = 1;
3115 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel", sizeof(mp->name_filter)-1);
3118 /* and GRE tunnel interfaces */
3119 M(SW_INTERFACE_DUMP, sw_interface_dump);
3120 mp->name_filter_valid = 1;
3121 strncpy ((char *) mp->name_filter, "gre", sizeof(mp->name_filter)-1);
3124 /* Use a control ping for synchronization */
3126 vl_api_control_ping_t * mp;
3127 M(CONTROL_PING, control_ping);
3133 static int api_sw_interface_set_flags (vat_main_t * vam)
3135 unformat_input_t * i = vam->input;
3136 vl_api_sw_interface_set_flags_t *mp;
3139 u8 sw_if_index_set = 0;
3140 u8 admin_up = 0, link_up = 0;
3142 /* Parse args required to build the message */
3143 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3144 if (unformat (i, "admin-up"))
3146 else if (unformat (i, "admin-down"))
3148 else if (unformat (i, "link-up"))
3150 else if (unformat (i, "link-down"))
3152 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3153 sw_if_index_set = 1;
3154 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3155 sw_if_index_set = 1;
3160 if (sw_if_index_set == 0) {
3161 errmsg ("missing interface name or sw_if_index\n");
3165 /* Construct the API message */
3166 M(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
3167 mp->sw_if_index = ntohl (sw_if_index);
3168 mp->admin_up_down = admin_up;
3169 mp->link_up_down = link_up;
3174 /* Wait for a reply, return the good/bad news... */
3178 static int api_sw_interface_clear_stats (vat_main_t * vam)
3180 unformat_input_t * i = vam->input;
3181 vl_api_sw_interface_clear_stats_t *mp;
3184 u8 sw_if_index_set = 0;
3186 /* Parse args required to build the message */
3187 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3188 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3189 sw_if_index_set = 1;
3190 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3191 sw_if_index_set = 1;
3196 /* Construct the API message */
3197 M(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
3199 if (sw_if_index_set == 1)
3200 mp->sw_if_index = ntohl (sw_if_index);
3202 mp->sw_if_index = ~0;
3207 /* Wait for a reply, return the good/bad news... */
3211 static int api_sw_interface_add_del_address (vat_main_t * vam)
3213 unformat_input_t * i = vam->input;
3214 vl_api_sw_interface_add_del_address_t *mp;
3217 u8 sw_if_index_set = 0;
3218 u8 is_add = 1, del_all = 0;
3219 u32 address_length = 0;
3220 u8 v4_address_set = 0;
3221 u8 v6_address_set = 0;
3222 ip4_address_t v4address;
3223 ip6_address_t v6address;
3225 /* Parse args required to build the message */
3226 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3227 if (unformat (i, "del-all"))
3229 else if (unformat (i, "del"))
3231 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3232 sw_if_index_set = 1;
3233 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3234 sw_if_index_set = 1;
3235 else if (unformat (i, "%U/%d",
3236 unformat_ip4_address, &v4address,
3239 else if (unformat (i, "%U/%d",
3240 unformat_ip6_address, &v6address,
3247 if (sw_if_index_set == 0) {
3248 errmsg ("missing interface name or sw_if_index\n");
3251 if (v4_address_set && v6_address_set) {
3252 errmsg ("both v4 and v6 addresses set\n");
3255 if (!v4_address_set && !v6_address_set && !del_all) {
3256 errmsg ("no addresses set\n");
3260 /* Construct the API message */
3261 M(SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
3263 mp->sw_if_index = ntohl (sw_if_index);
3264 mp->is_add = is_add;
3265 mp->del_all = del_all;
3266 if (v6_address_set) {
3268 clib_memcpy (mp->address, &v6address, sizeof (v6address));
3270 clib_memcpy (mp->address, &v4address, sizeof (v4address));
3272 mp->address_length = address_length;
3277 /* Wait for a reply, return good/bad news */
3281 static int api_sw_interface_set_table (vat_main_t * vam)
3283 unformat_input_t * i = vam->input;
3284 vl_api_sw_interface_set_table_t *mp;
3286 u32 sw_if_index, vrf_id = 0;
3287 u8 sw_if_index_set = 0;
3290 /* Parse args required to build the message */
3291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3292 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3293 sw_if_index_set = 1;
3294 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3295 sw_if_index_set = 1;
3296 else if (unformat (i, "vrf %d", &vrf_id))
3298 else if (unformat (i, "ipv6"))
3304 if (sw_if_index_set == 0) {
3305 errmsg ("missing interface name or sw_if_index\n");
3309 /* Construct the API message */
3310 M(SW_INTERFACE_SET_TABLE, sw_interface_set_table);
3312 mp->sw_if_index = ntohl (sw_if_index);
3313 mp->is_ipv6 = is_ipv6;
3314 mp->vrf_id = ntohl (vrf_id);
3319 /* Wait for a reply... */
3323 static int api_sw_interface_set_vpath (vat_main_t * vam)
3325 unformat_input_t * i = vam->input;
3326 vl_api_sw_interface_set_vpath_t *mp;
3328 u32 sw_if_index = 0;
3329 u8 sw_if_index_set = 0;
3332 /* Parse args required to build the message */
3333 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3334 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3335 sw_if_index_set = 1;
3336 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3337 sw_if_index_set = 1;
3338 else if (unformat (i, "enable"))
3340 else if (unformat (i, "disable"))
3346 if (sw_if_index_set == 0) {
3347 errmsg ("missing interface name or sw_if_index\n");
3351 /* Construct the API message */
3352 M(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
3354 mp->sw_if_index = ntohl (sw_if_index);
3355 mp->enable = is_enable;
3360 /* Wait for a reply... */
3364 static int api_sw_interface_set_l2_xconnect (vat_main_t * vam)
3366 unformat_input_t * i = vam->input;
3367 vl_api_sw_interface_set_l2_xconnect_t *mp;
3370 u8 rx_sw_if_index_set = 0;
3372 u8 tx_sw_if_index_set = 0;
3375 /* Parse args required to build the message */
3376 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3377 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
3378 rx_sw_if_index_set = 1;
3379 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
3380 tx_sw_if_index_set = 1;
3381 else if (unformat (i, "rx")) {
3382 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3383 if (unformat (i, "%U", unformat_sw_if_index, vam,
3385 rx_sw_if_index_set = 1;
3388 } else if (unformat (i, "tx")) {
3389 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3390 if (unformat (i, "%U", unformat_sw_if_index, vam,
3392 tx_sw_if_index_set = 1;
3395 } else if (unformat (i, "enable"))
3397 else if (unformat (i, "disable"))
3403 if (rx_sw_if_index_set == 0) {
3404 errmsg ("missing rx interface name or rx_sw_if_index\n");
3408 if (enable && (tx_sw_if_index_set == 0)) {
3409 errmsg ("missing tx interface name or tx_sw_if_index\n");
3413 M(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
3415 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3416 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
3417 mp->enable = enable;
3424 static int api_sw_interface_set_l2_bridge (vat_main_t * vam)
3426 unformat_input_t * i = vam->input;
3427 vl_api_sw_interface_set_l2_bridge_t *mp;
3430 u8 rx_sw_if_index_set = 0;
3437 /* Parse args required to build the message */
3438 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3439 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
3440 rx_sw_if_index_set = 1;
3441 else if (unformat (i, "bd_id %d", &bd_id))
3443 else if (unformat (i, "%U", unformat_sw_if_index, vam,
3445 rx_sw_if_index_set = 1;
3446 else if (unformat (i, "shg %d", &shg))
3448 else if (unformat (i, "bvi"))
3450 else if (unformat (i, "enable"))
3452 else if (unformat (i, "disable"))
3458 if (rx_sw_if_index_set == 0) {
3459 errmsg ("missing rx interface name or sw_if_index\n");
3463 if (enable && (bd_id_set == 0)) {
3464 errmsg ("missing bridge domain\n");
3468 M(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
3470 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3471 mp->bd_id = ntohl(bd_id);
3474 mp->enable = enable;
3481 static int api_bridge_domain_dump (vat_main_t * vam)
3483 unformat_input_t * i = vam->input;
3484 vl_api_bridge_domain_dump_t *mp;
3488 /* Parse args required to build the message */
3489 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3490 if (unformat (i, "bd_id %d", &bd_id))
3496 M(BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
3497 mp->bd_id = ntohl(bd_id);
3500 /* Use a control ping for synchronization */
3502 vl_api_control_ping_t * mp;
3503 M(CONTROL_PING, control_ping);
3512 static int api_bridge_domain_add_del (vat_main_t * vam)
3514 unformat_input_t * i = vam->input;
3515 vl_api_bridge_domain_add_del_t *mp;
3519 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
3521 /* Parse args required to build the message */
3522 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3523 if (unformat (i, "bd_id %d", &bd_id))
3525 else if (unformat (i, "flood %d", &flood))
3527 else if (unformat (i, "uu-flood %d", &uu_flood))
3529 else if (unformat (i, "forward %d", &forward))
3531 else if (unformat (i, "learn %d", &learn))
3533 else if (unformat (i, "arp-term %d", &arp_term))
3535 else if (unformat (i, "del")) {
3537 flood = uu_flood = forward = learn = 0;
3544 errmsg ("missing bridge domain\n");
3548 M(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
3550 mp->bd_id = ntohl(bd_id);
3552 mp->uu_flood = uu_flood;
3553 mp->forward = forward;
3555 mp->arp_term = arp_term;
3556 mp->is_add = is_add;
3563 static int api_l2fib_add_del (vat_main_t * vam)
3565 unformat_input_t * i = vam->input;
3566 vl_api_l2fib_add_del_t *mp;
3573 u8 sw_if_index_set = 0;
3578 /* Parse args required to build the message */
3579 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3580 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
3582 else if (unformat (i, "bd_id %d", &bd_id))
3584 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3585 sw_if_index_set = 1;
3586 else if (unformat (i, "sw_if")) {
3587 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3588 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3589 sw_if_index_set = 1;
3592 } else if (unformat (i, "static"))
3594 else if (unformat (i, "filter")) {
3597 } else if (unformat (i, "del"))
3604 errmsg ("missing mac address\n");
3608 if (bd_id_set == 0) {
3609 errmsg ("missing bridge domain\n");
3613 if (is_add && (sw_if_index_set == 0)) {
3614 errmsg ("missing interface name or sw_if_index\n");
3618 M(L2FIB_ADD_DEL, l2fib_add_del);
3621 mp->bd_id = ntohl(bd_id);
3622 mp->is_add = is_add;
3625 mp->sw_if_index = ntohl(sw_if_index);
3626 mp->static_mac = static_mac;
3627 mp->filter_mac = filter_mac;
3635 static int api_l2_flags (vat_main_t * vam)
3637 unformat_input_t * i = vam->input;
3638 vl_api_l2_flags_t *mp;
3641 u32 feature_bitmap = 0;
3642 u8 sw_if_index_set = 0;
3644 /* Parse args required to build the message */
3645 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3646 if (unformat (i, "sw_if_index %d", &sw_if_index))
3647 sw_if_index_set = 1;
3648 else if (unformat (i, "sw_if")) {
3649 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3650 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3651 sw_if_index_set = 1;
3654 } else if (unformat (i, "learn"))
3655 feature_bitmap |= L2INPUT_FEAT_LEARN;
3656 else if (unformat (i, "forward"))
3657 feature_bitmap |= L2INPUT_FEAT_FWD;
3658 else if (unformat (i, "flood"))
3659 feature_bitmap |= L2INPUT_FEAT_FLOOD;
3660 else if (unformat (i, "uu-flood"))
3661 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
3666 if (sw_if_index_set == 0) {
3667 errmsg ("missing interface name or sw_if_index\n");
3671 M(L2_FLAGS, l2_flags);
3673 mp->sw_if_index = ntohl(sw_if_index);
3674 mp->feature_bitmap = ntohl(feature_bitmap);
3681 static int api_bridge_flags (vat_main_t * vam)
3683 unformat_input_t * i = vam->input;
3684 vl_api_bridge_flags_t *mp;
3691 /* Parse args required to build the message */
3692 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3693 if (unformat (i, "bd_id %d", &bd_id))
3695 else if (unformat (i, "learn"))
3697 else if (unformat (i, "forward"))
3699 else if (unformat (i, "flood"))
3701 else if (unformat (i, "uu-flood"))
3702 flags |= L2_UU_FLOOD;
3703 else if (unformat (i, "arp-term"))
3704 flags |= L2_ARP_TERM;
3705 else if (unformat (i, "off"))
3707 else if (unformat (i, "disable"))
3713 if (bd_id_set == 0) {
3714 errmsg ("missing bridge domain\n");
3718 M(BRIDGE_FLAGS, bridge_flags);
3720 mp->bd_id = ntohl(bd_id);
3721 mp->feature_bitmap = ntohl(flags);
3722 mp->is_set = is_set;
3729 static int api_bd_ip_mac_add_del (vat_main_t * vam)
3731 unformat_input_t * i = vam->input;
3732 vl_api_bd_ip_mac_add_del_t *mp;
3740 ip4_address_t v4addr;
3741 ip6_address_t v6addr;
3745 /* Parse args required to build the message */
3746 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3747 if (unformat (i, "bd_id %d", &bd_id)) {
3749 } else if (unformat (i, "%U", unformat_ip4_address, &v4addr)) {
3751 } else if (unformat (i, "%U", unformat_ip6_address, &v6addr)) {
3754 } else if (unformat (i, "%U", unformat_ethernet_address, macaddr)) {
3756 } else if (unformat (i, "del"))
3762 if (bd_id_set == 0) {
3763 errmsg ("missing bridge domain\n");
3765 } else if (ip_set == 0) {
3766 errmsg ("missing IP address\n");
3768 } else if (mac_set == 0) {
3769 errmsg ("missing MAC address\n");
3773 M(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
3775 mp->bd_id = ntohl(bd_id);
3776 mp->is_ipv6 = is_ipv6;
3777 mp->is_add = is_add;
3779 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
3780 else clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
3781 clib_memcpy (mp->mac_address, macaddr, 6);
3787 static int api_tap_connect (vat_main_t * vam)
3789 unformat_input_t * i = vam->input;
3790 vl_api_tap_connect_t *mp;
3797 memset (mac_address, 0, sizeof (mac_address));
3799 /* Parse args required to build the message */
3800 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3801 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
3804 else if (unformat (i, "random-mac"))
3806 else if (unformat (i, "tapname %s", &tap_name))
3812 if (name_set == 0) {
3813 errmsg ("missing tap name\n");
3816 if (vec_len (tap_name) > 63) {
3817 errmsg ("tap name too long\n");
3819 vec_add1 (tap_name, 0);
3821 /* Construct the API message */
3822 M(TAP_CONNECT, tap_connect);
3824 mp->use_random_mac = random_mac;
3825 clib_memcpy (mp->mac_address, mac_address, 6);
3826 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
3827 vec_free (tap_name);
3832 /* Wait for a reply... */
3836 static int api_tap_modify (vat_main_t * vam)
3838 unformat_input_t * i = vam->input;
3839 vl_api_tap_modify_t *mp;
3845 u32 sw_if_index = ~0;
3846 u8 sw_if_index_set = 0;
3848 memset (mac_address, 0, sizeof (mac_address));
3850 /* Parse args required to build the message */
3851 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3852 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3853 sw_if_index_set = 1;
3854 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3855 sw_if_index_set = 1;
3856 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
3859 else if (unformat (i, "random-mac"))
3861 else if (unformat (i, "tapname %s", &tap_name))
3867 if (sw_if_index_set == 0) {
3868 errmsg ("missing vpp interface name");
3871 if (name_set == 0) {
3872 errmsg ("missing tap name\n");
3875 if (vec_len (tap_name) > 63) {
3876 errmsg ("tap name too long\n");
3878 vec_add1 (tap_name, 0);
3880 /* Construct the API message */
3881 M(TAP_MODIFY, tap_modify);
3883 mp->use_random_mac = random_mac;
3884 mp->sw_if_index = ntohl(sw_if_index);
3885 clib_memcpy (mp->mac_address, mac_address, 6);
3886 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
3887 vec_free (tap_name);
3892 /* Wait for a reply... */
3896 static int api_tap_delete (vat_main_t * vam)
3898 unformat_input_t * i = vam->input;
3899 vl_api_tap_delete_t *mp;
3901 u32 sw_if_index = ~0;
3902 u8 sw_if_index_set = 0;
3904 /* Parse args required to build the message */
3905 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3906 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3907 sw_if_index_set = 1;
3908 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3909 sw_if_index_set = 1;
3914 if (sw_if_index_set == 0) {
3915 errmsg ("missing vpp interface name");
3919 /* Construct the API message */
3920 M(TAP_DELETE, tap_delete);
3922 mp->sw_if_index = ntohl(sw_if_index);
3927 /* Wait for a reply... */
3931 static int api_ip_add_del_route (vat_main_t * vam)
3933 unformat_input_t * i = vam->input;
3934 vl_api_ip_add_del_route_t *mp;
3936 u32 sw_if_index = 0, vrf_id = 0;
3937 u8 sw_if_index_set = 0;
3939 u8 is_local = 0, is_drop = 0;
3940 u8 create_vrf_if_needed = 0;
3942 u8 next_hop_weight = 1;
3944 u8 is_multipath = 0;
3946 u8 address_length_set = 0;
3947 u32 lookup_in_vrf = 0;
3948 u32 resolve_attempts = 0;
3949 u32 dst_address_length = 0;
3950 u8 next_hop_set = 0;
3951 ip4_address_t v4_dst_address, v4_next_hop_address;
3952 ip6_address_t v6_dst_address, v6_next_hop_address;
3956 u32 random_add_del = 0;
3957 u32 * random_vector = 0;
3958 uword * random_hash;
3959 u32 random_seed = 0xdeaddabe;
3960 u32 classify_table_index = ~0;
3963 /* Parse args required to build the message */
3964 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3965 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3966 sw_if_index_set = 1;
3967 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3968 sw_if_index_set = 1;
3969 else if (unformat (i, "%U", unformat_ip4_address,
3974 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address)) {
3978 else if (unformat (i, "/%d", &dst_address_length)) {
3979 address_length_set = 1;
3982 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
3983 &v4_next_hop_address)) {
3986 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
3987 &v6_next_hop_address)) {
3990 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
3992 else if (unformat (i, "weight %d", &next_hop_weight))
3994 else if (unformat (i, "drop")) {
3996 } else if (unformat (i, "local")) {
3998 } else if (unformat (i, "classify %d", &classify_table_index)) {
4000 } else if (unformat (i, "del"))
4002 else if (unformat (i, "add"))
4004 else if (unformat (i, "not-last"))
4006 else if (unformat (i, "multipath"))
4008 else if (unformat (i, "vrf %d", &vrf_id))
4010 else if (unformat (i, "create-vrf"))
4011 create_vrf_if_needed = 1;
4012 else if (unformat (i, "count %d", &count))
4014 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
4016 else if (unformat (i, "random"))
4018 else if (unformat (i, "seed %d", &random_seed))
4021 clib_warning ("parse error '%U'", format_unformat_error, i);
4026 if (resolve_attempts > 0 && sw_if_index_set == 0) {
4027 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
4031 if (!next_hop_set && !is_drop && !is_local && !is_classify) {
4032 errmsg ("next hop / local / drop / classify not set\n");
4036 if (address_set == 0) {
4037 errmsg ("missing addresses\n");
4041 if (address_length_set == 0) {
4042 errmsg ("missing address length\n");
4046 /* Generate a pile of unique, random routes */
4047 if (random_add_del) {
4048 u32 this_random_address;
4049 random_hash = hash_create (count, sizeof(uword));
4051 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
4052 for (j = 0; j <= count; j++) {
4054 this_random_address = random_u32 (&random_seed);
4055 this_random_address =
4056 clib_host_to_net_u32 (this_random_address);
4057 } while (hash_get (random_hash, this_random_address));
4058 vec_add1 (random_vector, this_random_address);
4059 hash_set (random_hash, this_random_address, 1);
4061 hash_free (random_hash);
4062 v4_dst_address.as_u32 = random_vector[0];
4066 /* Turn on async mode */
4067 vam->async_mode = 1;
4068 vam->async_errors = 0;
4069 before = vat_time_now(vam);
4072 for (j = 0; j < count; j++) {
4073 /* Construct the API message */
4074 M(IP_ADD_DEL_ROUTE, ip_add_del_route);
4076 mp->next_hop_sw_if_index = ntohl (sw_if_index);
4077 mp->vrf_id = ntohl (vrf_id);
4078 if (resolve_attempts > 0) {
4079 mp->resolve_attempts = ntohl (resolve_attempts);
4080 mp->resolve_if_needed = 1;
4082 mp->create_vrf_if_needed = create_vrf_if_needed;
4084 mp->is_add = is_add;
4085 mp->is_drop = is_drop;
4086 mp->is_ipv6 = is_ipv6;
4087 mp->is_local = is_local;
4088 mp->is_classify = is_classify;
4089 mp->is_multipath = is_multipath;
4090 mp->not_last = not_last;
4091 mp->next_hop_weight = next_hop_weight;
4092 mp->dst_address_length = dst_address_length;
4093 mp->lookup_in_vrf = ntohl(lookup_in_vrf);
4094 mp->classify_table_index = ntohl(classify_table_index);
4097 clib_memcpy (mp->dst_address, &v6_dst_address, sizeof (v6_dst_address));
4099 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
4100 sizeof (v6_next_hop_address));
4101 increment_v6_address (&v6_dst_address);
4103 clib_memcpy (mp->dst_address, &v4_dst_address, sizeof (v4_dst_address));
4105 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
4106 sizeof (v4_next_hop_address));
4108 v4_dst_address.as_u32 = random_vector[j+1];
4110 increment_v4_address (&v4_dst_address);
4116 /* When testing multiple add/del ops, use a control-ping to sync */
4118 vl_api_control_ping_t * mp;
4121 /* Shut off async mode */
4122 vam->async_mode = 0;
4124 M(CONTROL_PING, control_ping);
4127 timeout = vat_time_now(vam) + 1.0;
4128 while (vat_time_now (vam) < timeout)
4129 if (vam->result_ready == 1)
4134 if (vam->retval == -99)
4135 errmsg ("timeout\n");
4137 if (vam->async_errors > 0) {
4138 errmsg ("%d asynchronous errors\n", vam->async_errors);
4141 vam->async_errors = 0;
4142 after = vat_time_now(vam);
4144 fformat(vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4145 count, after - before, count / (after - before));
4147 /* Wait for a reply... */
4151 /* Return the good/bad news */
4152 return (vam->retval);
4155 static int api_proxy_arp_add_del (vat_main_t * vam)
4157 unformat_input_t * i = vam->input;
4158 vl_api_proxy_arp_add_del_t *mp;
4162 ip4_address_t lo, hi;
4165 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4166 if (unformat (i, "vrf %d", &vrf_id))
4168 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
4169 unformat_ip4_address, &hi))
4171 else if (unformat (i, "del"))
4174 clib_warning ("parse error '%U'", format_unformat_error, i);
4179 if (range_set == 0) {
4180 errmsg ("address range not set\n");
4184 M(PROXY_ARP_ADD_DEL, proxy_arp_add_del);
4186 mp->vrf_id = ntohl(vrf_id);
4187 mp->is_add = is_add;
4188 clib_memcpy(mp->low_address, &lo, sizeof (mp->low_address));
4189 clib_memcpy(mp->hi_address, &hi, sizeof (mp->hi_address));
4196 static int api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
4198 unformat_input_t * i = vam->input;
4199 vl_api_proxy_arp_intfc_enable_disable_t *mp;
4203 u8 sw_if_index_set = 0;
4205 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4206 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4207 sw_if_index_set = 1;
4208 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4209 sw_if_index_set = 1;
4210 else if (unformat (i, "enable"))
4212 else if (unformat (i, "disable"))
4215 clib_warning ("parse error '%U'", format_unformat_error, i);
4220 if (sw_if_index_set == 0) {
4221 errmsg ("missing interface name or sw_if_index\n");
4225 M(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
4227 mp->sw_if_index = ntohl(sw_if_index);
4228 mp->enable_disable = enable;
4235 static int api_mpls_add_del_decap (vat_main_t * vam)
4237 unformat_input_t * i = vam->input;
4238 vl_api_mpls_add_del_decap_t *mp;
4247 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4248 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4250 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
4252 else if (unformat (i, "label %d", &label))
4254 else if (unformat (i, "next-index %d", &next_index))
4256 else if (unformat (i, "del"))
4258 else if (unformat (i, "s-bit-clear"))
4261 clib_warning ("parse error '%U'", format_unformat_error, i);
4266 M(MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
4268 mp->rx_vrf_id = ntohl(rx_vrf_id);
4269 mp->tx_vrf_id = ntohl(tx_vrf_id);
4270 mp->label = ntohl(label);
4271 mp->next_index = ntohl(next_index);
4273 mp->is_add = is_add;
4280 static int api_mpls_add_del_encap (vat_main_t * vam)
4282 unformat_input_t * i = vam->input;
4283 vl_api_mpls_add_del_encap_t *mp;
4288 ip4_address_t dst_address;
4291 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4292 if (unformat (i, "vrf %d", &vrf_id))
4294 else if (unformat (i, "label %d", &label))
4295 vec_add1 (labels, ntohl(label));
4296 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4298 else if (unformat (i, "del"))
4301 clib_warning ("parse error '%U'", format_unformat_error, i);
4306 if (vec_len (labels) == 0) {
4307 errmsg ("missing encap label stack\n");
4311 M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
4312 sizeof (u32) * vec_len (labels));
4314 mp->vrf_id = ntohl(vrf_id);
4315 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4316 mp->is_add = is_add;
4317 mp->nlabels = vec_len (labels);
4318 clib_memcpy(mp->labels, labels, sizeof(u32)*mp->nlabels);
4327 static int api_mpls_gre_add_del_tunnel (vat_main_t * vam)
4329 unformat_input_t * i = vam->input;
4330 vl_api_mpls_gre_add_del_tunnel_t *mp;
4332 u32 inner_vrf_id = 0;
4333 u32 outer_vrf_id = 0;
4334 ip4_address_t src_address;
4335 ip4_address_t dst_address;
4336 ip4_address_t intfc_address;
4338 u8 intfc_address_length = 0;
4342 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4343 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4345 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4347 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
4349 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4351 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4352 &intfc_address, &tmp))
4353 intfc_address_length = tmp;
4354 else if (unformat (i, "l2-only"))
4356 else if (unformat (i, "del"))
4359 clib_warning ("parse error '%U'", format_unformat_error, i);
4364 M(MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
4366 mp->inner_vrf_id = ntohl(inner_vrf_id);
4367 mp->outer_vrf_id = ntohl(outer_vrf_id);
4368 clib_memcpy(mp->src_address, &src_address, sizeof (src_address));
4369 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4370 clib_memcpy(mp->intfc_address, &intfc_address, sizeof (intfc_address));
4371 mp->intfc_address_length = intfc_address_length;
4372 mp->l2_only = l2_only;
4373 mp->is_add = is_add;
4380 static int api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
4382 unformat_input_t * i = vam->input;
4383 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
4385 u32 inner_vrf_id = 0;
4386 ip4_address_t intfc_address;
4387 u8 dst_mac_address[6];
4390 u8 intfc_address_length = 0;
4394 int tx_sw_if_index_set = 0;
4396 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4397 if (unformat (i, "vrf %d", &inner_vrf_id))
4399 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4400 &intfc_address, &tmp))
4401 intfc_address_length = tmp;
4402 else if (unformat (i, "%U",
4403 unformat_sw_if_index, vam, &tx_sw_if_index))
4404 tx_sw_if_index_set = 1;
4405 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4406 tx_sw_if_index_set = 1;
4407 else if (unformat (i, "dst %U", unformat_ethernet_address,
4410 else if (unformat (i, "l2-only"))
4412 else if (unformat (i, "del"))
4415 clib_warning ("parse error '%U'", format_unformat_error, i);
4421 errmsg ("dst (mac address) not set\n");
4424 if (!tx_sw_if_index_set) {
4425 errmsg ("tx-intfc not set\n");
4429 M(MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
4431 mp->vrf_id = ntohl(inner_vrf_id);
4432 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
4433 mp->adj_address_length = intfc_address_length;
4434 clib_memcpy (mp->dst_mac_address, dst_mac_address, sizeof (dst_mac_address));
4435 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
4436 mp->l2_only = l2_only;
4437 mp->is_add = is_add;
4444 static int api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
4446 unformat_input_t * i = vam->input;
4447 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
4449 u32 inner_vrf_id = 0;
4450 u32 outer_vrf_id = 0;
4451 ip4_address_t adj_address;
4452 int adj_address_set = 0;
4453 ip4_address_t next_hop_address;
4454 int next_hop_address_set = 0;
4456 u8 adj_address_length = 0;
4459 u32 resolve_attempts = 5;
4460 u8 resolve_if_needed = 1;
4462 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4463 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4465 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4467 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4468 &adj_address, &tmp)) {
4469 adj_address_length = tmp;
4470 adj_address_set = 1;
4472 else if (unformat (i, "next-hop %U", unformat_ip4_address,
4474 next_hop_address_set = 1;
4475 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4477 else if (unformat (i, "resolve-if-needed %d", &tmp))
4478 resolve_if_needed = tmp;
4479 else if (unformat (i, "l2-only"))
4481 else if (unformat (i, "del"))
4484 clib_warning ("parse error '%U'", format_unformat_error, i);
4489 if (!adj_address_set) {
4490 errmsg ("adjacency address/mask not set\n");
4493 if (!next_hop_address_set) {
4494 errmsg ("ip4 next hop address (in outer fib) not set\n");
4498 M(MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
4500 mp->inner_vrf_id = ntohl(inner_vrf_id);
4501 mp->outer_vrf_id = ntohl(outer_vrf_id);
4502 mp->resolve_attempts = ntohl(resolve_attempts);
4503 mp->resolve_if_needed = resolve_if_needed;
4504 mp->is_add = is_add;
4505 mp->l2_only = l2_only;
4506 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
4507 mp->adj_address_length = adj_address_length;
4508 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
4509 sizeof (next_hop_address));
4516 static int api_sw_interface_set_unnumbered (vat_main_t * vam)
4518 unformat_input_t * i = vam->input;
4519 vl_api_sw_interface_set_unnumbered_t *mp;
4524 u8 sw_if_index_set = 0;
4526 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4527 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4528 sw_if_index_set = 1;
4529 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4530 sw_if_index_set = 1;
4531 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4533 else if (unformat (i, "del"))
4536 clib_warning ("parse error '%U'", format_unformat_error, i);
4541 if (sw_if_index_set == 0) {
4542 errmsg ("missing interface name or sw_if_index\n");
4546 M(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
4548 mp->sw_if_index = ntohl(sw_if_index);
4549 mp->unnumbered_sw_if_index = ntohl(unnum_sw_index);
4550 mp->is_add = is_add;
4557 static int api_ip_neighbor_add_del (vat_main_t * vam)
4559 unformat_input_t * i = vam->input;
4560 vl_api_ip_neighbor_add_del_t *mp;
4563 u8 sw_if_index_set = 0;
4569 u8 v4_address_set = 0;
4570 u8 v6_address_set = 0;
4571 ip4_address_t v4address;
4572 ip6_address_t v6address;
4574 memset (mac_address, 0, sizeof (mac_address));
4576 /* Parse args required to build the message */
4577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4578 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4581 else if (unformat (i, "del"))
4583 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4584 sw_if_index_set = 1;
4585 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4586 sw_if_index_set = 1;
4587 else if (unformat (i, "is_static"))
4589 else if (unformat (i, "vrf %d", &vrf_id))
4591 else if (unformat (i, "dst %U",
4592 unformat_ip4_address, &v4address))
4594 else if (unformat (i, "dst %U",
4595 unformat_ip6_address, &v6address))
4598 clib_warning ("parse error '%U'", format_unformat_error, i);
4603 if (sw_if_index_set == 0) {
4604 errmsg ("missing interface name or sw_if_index\n");
4607 if (v4_address_set && v6_address_set) {
4608 errmsg ("both v4 and v6 addresses set\n");
4611 if (!v4_address_set && !v6_address_set) {
4612 errmsg ("no addresses set\n");
4616 /* Construct the API message */
4617 M(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
4619 mp->sw_if_index = ntohl (sw_if_index);
4620 mp->is_add = is_add;
4621 mp->vrf_id = ntohl (vrf_id);
4622 mp->is_static = is_static;
4624 clib_memcpy (mp->mac_address, mac_address, 6);
4625 if (v6_address_set) {
4627 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
4629 /* mp->is_ipv6 = 0; via memset in M macro above */
4630 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
4636 /* Wait for a reply, return good/bad news */
4643 static int api_reset_vrf (vat_main_t * vam)
4645 unformat_input_t * i = vam->input;
4646 vl_api_reset_vrf_t *mp;
4652 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4653 if (unformat (i, "vrf %d", &vrf_id))
4655 else if (unformat (i, "ipv6"))
4658 clib_warning ("parse error '%U'", format_unformat_error, i);
4663 if (vrf_id_set == 0) {
4664 errmsg ("missing vrf id\n");
4668 M(RESET_VRF, reset_vrf);
4670 mp->vrf_id = ntohl(vrf_id);
4671 mp->is_ipv6 = is_ipv6;
4678 static int api_create_vlan_subif (vat_main_t * vam)
4680 unformat_input_t * i = vam->input;
4681 vl_api_create_vlan_subif_t *mp;
4684 u8 sw_if_index_set = 0;
4688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4689 if (unformat (i, "sw_if_index %d", &sw_if_index))
4690 sw_if_index_set = 1;
4691 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4692 sw_if_index_set = 1;
4693 else if (unformat (i, "vlan %d", &vlan_id))
4696 clib_warning ("parse error '%U'", format_unformat_error, i);
4701 if (sw_if_index_set == 0) {
4702 errmsg ("missing interface name or sw_if_index\n");
4706 if (vlan_id_set == 0) {
4707 errmsg ("missing vlan_id\n");
4710 M(CREATE_VLAN_SUBIF, create_vlan_subif);
4712 mp->sw_if_index = ntohl(sw_if_index);
4713 mp->vlan_id = ntohl(vlan_id);
4720 #define foreach_create_subif_bit \
4727 _(outer_vlan_id_any) \
4728 _(inner_vlan_id_any)
4730 static int api_create_subif (vat_main_t * vam)
4732 unformat_input_t * i = vam->input;
4733 vl_api_create_subif_t *mp;
4736 u8 sw_if_index_set = 0;
4743 u32 exact_match = 0;
4744 u32 default_sub = 0;
4745 u32 outer_vlan_id_any = 0;
4746 u32 inner_vlan_id_any = 0;
4748 u16 outer_vlan_id = 0;
4749 u16 inner_vlan_id = 0;
4751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4752 if (unformat (i, "sw_if_index %d", &sw_if_index))
4753 sw_if_index_set = 1;
4754 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4755 sw_if_index_set = 1;
4756 else if (unformat (i, "sub_id %d", &sub_id))
4758 else if (unformat (i, "outer_vlan_id %d", &tmp))
4759 outer_vlan_id = tmp;
4760 else if (unformat (i, "inner_vlan_id %d", &tmp))
4761 inner_vlan_id = tmp;
4763 #define _(a) else if (unformat (i, #a)) a = 1 ;
4764 foreach_create_subif_bit
4768 clib_warning ("parse error '%U'", format_unformat_error, i);
4773 if (sw_if_index_set == 0) {
4774 errmsg ("missing interface name or sw_if_index\n");
4778 if (sub_id_set == 0) {
4779 errmsg ("missing sub_id\n");
4782 M(CREATE_SUBIF, create_subif);
4784 mp->sw_if_index = ntohl(sw_if_index);
4785 mp->sub_id = ntohl(sub_id);
4787 #define _(a) mp->a = a;
4788 foreach_create_subif_bit;
4791 mp->outer_vlan_id = ntohs (outer_vlan_id);
4792 mp->inner_vlan_id = ntohs (inner_vlan_id);
4799 static int api_oam_add_del (vat_main_t * vam)
4801 unformat_input_t * i = vam->input;
4802 vl_api_oam_add_del_t *mp;
4806 ip4_address_t src, dst;
4810 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4811 if (unformat (i, "vrf %d", &vrf_id))
4813 else if (unformat (i, "src %U", unformat_ip4_address, &src))
4815 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
4817 else if (unformat (i, "del"))
4820 clib_warning ("parse error '%U'", format_unformat_error, i);
4826 errmsg ("missing src addr\n");
4831 errmsg ("missing dst addr\n");
4835 M(OAM_ADD_DEL, oam_add_del);
4837 mp->vrf_id = ntohl(vrf_id);
4838 mp->is_add = is_add;
4839 clib_memcpy(mp->src_address, &src, sizeof (mp->src_address));
4840 clib_memcpy(mp->dst_address, &dst, sizeof (mp->dst_address));
4847 static int api_reset_fib (vat_main_t * vam)
4849 unformat_input_t * i = vam->input;
4850 vl_api_reset_fib_t *mp;
4856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4857 if (unformat (i, "vrf %d", &vrf_id))
4859 else if (unformat (i, "ipv6"))
4862 clib_warning ("parse error '%U'", format_unformat_error, i);
4867 if (vrf_id_set == 0) {
4868 errmsg ("missing vrf id\n");
4872 M(RESET_FIB, reset_fib);
4874 mp->vrf_id = ntohl(vrf_id);
4875 mp->is_ipv6 = is_ipv6;
4882 static int api_dhcp_proxy_config (vat_main_t * vam)
4884 unformat_input_t * i = vam->input;
4885 vl_api_dhcp_proxy_config_t *mp;
4890 u8 v4_address_set = 0;
4891 u8 v6_address_set = 0;
4892 ip4_address_t v4address;
4893 ip6_address_t v6address;
4894 u8 v4_src_address_set = 0;
4895 u8 v6_src_address_set = 0;
4896 ip4_address_t v4srcaddress;
4897 ip6_address_t v6srcaddress;
4899 /* Parse args required to build the message */
4900 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4901 if (unformat (i, "del"))
4903 else if (unformat (i, "vrf %d", &vrf_id))
4905 else if (unformat (i, "insert-cid %d", &insert_cid))
4907 else if (unformat (i, "svr %U",
4908 unformat_ip4_address, &v4address))
4910 else if (unformat (i, "svr %U",
4911 unformat_ip6_address, &v6address))
4913 else if (unformat (i, "src %U",
4914 unformat_ip4_address, &v4srcaddress))
4915 v4_src_address_set = 1;
4916 else if (unformat (i, "src %U",
4917 unformat_ip6_address, &v6srcaddress))
4918 v6_src_address_set = 1;
4923 if (v4_address_set && v6_address_set) {
4924 errmsg ("both v4 and v6 server addresses set\n");
4927 if (!v4_address_set && !v6_address_set) {
4928 errmsg ("no server addresses set\n");
4932 if (v4_src_address_set && v6_src_address_set) {
4933 errmsg ("both v4 and v6 src addresses set\n");
4936 if (!v4_src_address_set && !v6_src_address_set) {
4937 errmsg ("no src addresses set\n");
4941 if (!(v4_src_address_set && v4_address_set) &&
4942 !(v6_src_address_set && v6_address_set)) {
4943 errmsg ("no matching server and src addresses set\n");
4947 /* Construct the API message */
4948 M(DHCP_PROXY_CONFIG, dhcp_proxy_config);
4950 mp->insert_circuit_id = insert_cid;
4951 mp->is_add = is_add;
4952 mp->vrf_id = ntohl (vrf_id);
4953 if (v6_address_set) {
4955 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
4956 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
4958 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
4959 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
4965 /* Wait for a reply, return good/bad news */
4971 static int api_dhcp_proxy_config_2 (vat_main_t * vam)
4973 unformat_input_t * i = vam->input;
4974 vl_api_dhcp_proxy_config_2_t *mp;
4977 u32 server_vrf_id = 0;
4980 u8 v4_address_set = 0;
4981 u8 v6_address_set = 0;
4982 ip4_address_t v4address;
4983 ip6_address_t v6address;
4984 u8 v4_src_address_set = 0;
4985 u8 v6_src_address_set = 0;
4986 ip4_address_t v4srcaddress;
4987 ip6_address_t v6srcaddress;
4989 /* Parse args required to build the message */
4990 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4991 if (unformat (i, "del"))
4993 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4995 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
4997 else if (unformat (i, "insert-cid %d", &insert_cid))
4999 else if (unformat (i, "svr %U",
5000 unformat_ip4_address, &v4address))
5002 else if (unformat (i, "svr %U",
5003 unformat_ip6_address, &v6address))
5005 else if (unformat (i, "src %U",
5006 unformat_ip4_address, &v4srcaddress))
5007 v4_src_address_set = 1;
5008 else if (unformat (i, "src %U",
5009 unformat_ip6_address, &v6srcaddress))
5010 v6_src_address_set = 1;
5015 if (v4_address_set && v6_address_set) {
5016 errmsg ("both v4 and v6 server addresses set\n");
5019 if (!v4_address_set && !v6_address_set) {
5020 errmsg ("no server addresses set\n");
5024 if (v4_src_address_set && v6_src_address_set) {
5025 errmsg ("both v4 and v6 src addresses set\n");
5028 if (!v4_src_address_set && !v6_src_address_set) {
5029 errmsg ("no src addresses set\n");
5033 if (!(v4_src_address_set && v4_address_set) &&
5034 !(v6_src_address_set && v6_address_set)) {
5035 errmsg ("no matching server and src addresses set\n");
5039 /* Construct the API message */
5040 M(DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
5042 mp->insert_circuit_id = insert_cid;
5043 mp->is_add = is_add;
5044 mp->rx_vrf_id = ntohl (rx_vrf_id);
5045 mp->server_vrf_id = ntohl (server_vrf_id);
5046 if (v6_address_set) {
5048 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5049 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5051 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5052 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5058 /* Wait for a reply, return good/bad news */
5064 static int api_dhcp_proxy_set_vss (vat_main_t * vam)
5066 unformat_input_t * i = vam->input;
5067 vl_api_dhcp_proxy_set_vss_t *mp;
5078 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5079 if (unformat (i, "tbl_id %d", &tbl_id))
5081 if (unformat (i, "fib_id %d", &fib_id))
5083 if (unformat (i, "oui %d", &oui))
5085 else if (unformat (i, "ipv6"))
5087 else if (unformat (i, "del"))
5090 clib_warning ("parse error '%U'", format_unformat_error, i);
5095 if (tbl_id_set == 0) {
5096 errmsg ("missing tbl id\n");
5100 if (fib_id_set == 0) {
5101 errmsg ("missing fib id\n");
5105 errmsg ("missing oui\n");
5109 M(DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
5110 mp->tbl_id = ntohl(tbl_id);
5111 mp->fib_id = ntohl(fib_id);
5112 mp->oui = ntohl(oui);
5113 mp->is_ipv6 = is_ipv6;
5114 mp->is_add = is_add;
5121 static int api_dhcp_client_config (vat_main_t * vam)
5123 unformat_input_t * i = vam->input;
5124 vl_api_dhcp_client_config_t *mp;
5127 u8 sw_if_index_set = 0;
5130 u8 disable_event = 0;
5132 /* Parse args required to build the message */
5133 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5134 if (unformat (i, "del"))
5136 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5137 sw_if_index_set = 1;
5138 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5139 sw_if_index_set = 1;
5140 else if (unformat (i, "hostname %s", &hostname))
5142 else if (unformat (i, "disable_event"))
5148 if (sw_if_index_set == 0) {
5149 errmsg ("missing interface name or sw_if_index\n");
5153 if (vec_len (hostname) > 63) {
5154 errmsg ("hostname too long\n");
5156 vec_add1 (hostname, 0);
5158 /* Construct the API message */
5159 M(DHCP_CLIENT_CONFIG, dhcp_client_config);
5161 mp->sw_if_index = ntohl (sw_if_index);
5162 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
5163 vec_free (hostname);
5164 mp->is_add = is_add;
5165 mp->want_dhcp_event = disable_event ? 0 : 1;
5171 /* Wait for a reply, return good/bad news */
5177 static int api_set_ip_flow_hash (vat_main_t * vam)
5179 unformat_input_t * i = vam->input;
5180 vl_api_set_ip_flow_hash_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"))
5197 else if (unformat (i, "src"))
5199 else if (unformat (i, "dst"))
5201 else if (unformat (i, "sport"))
5203 else if (unformat (i, "dport"))
5205 else if (unformat (i, "proto"))
5207 else if (unformat (i, "reverse"))
5211 clib_warning ("parse error '%U'", format_unformat_error, i);
5216 if (vrf_id_set == 0) {
5217 errmsg ("missing vrf id\n");
5221 M(SET_IP_FLOW_HASH, set_ip_flow_hash);
5227 mp->reverse = reverse;
5228 mp->vrf_id = ntohl(vrf_id);
5229 mp->is_ipv6 = is_ipv6;
5236 static int api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5238 unformat_input_t * i = vam->input;
5239 vl_api_sw_interface_ip6_enable_disable_t *mp;
5242 u8 sw_if_index_set = 0;
5245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5246 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5247 sw_if_index_set = 1;
5248 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5249 sw_if_index_set = 1;
5250 else if (unformat (i, "enable"))
5252 else if (unformat (i, "disable"))
5255 clib_warning ("parse error '%U'", format_unformat_error, i);
5260 if (sw_if_index_set == 0) {
5261 errmsg ("missing interface name or sw_if_index\n");
5265 M(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
5267 mp->sw_if_index = ntohl(sw_if_index);
5268 mp->enable = enable;
5275 static int api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
5277 unformat_input_t * i = vam->input;
5278 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
5281 u8 sw_if_index_set = 0;
5282 u32 address_length = 0;
5283 u8 v6_address_set = 0;
5284 ip6_address_t v6address;
5286 /* Parse args required to build the message */
5287 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5288 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5289 sw_if_index_set = 1;
5290 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5291 sw_if_index_set = 1;
5292 else if (unformat (i, "%U/%d",
5293 unformat_ip6_address, &v6address,
5300 if (sw_if_index_set == 0) {
5301 errmsg ("missing interface name or sw_if_index\n");
5304 if (!v6_address_set) {
5305 errmsg ("no address set\n");
5309 /* Construct the API message */
5310 M(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \
5311 sw_interface_ip6_set_link_local_address);
5313 mp->sw_if_index = ntohl (sw_if_index);
5314 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5315 mp->address_length = address_length;
5320 /* Wait for a reply, return good/bad news */
5328 static int api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
5330 unformat_input_t * i = vam->input;
5331 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
5334 u8 sw_if_index_set = 0;
5335 u32 address_length = 0;
5336 u8 v6_address_set = 0;
5337 ip6_address_t v6address;
5339 u8 no_advertise = 0;
5341 u8 no_autoconfig = 0;
5344 u32 val_lifetime = 0;
5345 u32 pref_lifetime = 0;
5347 /* Parse args required to build the message */
5348 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5349 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5350 sw_if_index_set = 1;
5351 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5352 sw_if_index_set = 1;
5353 else if (unformat (i, "%U/%d",
5354 unformat_ip6_address, &v6address,
5357 else if (unformat (i, "val_life %d", &val_lifetime))
5359 else if (unformat (i, "pref_life %d", &pref_lifetime))
5361 else if (unformat (i, "def"))
5363 else if (unformat (i, "noadv"))
5365 else if (unformat (i, "offl"))
5367 else if (unformat (i, "noauto"))
5369 else if (unformat (i, "nolink"))
5371 else if (unformat (i, "isno"))
5374 clib_warning ("parse error '%U'", format_unformat_error, i);
5379 if (sw_if_index_set == 0) {
5380 errmsg ("missing interface name or sw_if_index\n");
5383 if (!v6_address_set) {
5384 errmsg ("no address set\n");
5388 /* Construct the API message */
5389 M(SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
5391 mp->sw_if_index = ntohl (sw_if_index);
5392 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5393 mp->address_length = address_length;
5394 mp->use_default = use_default;
5395 mp->no_advertise = no_advertise;
5396 mp->off_link = off_link;
5397 mp->no_autoconfig = no_autoconfig;
5398 mp->no_onlink = no_onlink;
5400 mp->val_lifetime = ntohl(val_lifetime);
5401 mp->pref_lifetime = ntohl(pref_lifetime);
5406 /* Wait for a reply, return good/bad news */
5413 static int api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
5415 unformat_input_t * i = vam->input;
5416 vl_api_sw_interface_ip6nd_ra_config_t *mp;
5419 u8 sw_if_index_set = 0;
5424 u8 send_unicast = 0;
5427 u8 default_router = 0;
5428 u32 max_interval = 0;
5429 u32 min_interval = 0;
5431 u32 initial_count = 0;
5432 u32 initial_interval = 0;
5435 /* Parse args required to build the message */
5436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5437 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5438 sw_if_index_set = 1;
5439 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5440 sw_if_index_set = 1;
5441 else if (unformat (i, "maxint %d", &max_interval))
5443 else if (unformat (i, "minint %d", &min_interval))
5445 else if (unformat (i, "life %d", &lifetime))
5447 else if (unformat (i, "count %d", &initial_count))
5449 else if (unformat (i, "interval %d", &initial_interval))
5451 else if (unformat (i, "surpress"))
5453 else if (unformat (i, "managed"))
5455 else if (unformat (i, "other"))
5457 else if (unformat (i, "ll"))
5459 else if (unformat (i, "send"))
5461 else if (unformat (i, "cease"))
5463 else if (unformat (i, "isno"))
5465 else if (unformat (i, "def"))
5468 clib_warning ("parse error '%U'", format_unformat_error, i);
5473 if (sw_if_index_set == 0) {
5474 errmsg ("missing interface name or sw_if_index\n");
5478 /* Construct the API message */
5479 M(SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
5481 mp->sw_if_index = ntohl (sw_if_index);
5482 mp->max_interval = ntohl(max_interval);
5483 mp->min_interval = ntohl(min_interval);
5484 mp->lifetime = ntohl(lifetime);
5485 mp->initial_count = ntohl(initial_count);
5486 mp->initial_interval = ntohl(initial_interval);
5487 mp->surpress = surpress;
5488 mp->managed = managed;
5490 mp->ll_option = ll_option;
5491 mp->send_unicast = send_unicast;
5494 mp->default_router = default_router;
5499 /* Wait for a reply, return good/bad news */
5506 static int api_set_arp_neighbor_limit (vat_main_t * vam)
5508 unformat_input_t * i = vam->input;
5509 vl_api_set_arp_neighbor_limit_t *mp;
5515 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5516 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
5518 else if (unformat (i, "ipv6"))
5521 clib_warning ("parse error '%U'", format_unformat_error, i);
5526 if (limit_set == 0) {
5527 errmsg ("missing limit value\n");
5531 M(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
5533 mp->arp_neighbor_limit = ntohl(arp_nbr_limit);
5534 mp->is_ipv6 = is_ipv6;
5541 static int api_l2_patch_add_del (vat_main_t * vam)
5543 unformat_input_t * i = vam->input;
5544 vl_api_l2_patch_add_del_t *mp;
5547 u8 rx_sw_if_index_set = 0;
5549 u8 tx_sw_if_index_set = 0;
5552 /* Parse args required to build the message */
5553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5554 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5555 rx_sw_if_index_set = 1;
5556 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5557 tx_sw_if_index_set = 1;
5558 else if (unformat (i, "rx")) {
5559 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5560 if (unformat (i, "%U", unformat_sw_if_index, vam,
5562 rx_sw_if_index_set = 1;
5565 } else if (unformat (i, "tx")) {
5566 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5567 if (unformat (i, "%U", unformat_sw_if_index, vam,
5569 tx_sw_if_index_set = 1;
5572 } else if (unformat (i, "del"))
5578 if (rx_sw_if_index_set == 0) {
5579 errmsg ("missing rx interface name or rx_sw_if_index\n");
5583 if (tx_sw_if_index_set == 0) {
5584 errmsg ("missing tx interface name or tx_sw_if_index\n");
5588 M(L2_PATCH_ADD_DEL, l2_patch_add_del);
5590 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
5591 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
5592 mp->is_add = is_add;
5598 static int api_trace_profile_add (vat_main_t *vam)
5600 unformat_input_t * input = vam->input;
5601 vl_api_trace_profile_add_t *mp;
5604 u32 trace_option_elts = 0;
5605 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
5606 int has_pow_option = 0;
5607 int has_ppc_option = 0;
5609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5611 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
5612 "trace-tsp %d node-id 0x%x app-data 0x%x",
5613 &id, &trace_type, &trace_option_elts, &trace_tsp,
5614 &node_id, &app_data))
5616 else if (unformat (input, "pow"))
5618 else if (unformat (input, "ppc encap"))
5619 has_ppc_option = PPC_ENCAP;
5620 else if (unformat (input, "ppc decap"))
5621 has_ppc_option = PPC_DECAP;
5622 else if (unformat (input, "ppc none"))
5623 has_ppc_option = PPC_NONE;
5627 M(TRACE_PROFILE_ADD, trace_profile_add);
5629 mp->trace_type = trace_type;
5630 mp->trace_num_elt = trace_option_elts;
5631 mp->trace_ppc = has_ppc_option;
5632 mp->trace_app_data = htonl(app_data);
5633 mp->pow_enable = has_pow_option;
5634 mp->trace_tsp = trace_tsp;
5635 mp->node_id = htonl(node_id);
5642 static int api_trace_profile_apply (vat_main_t *vam)
5644 unformat_input_t * input = vam->input;
5645 vl_api_trace_profile_apply_t *mp;
5648 u32 mask_width = ~0;
5655 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5657 if (unformat (input, "%U/%d",
5658 unformat_ip6_address, &addr, &mask_width))
5660 else if (unformat (input, "id %d", &id))
5662 else if (unformat (input, "vrf-id %d", &vrf_id))
5664 else if (unformat (input, "add"))
5666 else if (unformat (input, "pop"))
5668 else if (unformat (input, "none"))
5674 if ((is_add + is_pop + is_none) != 1) {
5675 errmsg("One of (add, pop, none) required");
5678 if (mask_width == ~0) {
5679 errmsg("<address>/<mask-width> required");
5682 M(TRACE_PROFILE_APPLY, trace_profile_apply);
5683 clib_memcpy(mp->dest_ipv6, &addr, sizeof(mp->dest_ipv6));
5685 mp->prefix_length = htonl(mask_width);
5686 mp->vrf_id = htonl(vrf_id);
5688 mp->trace_op = IOAM_HBYH_ADD;
5690 mp->trace_op = IOAM_HBYH_POP;
5692 mp->trace_op = IOAM_HBYH_MOD;
5704 static int api_trace_profile_del (vat_main_t *vam)
5706 vl_api_trace_profile_del_t *mp;
5709 M(TRACE_PROFILE_DEL, trace_profile_del);
5714 static int api_sr_tunnel_add_del (vat_main_t * vam)
5716 unformat_input_t * i = vam->input;
5717 vl_api_sr_tunnel_add_del_t *mp;
5721 ip6_address_t src_address;
5722 int src_address_set = 0;
5723 ip6_address_t dst_address;
5725 int dst_address_set = 0;
5727 u32 rx_table_id = 0;
5728 u32 tx_table_id = 0;
5729 ip6_address_t * segments = 0;
5730 ip6_address_t * this_seg;
5731 ip6_address_t * tags = 0;
5732 ip6_address_t * this_tag;
5733 ip6_address_t next_address, tag;
5735 u8 * policy_name = 0;
5737 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5739 if (unformat (i, "del"))
5741 else if (unformat (i, "name %s", &name))
5743 else if (unformat (i, "policy %s", &policy_name))
5745 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
5747 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
5749 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
5750 src_address_set = 1;
5751 else if (unformat (i, "dst %U/%d",
5752 unformat_ip6_address, &dst_address,
5754 dst_address_set = 1;
5755 else if (unformat (i, "next %U", unformat_ip6_address,
5758 vec_add2 (segments, this_seg, 1);
5759 clib_memcpy (this_seg->as_u8, next_address.as_u8, sizeof (*this_seg));
5761 else if (unformat (i, "tag %U", unformat_ip6_address,
5764 vec_add2 (tags, this_tag, 1);
5765 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
5767 else if (unformat (i, "clean"))
5768 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
5769 else if (unformat (i, "protected"))
5770 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
5771 else if (unformat (i, "InPE %d", &pl_index))
5773 if (pl_index <= 0 || pl_index > 4)
5775 pl_index_range_error:
5776 errmsg ("pl index %d out of range\n", pl_index);
5779 flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3*(pl_index - 1));
5781 else if (unformat (i, "EgPE %d", &pl_index))
5783 if (pl_index <= 0 || pl_index > 4)
5784 goto pl_index_range_error;
5785 flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3*(pl_index - 1));
5787 else if (unformat (i, "OrgSrc %d", &pl_index))
5789 if (pl_index <= 0 || pl_index > 4)
5790 goto pl_index_range_error;
5791 flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3*(pl_index - 1));
5797 if (!src_address_set)
5799 errmsg ("src address required\n");
5803 if (!dst_address_set)
5805 errmsg ("dst address required\n");
5811 errmsg ("at least one sr segment required\n");
5815 M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
5816 vec_len(segments) * sizeof (ip6_address_t)
5817 + vec_len(tags) * sizeof (ip6_address_t));
5819 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
5820 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
5821 mp->dst_mask_width = dst_mask_width;
5822 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
5823 mp->n_segments = vec_len (segments);
5824 mp->n_tags = vec_len (tags);
5825 mp->is_add = is_del == 0;
5826 clib_memcpy (mp->segs_and_tags, segments,
5827 vec_len(segments)* sizeof (ip6_address_t));
5828 clib_memcpy (mp->segs_and_tags + vec_len(segments)*sizeof (ip6_address_t),
5829 tags, vec_len(tags)* sizeof (ip6_address_t));
5831 mp->outer_vrf_id = ntohl (rx_table_id);
5832 mp->inner_vrf_id = ntohl (tx_table_id);
5833 memcpy (mp->name, name, vec_len(name));
5834 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
5836 vec_free (segments);
5843 static int api_sr_policy_add_del (vat_main_t * vam)
5845 unformat_input_t * input = vam->input;
5846 vl_api_sr_policy_add_del_t *mp;
5850 u8 * tunnel_name = 0;
5851 u8 ** tunnel_names = 0;
5856 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
5857 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
5859 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5861 if (unformat (input, "del"))
5863 else if (unformat (input, "name %s", &name))
5865 else if (unformat (input, "tunnel %s", &tunnel_name))
5869 vec_add1 (tunnel_names, tunnel_name);
5871 - length = #bytes to store in serial vector
5872 - +1 = byte to store that length
5874 tunnel_names_length += (vec_len (tunnel_name) + 1);
5885 errmsg ("policy name required\n");
5889 if ((!tunnel_set) && (!is_del))
5891 errmsg ("tunnel name required\n");
5895 M2(SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
5899 mp->is_add = !is_del;
5901 memcpy (mp->name, name, vec_len(name));
5902 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
5903 u8 * serial_orig = 0;
5904 vec_validate (serial_orig, tunnel_names_length);
5905 *serial_orig = vec_len(tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
5906 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
5908 for (j=0; j < vec_len(tunnel_names); j++)
5910 tun_name_len = vec_len (tunnel_names[j]);
5911 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
5912 serial_orig += 1; // Move along one byte to store the actual tunnel name
5913 memcpy (serial_orig, tunnel_names[j], tun_name_len);
5914 serial_orig += tun_name_len; // Advance past the copy
5916 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
5918 vec_free (tunnel_names);
5919 vec_free (tunnel_name);
5925 static int api_sr_multicast_map_add_del (vat_main_t * vam)
5927 unformat_input_t * input = vam->input;
5928 vl_api_sr_multicast_map_add_del_t *mp;
5931 ip6_address_t multicast_address;
5932 u8 * policy_name = 0;
5933 int multicast_address_set = 0;
5935 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5937 if (unformat (input, "del"))
5939 else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address))
5940 multicast_address_set = 1;
5941 else if (unformat (input, "sr-policy %s", &policy_name))
5947 if (!is_del && !policy_name)
5949 errmsg ("sr-policy name required\n");
5954 if (!multicast_address_set)
5956 errmsg ("address required\n");
5960 M(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
5962 mp->is_add = !is_del;
5963 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
5964 clib_memcpy (mp->multicast_address, &multicast_address, sizeof (mp->multicast_address));
5967 vec_free (policy_name);
5974 #define foreach_ip4_proto_field \
5984 uword unformat_ip4_mask (unformat_input_t * input, va_list * args)
5986 u8 ** maskp = va_arg (*args, u8 **);
5988 u8 found_something = 0;
5991 #define _(a) u8 a=0;
5992 foreach_ip4_proto_field;
5998 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6000 if (unformat (input, "version"))
6002 else if (unformat (input, "hdr_length"))
6004 else if (unformat (input, "src"))
6006 else if (unformat (input, "dst"))
6008 else if (unformat (input, "proto"))
6011 #define _(a) else if (unformat (input, #a)) a=1;
6012 foreach_ip4_proto_field
6018 #define _(a) found_something += a;
6019 foreach_ip4_proto_field;
6022 if (found_something == 0)
6025 vec_validate (mask, sizeof (*ip) - 1);
6027 ip = (ip4_header_t *) mask;
6029 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6030 foreach_ip4_proto_field;
6033 ip->ip_version_and_header_length = 0;
6036 ip->ip_version_and_header_length |= 0xF0;
6039 ip->ip_version_and_header_length |= 0x0F;
6045 #define foreach_ip6_proto_field \
6052 uword unformat_ip6_mask (unformat_input_t * input, va_list * args)
6054 u8 ** maskp = va_arg (*args, u8 **);
6056 u8 found_something = 0;
6058 u32 ip_version_traffic_class_and_flow_label;
6060 #define _(a) u8 a=0;
6061 foreach_ip6_proto_field;
6064 u8 traffic_class = 0;
6067 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6069 if (unformat (input, "version"))
6071 else if (unformat (input, "traffic-class"))
6073 else if (unformat (input, "flow-label"))
6075 else if (unformat (input, "src"))
6077 else if (unformat (input, "dst"))
6079 else if (unformat (input, "proto"))
6082 #define _(a) else if (unformat (input, #a)) a=1;
6083 foreach_ip6_proto_field
6089 #define _(a) found_something += a;
6090 foreach_ip6_proto_field;
6093 if (found_something == 0)
6096 vec_validate (mask, sizeof (*ip) - 1);
6098 ip = (ip6_header_t *) mask;
6100 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6101 foreach_ip6_proto_field;
6104 ip_version_traffic_class_and_flow_label = 0;
6107 ip_version_traffic_class_and_flow_label |= 0xF0000000;
6110 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
6113 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
6115 ip->ip_version_traffic_class_and_flow_label =
6116 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6122 uword unformat_l3_mask (unformat_input_t * input, va_list * args)
6124 u8 ** maskp = va_arg (*args, u8 **);
6126 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6127 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
6129 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
6137 uword unformat_l2_mask (unformat_input_t * input, va_list * args)
6139 u8 ** maskp = va_arg (*args, u8 **);
6154 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6155 if (unformat (input, "src"))
6157 else if (unformat (input, "dst"))
6159 else if (unformat (input, "proto"))
6161 else if (unformat (input, "tag1"))
6163 else if (unformat (input, "tag2"))
6165 else if (unformat (input, "ignore-tag1"))
6167 else if (unformat (input, "ignore-tag2"))
6169 else if (unformat (input, "cos1"))
6171 else if (unformat (input, "cos2"))
6173 else if (unformat (input, "dot1q"))
6175 else if (unformat (input, "dot1ad"))
6180 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
6181 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6184 if (tag1 || ignore_tag1 || cos1 || dot1q)
6186 if (tag2 || ignore_tag2 || cos2 || dot1ad)
6189 vec_validate (mask, len-1);
6192 memset (mask, 0xff, 6);
6195 memset (mask + 6, 0xff, 6);
6199 /* inner vlan tag */
6208 mask[21] = mask [20] = 0xff;
6229 mask[16] = mask [17] = 0xff;
6239 mask[12] = mask [13] = 0xff;
6245 uword unformat_classify_mask (unformat_input_t * input, va_list * args)
6247 u8 ** maskp = va_arg (*args, u8 **);
6248 u32 * skipp = va_arg (*args, u32 *);
6249 u32 * matchp = va_arg (*args, u32 *);
6256 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6257 if (unformat (input, "hex %U", unformat_hex_string, &mask))
6259 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
6261 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
6267 if (mask || l2 || l3)
6271 /* "With a free Ethernet header in every package" */
6273 vec_validate (l2, 13);
6275 vec_append (mask, l3);
6279 /* Scan forward looking for the first significant mask octet */
6280 for (i = 0; i < vec_len (mask); i++)
6284 /* compute (skip, match) params */
6285 *skipp = i / sizeof(u32x4);
6286 vec_delete (mask, *skipp * sizeof(u32x4), 0);
6288 /* Pad mask to an even multiple of the vector size */
6289 while (vec_len (mask) % sizeof (u32x4))
6292 match = vec_len (mask) / sizeof (u32x4);
6294 for (i = match*sizeof(u32x4); i > 0; i-= sizeof(u32x4))
6296 u64 *tmp = (u64 *)(mask + (i-sizeof(u32x4)));
6297 if (*tmp || *(tmp+1))
6302 clib_warning ("BUG: match 0");
6304 _vec_len (mask) = match * sizeof(u32x4);
6315 #define foreach_l2_next \
6317 _(ethernet, ETHERNET_INPUT) \
6321 uword unformat_l2_next_index (unformat_input_t * input, va_list * args)
6323 u32 * miss_next_indexp = va_arg (*args, u32 *);
6328 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
6332 if (unformat (input, "%d", &tmp))
6341 *miss_next_indexp = next_index;
6345 #define foreach_ip_next \
6351 uword unformat_ip_next_index (unformat_input_t * input, va_list * args)
6353 u32 * miss_next_indexp = va_arg (*args, u32 *);
6358 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
6362 if (unformat (input, "%d", &tmp))
6371 *miss_next_indexp = next_index;
6375 #define foreach_acl_next \
6378 uword unformat_acl_next_index (unformat_input_t * input, va_list * args)
6380 u32 * miss_next_indexp = va_arg (*args, u32 *);
6385 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
6389 if (unformat (input, "permit"))
6394 else if (unformat (input, "%d", &tmp))
6403 *miss_next_indexp = next_index;
6407 static int api_classify_add_del_table (vat_main_t * vam)
6409 unformat_input_t * i = vam->input;
6410 vl_api_classify_add_del_table_t *mp;
6416 u32 table_index = ~0;
6417 u32 next_table_index = ~0;
6418 u32 miss_next_index = ~0;
6419 u32 memory_size = 32<<20;
6423 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6424 if (unformat (i, "del"))
6426 else if (unformat (i, "buckets %d", &nbuckets))
6428 else if (unformat (i, "memory_size %d", &memory_size))
6430 else if (unformat (i, "skip %d", &skip))
6432 else if (unformat (i, "match %d", &match))
6434 else if (unformat (i, "table %d", &table_index))
6436 else if (unformat (i, "mask %U", unformat_classify_mask,
6437 &mask, &skip, &match))
6439 else if (unformat (i, "next-table %d", &next_table_index))
6441 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
6444 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
6447 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
6454 if (is_add && mask == 0) {
6455 errmsg ("Mask required\n");
6459 if (is_add && skip == ~0) {
6460 errmsg ("skip count required\n");
6464 if (is_add && match == ~0) {
6465 errmsg ("match count required\n");
6469 if (!is_add && table_index == ~0) {
6470 errmsg ("table index required for delete\n");
6474 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table,
6477 mp->is_add = is_add;
6478 mp->table_index = ntohl(table_index);
6479 mp->nbuckets = ntohl(nbuckets);
6480 mp->memory_size = ntohl(memory_size);
6481 mp->skip_n_vectors = ntohl(skip);
6482 mp->match_n_vectors = ntohl(match);
6483 mp->next_table_index = ntohl(next_table_index);
6484 mp->miss_next_index = ntohl(miss_next_index);
6485 clib_memcpy (mp->mask, mask, vec_len(mask));
6493 uword unformat_ip4_match (unformat_input_t * input, va_list * args)
6495 u8 ** matchp = va_arg (*args, u8 **);
6502 int src = 0, dst = 0;
6503 ip4_address_t src_val, dst_val;
6510 int fragment_id = 0;
6511 u32 fragment_id_val;
6517 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6519 if (unformat (input, "version %d", &version_val))
6521 else if (unformat (input, "hdr_length %d", &hdr_length_val))
6523 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
6525 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
6527 else if (unformat (input, "proto %d", &proto_val))
6529 else if (unformat (input, "tos %d", &tos_val))
6531 else if (unformat (input, "length %d", &length_val))
6533 else if (unformat (input, "fragment_id %d", &fragment_id_val))
6535 else if (unformat (input, "ttl %d", &ttl_val))
6537 else if (unformat (input, "checksum %d", &checksum_val))
6543 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
6544 + ttl + checksum == 0)
6548 * Aligned because we use the real comparison functions
6550 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6552 ip = (ip4_header_t *) match;
6554 /* These are realistically matched in practice */
6556 ip->src_address.as_u32 = src_val.as_u32;
6559 ip->dst_address.as_u32 = dst_val.as_u32;
6562 ip->protocol = proto_val;
6565 /* These are not, but they're included for completeness */
6567 ip->ip_version_and_header_length |= (version_val & 0xF)<<4;
6570 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
6576 ip->length = length_val;
6582 ip->checksum = checksum_val;
6588 uword unformat_ip6_match (unformat_input_t * input, va_list * args)
6590 u8 ** matchp = va_arg (*args, u8 **);
6596 u32 traffic_class_val;
6599 int src = 0, dst = 0;
6600 ip6_address_t src_val, dst_val;
6603 int payload_length = 0;
6604 u32 payload_length_val;
6607 u32 ip_version_traffic_class_and_flow_label;
6609 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6611 if (unformat (input, "version %d", &version_val))
6613 else if (unformat (input, "traffic_class %d", &traffic_class_val))
6615 else if (unformat (input, "flow_label %d", &flow_label_val))
6617 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
6619 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
6621 else if (unformat (input, "proto %d", &proto_val))
6623 else if (unformat (input, "payload_length %d", &payload_length_val))
6625 else if (unformat (input, "hop_limit %d", &hop_limit_val))
6631 if (version + traffic_class + flow_label + src + dst + proto +
6632 payload_length + hop_limit == 0)
6636 * Aligned because we use the real comparison functions
6638 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6640 ip = (ip6_header_t *) match;
6643 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
6646 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
6649 ip->protocol = proto_val;
6651 ip_version_traffic_class_and_flow_label = 0;
6654 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
6657 ip_version_traffic_class_and_flow_label |= (traffic_class_val & 0xFF) << 20;
6660 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
6662 ip->ip_version_traffic_class_and_flow_label =
6663 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6666 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
6669 ip->hop_limit = hop_limit_val;
6675 uword unformat_l3_match (unformat_input_t * input, va_list * args)
6677 u8 ** matchp = va_arg (*args, u8 **);
6679 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6680 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
6682 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
6690 uword unformat_vlan_tag (unformat_input_t * input, va_list * args)
6692 u8 * tagp = va_arg (*args, u8 *);
6695 if (unformat(input, "%d", &tag))
6697 tagp[0] = (tag>>8) & 0x0F;
6698 tagp[1] = tag & 0xFF;
6705 uword unformat_l2_match (unformat_input_t * input, va_list * args)
6707 u8 ** matchp = va_arg (*args, u8 **);
6727 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6728 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
6730 else if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
6732 else if (unformat (input, "proto %U",
6733 unformat_ethernet_type_host_byte_order, &proto_val))
6735 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
6737 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
6739 else if (unformat (input, "ignore-tag1"))
6741 else if (unformat (input, "ignore-tag2"))
6743 else if (unformat (input, "cos1 %d", &cos1_val))
6745 else if (unformat (input, "cos2 %d", &cos2_val))
6750 if ((src + dst + proto + tag1 + tag2 +
6751 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6754 if (tag1 || ignore_tag1 || cos1)
6756 if (tag2 || ignore_tag2 || cos2)
6759 vec_validate_aligned (match, len-1, sizeof(u32x4));
6762 clib_memcpy (match, dst_val, 6);
6765 clib_memcpy (match + 6, src_val, 6);
6769 /* inner vlan tag */
6770 match[19] = tag2_val[1];
6771 match[18] = tag2_val[0];
6773 match [18] |= (cos2_val & 0x7) << 5;
6776 match[21] = proto_val & 0xff;
6777 match[20] = proto_val >> 8;
6781 match [15] = tag1_val[1];
6782 match [14] = tag1_val[0];
6785 match [14] |= (cos1_val & 0x7) << 5;
6791 match [15] = tag1_val[1];
6792 match [14] = tag1_val[0];
6795 match[17] = proto_val & 0xff;
6796 match[16] = proto_val >> 8;
6799 match [14] |= (cos1_val & 0x7) << 5;
6805 match [18] |= (cos2_val & 0x7) << 5;
6807 match [14] |= (cos1_val & 0x7) << 5;
6810 match[13] = proto_val & 0xff;
6811 match[12] = proto_val >> 8;
6819 uword unformat_classify_match (unformat_input_t * input, va_list * args)
6821 u8 ** matchp = va_arg (*args, u8 **);
6822 u32 skip_n_vectors = va_arg (*args, u32);
6823 u32 match_n_vectors = va_arg (*args, u32);
6829 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6830 if (unformat (input, "hex %U", unformat_hex_string, &match))
6832 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
6834 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
6840 if (match || l2 || l3)
6844 /* "Win a free Ethernet header in every packet" */
6846 vec_validate_aligned (l2, 13, sizeof(u32x4));
6848 vec_append_aligned (match, l3, sizeof(u32x4));
6852 /* Make sure the vector is big enough even if key is all 0's */
6853 vec_validate_aligned
6854 (match, ((match_n_vectors + skip_n_vectors) * sizeof(u32x4)) - 1,
6857 /* Set size, include skipped vectors*/
6858 _vec_len (match) = (match_n_vectors+skip_n_vectors) * sizeof(u32x4);
6868 static int api_classify_add_del_session (vat_main_t * vam)
6870 unformat_input_t * i = vam->input;
6871 vl_api_classify_add_del_session_t *mp;
6873 u32 table_index = ~0;
6874 u32 hit_next_index = ~0;
6875 u32 opaque_index = ~0;
6879 u32 skip_n_vectors = 0;
6880 u32 match_n_vectors = 0;
6883 * Warning: you have to supply skip_n and match_n
6884 * because the API client cant simply look at the classify
6888 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6889 if (unformat (i, "del"))
6891 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
6894 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
6897 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
6900 else if (unformat (i, "opaque-index %d", &opaque_index))
6902 else if (unformat (i, "skip_n %d", &skip_n_vectors))
6904 else if (unformat (i, "match_n %d", &match_n_vectors))
6906 else if (unformat (i, "match %U", unformat_classify_match,
6907 &match, skip_n_vectors, match_n_vectors))
6909 else if (unformat (i, "advance %d", &advance))
6911 else if (unformat (i, "table-index %d", &table_index))
6917 if (table_index == ~0) {
6918 errmsg ("Table index required\n");
6922 if (is_add && match == 0) {
6923 errmsg ("Match value required\n");
6927 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session,
6930 mp->is_add = is_add;
6931 mp->table_index = ntohl(table_index);
6932 mp->hit_next_index = ntohl(hit_next_index);
6933 mp->opaque_index = ntohl(opaque_index);
6934 mp->advance = ntohl(advance);
6935 clib_memcpy (mp->match, match, vec_len(match));
6942 static int api_classify_set_interface_ip_table (vat_main_t * vam)
6944 unformat_input_t * i = vam->input;
6945 vl_api_classify_set_interface_ip_table_t *mp;
6948 int sw_if_index_set;
6949 u32 table_index = ~0;
6952 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6953 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6954 sw_if_index_set = 1;
6955 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6956 sw_if_index_set = 1;
6957 else if (unformat (i, "table %d", &table_index))
6960 clib_warning ("parse error '%U'", format_unformat_error, i);
6965 if (sw_if_index_set == 0) {
6966 errmsg ("missing interface name or sw_if_index\n");
6971 M(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
6973 mp->sw_if_index = ntohl(sw_if_index);
6974 mp->table_index = ntohl(table_index);
6975 mp->is_ipv6 = is_ipv6;
6982 static int api_classify_set_interface_l2_tables (vat_main_t * vam)
6984 unformat_input_t * i = vam->input;
6985 vl_api_classify_set_interface_l2_tables_t *mp;
6988 int sw_if_index_set;
6989 u32 ip4_table_index = ~0;
6990 u32 ip6_table_index = ~0;
6991 u32 other_table_index = ~0;
6993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6994 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6995 sw_if_index_set = 1;
6996 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6997 sw_if_index_set = 1;
6998 else if (unformat (i, "ip4-table %d", &ip4_table_index))
7000 else if (unformat (i, "ip6-table %d", &ip6_table_index))
7002 else if (unformat (i, "other-table %d", &other_table_index))
7005 clib_warning ("parse error '%U'", format_unformat_error, i);
7010 if (sw_if_index_set == 0) {
7011 errmsg ("missing interface name or sw_if_index\n");
7016 M(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
7018 mp->sw_if_index = ntohl(sw_if_index);
7019 mp->ip4_table_index = ntohl(ip4_table_index);
7020 mp->ip6_table_index = ntohl(ip6_table_index);
7021 mp->other_table_index = ntohl(other_table_index);
7029 static int api_get_node_index (vat_main_t * vam)
7031 unformat_input_t * i = vam->input;
7032 vl_api_get_node_index_t * mp;
7036 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7037 if (unformat (i, "node %s", &name))
7043 errmsg ("node name required\n");
7046 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7047 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7051 M(GET_NODE_INDEX, get_node_index);
7052 clib_memcpy (mp->node_name, name, vec_len(name));
7060 static int api_add_node_next (vat_main_t * vam)
7062 unformat_input_t * i = vam->input;
7063 vl_api_add_node_next_t * mp;
7068 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7069 if (unformat (i, "node %s", &name))
7071 else if (unformat (i, "next %s", &next))
7077 errmsg ("node name required\n");
7080 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7081 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7085 errmsg ("next node required\n");
7088 if (vec_len (next) >= ARRAY_LEN(mp->next_name)) {
7089 errmsg ("next name too long, max %d\n", ARRAY_LEN(mp->next_name));
7093 M(ADD_NODE_NEXT, add_node_next);
7094 clib_memcpy (mp->node_name, name, vec_len(name));
7095 clib_memcpy (mp->next_name, next, vec_len(next));
7104 static int api_l2tpv3_create_tunnel (vat_main_t * vam)
7106 unformat_input_t * i = vam->input;
7107 ip6_address_t client_address, our_address;
7108 int client_address_set = 0;
7109 int our_address_set = 0;
7110 u32 local_session_id = 0;
7111 u32 remote_session_id = 0;
7112 u64 local_cookie = 0;
7113 u64 remote_cookie = 0;
7114 u8 l2_sublayer_present = 0;
7115 vl_api_l2tpv3_create_tunnel_t * mp;
7118 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7119 if (unformat (i, "client_address %U", unformat_ip6_address,
7121 client_address_set = 1;
7122 else if (unformat (i, "our_address %U", unformat_ip6_address,
7124 our_address_set = 1;
7125 else if (unformat (i, "local_session_id %d", &local_session_id))
7127 else if (unformat (i, "remote_session_id %d", &remote_session_id))
7129 else if (unformat (i, "local_cookie %lld", &local_cookie))
7131 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
7133 else if (unformat (i, "l2-sublayer-present"))
7134 l2_sublayer_present = 1;
7139 if (client_address_set == 0) {
7140 errmsg ("client_address required\n");
7144 if (our_address_set == 0) {
7145 errmsg ("our_address required\n");
7149 M(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
7151 clib_memcpy (mp->client_address, client_address.as_u8,
7152 sizeof (mp->client_address));
7154 clib_memcpy (mp->our_address, our_address.as_u8,
7155 sizeof (mp->our_address));
7157 mp->local_session_id = ntohl (local_session_id);
7158 mp->remote_session_id = ntohl (remote_session_id);
7159 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
7160 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
7161 mp->l2_sublayer_present = l2_sublayer_present;
7169 static int api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
7171 unformat_input_t * i = vam->input;
7173 u8 sw_if_index_set = 0;
7174 u64 new_local_cookie = 0;
7175 u64 new_remote_cookie = 0;
7176 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
7179 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7180 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7181 sw_if_index_set = 1;
7182 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7183 sw_if_index_set = 1;
7184 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
7186 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
7192 if (sw_if_index_set == 0) {
7193 errmsg ("missing interface name or sw_if_index\n");
7197 M(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
7199 mp->sw_if_index = ntohl(sw_if_index);
7200 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
7201 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
7208 static int api_l2tpv3_interface_enable_disable (vat_main_t * vam)
7210 unformat_input_t * i = vam->input;
7211 vl_api_l2tpv3_interface_enable_disable_t *mp;
7214 u8 sw_if_index_set = 0;
7215 u8 enable_disable = 1;
7217 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7218 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7219 sw_if_index_set = 1;
7220 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7221 sw_if_index_set = 1;
7222 else if (unformat (i, "enable"))
7224 else if (unformat (i, "disable"))
7230 if (sw_if_index_set == 0) {
7231 errmsg ("missing interface name or sw_if_index\n");
7235 M(L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
7237 mp->sw_if_index = ntohl(sw_if_index);
7238 mp->enable_disable = enable_disable;
7245 static int api_l2tpv3_set_lookup_key (vat_main_t * vam)
7247 unformat_input_t * i = vam->input;
7248 vl_api_l2tpv3_set_lookup_key_t * mp;
7252 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7253 if (unformat (i, "lookup_v6_src"))
7254 key = L2T_LOOKUP_SRC_ADDRESS;
7255 else if (unformat (i, "lookup_v6_dst"))
7256 key = L2T_LOOKUP_DST_ADDRESS;
7257 else if (unformat (i, "lookup_session_id"))
7258 key = L2T_LOOKUP_SESSION_ID;
7263 if (key == (u8) ~0) {
7264 errmsg ("l2tp session lookup key unset\n");
7268 M(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
7277 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
7278 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7280 vat_main_t * vam = &vat_main;
7282 fformat(vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
7283 format_ip6_address, mp->our_address,
7284 format_ip6_address, mp->client_address,
7285 clib_net_to_host_u32(mp->sw_if_index));
7287 fformat (vam->ofp, " local cookies %016llx %016llx remote cookie %016llx\n",
7288 clib_net_to_host_u64 (mp->local_cookie[0]),
7289 clib_net_to_host_u64 (mp->local_cookie[1]),
7290 clib_net_to_host_u64 (mp->remote_cookie));
7292 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
7293 clib_net_to_host_u32 (mp->local_session_id),
7294 clib_net_to_host_u32 (mp->remote_session_id));
7296 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
7297 mp->l2_sublayer_present ? "preset" : "absent");
7301 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
7302 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7304 vat_main_t * vam = &vat_main;
7305 vat_json_node_t *node = NULL;
7306 struct in6_addr addr;
7308 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7309 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7310 vat_json_init_array(&vam->json_tree);
7312 node = vat_json_array_add(&vam->json_tree);
7314 vat_json_init_object(node);
7316 clib_memcpy(&addr, mp->our_address, sizeof(addr));
7317 vat_json_object_add_ip6(node, "our_address", addr);
7318 clib_memcpy(&addr, mp->client_address, sizeof(addr));
7319 vat_json_object_add_ip6(node, "client_address", addr);
7321 vat_json_node_t * lc = vat_json_object_add(node, "local_cookie");
7322 vat_json_init_array(lc);
7323 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[0]));
7324 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[1]));
7325 vat_json_object_add_uint(node, "remote_cookie", clib_net_to_host_u64(mp->remote_cookie));
7327 printf("local id: %u", clib_net_to_host_u32(mp->local_session_id));
7328 vat_json_object_add_uint(node, "local_session_id", clib_net_to_host_u32(mp->local_session_id));
7329 vat_json_object_add_uint(node, "remote_session_id", clib_net_to_host_u32(mp->remote_session_id));
7330 vat_json_object_add_string_copy(node, "l2_sublayer", mp->l2_sublayer_present ?
7331 (u8*)"present" : (u8*)"absent");
7334 static int api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
7336 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
7339 /* Get list of l2tpv3-tunnel interfaces */
7340 M(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
7343 /* Use a control ping for synchronization */
7345 vl_api_control_ping_t * mp;
7346 M(CONTROL_PING, control_ping);
7353 static void vl_api_sw_interface_tap_details_t_handler
7354 (vl_api_sw_interface_tap_details_t * mp)
7356 vat_main_t * vam = &vat_main;
7358 fformat(vam->ofp, "%-16s %d\n",
7360 clib_net_to_host_u32(mp->sw_if_index));
7363 static void vl_api_sw_interface_tap_details_t_handler_json
7364 (vl_api_sw_interface_tap_details_t * mp)
7366 vat_main_t * vam = &vat_main;
7367 vat_json_node_t *node = NULL;
7369 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7370 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7371 vat_json_init_array(&vam->json_tree);
7373 node = vat_json_array_add(&vam->json_tree);
7375 vat_json_init_object(node);
7376 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7377 vat_json_object_add_string_copy(node, "dev_name", mp->dev_name);
7380 static int api_sw_interface_tap_dump (vat_main_t * vam)
7382 vl_api_sw_interface_tap_dump_t *mp;
7385 fformat(vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
7386 /* Get list of tap interfaces */
7387 M(SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
7390 /* Use a control ping for synchronization */
7392 vl_api_control_ping_t * mp;
7393 M(CONTROL_PING, control_ping);
7399 static uword unformat_vxlan_decap_next
7400 (unformat_input_t * input, va_list * args)
7402 u32 * result = va_arg (*args, u32 *);
7405 if (unformat (input, "drop"))
7406 *result = VXLAN_INPUT_NEXT_DROP;
7407 else if (unformat (input, "ip4"))
7408 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
7409 else if (unformat (input, "ip6"))
7410 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
7411 else if (unformat (input, "l2"))
7412 *result = VXLAN_INPUT_NEXT_L2_INPUT;
7413 else if (unformat (input, "%d", &tmp))
7420 static int api_vxlan_add_del_tunnel (vat_main_t * vam)
7422 unformat_input_t * line_input = vam->input;
7423 vl_api_vxlan_add_del_tunnel_t *mp;
7425 ip4_address_t src4, dst4;
7426 ip6_address_t src6, dst6;
7428 u8 ipv4_set = 0, ipv6_set = 0;
7431 u32 encap_vrf_id = 0;
7432 u32 decap_next_index = ~0;
7435 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7436 if (unformat (line_input, "del"))
7438 else if (unformat (line_input, "src %U",
7439 unformat_ip4_address, &src4))
7444 else if (unformat (line_input, "dst %U",
7445 unformat_ip4_address, &dst4))
7450 else if (unformat (line_input, "src %U",
7451 unformat_ip6_address, &src6))
7456 else if (unformat (line_input, "dst %U",
7457 unformat_ip6_address, &dst6))
7462 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
7464 else if (unformat (line_input, "decap-next %U",
7465 unformat_vxlan_decap_next, &decap_next_index))
7467 else if (unformat (line_input, "vni %d", &vni))
7470 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7476 errmsg ("tunnel src address not specified\n");
7480 errmsg ("tunnel dst address not specified\n");
7484 if (ipv4_set && ipv6_set) {
7485 errmsg ("both IPv4 and IPv6 addresses specified");
7489 if ((vni == 0) || (vni>>24)) {
7490 errmsg ("vni not specified or out of range\n");
7494 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
7497 clib_memcpy(&mp->src_address, &src6, sizeof(src6));
7498 clib_memcpy(&mp->dst_address, &dst6, sizeof(dst6));
7500 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7501 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7503 mp->encap_vrf_id = ntohl(encap_vrf_id);
7504 mp->decap_next_index = ntohl(decap_next_index);
7505 mp->vni = ntohl(vni);
7506 mp->is_add = is_add;
7507 mp->is_ipv6 = ipv6_set;
7514 static void vl_api_vxlan_tunnel_details_t_handler
7515 (vl_api_vxlan_tunnel_details_t * mp)
7517 vat_main_t * vam = &vat_main;
7519 fformat(vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
7520 ntohl(mp->sw_if_index),
7521 format_ip46_address, &(mp->src_address[0]),
7522 format_ip46_address, &(mp->dst_address[0]),
7523 ntohl(mp->encap_vrf_id),
7524 ntohl(mp->decap_next_index),
7528 static void vl_api_vxlan_tunnel_details_t_handler_json
7529 (vl_api_vxlan_tunnel_details_t * mp)
7531 vat_main_t * vam = &vat_main;
7532 vat_json_node_t *node = NULL;
7534 struct in6_addr ip6;
7536 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7537 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7538 vat_json_init_array(&vam->json_tree);
7540 node = vat_json_array_add(&vam->json_tree);
7542 vat_json_init_object(node);
7543 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7545 clib_memcpy(&ip6, &(mp->src_address[0]), sizeof(ip6));
7546 vat_json_object_add_ip6(node, "src_address", ip6);
7547 clib_memcpy(&ip6, &(mp->dst_address[0]), sizeof(ip6));
7548 vat_json_object_add_ip6(node, "dst_address", ip6);
7550 clib_memcpy(&ip4, &(mp->src_address[0]), sizeof(ip4));
7551 vat_json_object_add_ip4(node, "src_address", ip4);
7552 clib_memcpy(&ip4, &(mp->dst_address[0]), sizeof(ip4));
7553 vat_json_object_add_ip4(node, "dst_address", ip4);
7555 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
7556 vat_json_object_add_uint(node, "decap_next_index", ntohl(mp->decap_next_index));
7557 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
7558 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
7561 static int api_vxlan_tunnel_dump (vat_main_t * vam)
7563 unformat_input_t * i = vam->input;
7564 vl_api_vxlan_tunnel_dump_t *mp;
7567 u8 sw_if_index_set = 0;
7569 /* Parse args required to build the message */
7570 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7571 if (unformat (i, "sw_if_index %d", &sw_if_index))
7572 sw_if_index_set = 1;
7577 if (sw_if_index_set == 0) {
7581 if (!vam->json_output) {
7582 fformat(vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
7583 "sw_if_index", "src_address", "dst_address",
7584 "encap_vrf_id", "decap_next_index", "vni");
7587 /* Get list of vxlan-tunnel interfaces */
7588 M(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
7590 mp->sw_if_index = htonl(sw_if_index);
7594 /* Use a control ping for synchronization */
7596 vl_api_control_ping_t * mp;
7597 M(CONTROL_PING, control_ping);
7603 static int api_gre_add_del_tunnel (vat_main_t * vam)
7605 unformat_input_t * line_input = vam->input;
7606 vl_api_gre_add_del_tunnel_t *mp;
7608 ip4_address_t src4, dst4;
7612 u32 outer_fib_id = 0;
7614 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7615 if (unformat (line_input, "del"))
7617 else if (unformat (line_input, "src %U",
7618 unformat_ip4_address, &src4))
7620 else if (unformat (line_input, "dst %U",
7621 unformat_ip4_address, &dst4))
7623 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
7626 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7632 errmsg ("tunnel src address not specified\n");
7636 errmsg ("tunnel dst address not specified\n");
7641 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
7643 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7644 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7645 mp->outer_table_id = ntohl(outer_fib_id);
7646 mp->is_add = is_add;
7653 static void vl_api_gre_tunnel_details_t_handler
7654 (vl_api_gre_tunnel_details_t * mp)
7656 vat_main_t * vam = &vat_main;
7658 fformat(vam->ofp, "%11d%15U%15U%14d\n",
7659 ntohl(mp->sw_if_index),
7660 format_ip4_address, &mp->src_address,
7661 format_ip4_address, &mp->dst_address,
7662 ntohl(mp->outer_table_id));
7665 static void vl_api_gre_tunnel_details_t_handler_json
7666 (vl_api_gre_tunnel_details_t * mp)
7668 vat_main_t * vam = &vat_main;
7669 vat_json_node_t *node = NULL;
7672 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7673 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7674 vat_json_init_array(&vam->json_tree);
7676 node = vat_json_array_add(&vam->json_tree);
7678 vat_json_init_object(node);
7679 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7680 clib_memcpy(&ip4, &mp->src_address, sizeof(ip4));
7681 vat_json_object_add_ip4(node, "src_address", ip4);
7682 clib_memcpy(&ip4, &mp->dst_address, sizeof(ip4));
7683 vat_json_object_add_ip4(node, "dst_address", ip4);
7684 vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_table_id));
7687 static int api_gre_tunnel_dump (vat_main_t * vam)
7689 unformat_input_t * i = vam->input;
7690 vl_api_gre_tunnel_dump_t *mp;
7693 u8 sw_if_index_set = 0;
7695 /* Parse args required to build the message */
7696 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7697 if (unformat (i, "sw_if_index %d", &sw_if_index))
7698 sw_if_index_set = 1;
7703 if (sw_if_index_set == 0) {
7707 if (!vam->json_output) {
7708 fformat(vam->ofp, "%11s%15s%15s%14s\n",
7709 "sw_if_index", "src_address", "dst_address",
7713 /* Get list of gre-tunnel interfaces */
7714 M(GRE_TUNNEL_DUMP, gre_tunnel_dump);
7716 mp->sw_if_index = htonl(sw_if_index);
7720 /* Use a control ping for synchronization */
7722 vl_api_control_ping_t * mp;
7723 M(CONTROL_PING, control_ping);
7729 static int api_l2_fib_clear_table (vat_main_t * vam)
7731 // unformat_input_t * i = vam->input;
7732 vl_api_l2_fib_clear_table_t *mp;
7735 M(L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
7742 static int api_l2_interface_efp_filter (vat_main_t * vam)
7744 unformat_input_t * i = vam->input;
7745 vl_api_l2_interface_efp_filter_t *mp;
7749 u8 sw_if_index_set = 0;
7751 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7752 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7753 sw_if_index_set = 1;
7754 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7755 sw_if_index_set = 1;
7756 else if (unformat (i, "enable"))
7758 else if (unformat (i, "disable"))
7761 clib_warning ("parse error '%U'", format_unformat_error, i);
7766 if (sw_if_index_set == 0) {
7767 errmsg ("missing sw_if_index\n");
7771 M(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
7773 mp->sw_if_index = ntohl(sw_if_index);
7774 mp->enable_disable = enable;
7781 #define foreach_vtr_op \
7782 _("disable", L2_VTR_DISABLED) \
7783 _("push-1", L2_VTR_PUSH_1) \
7784 _("push-2", L2_VTR_PUSH_2) \
7785 _("pop-1", L2_VTR_POP_1) \
7786 _("pop-2", L2_VTR_POP_2) \
7787 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
7788 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
7789 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
7790 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
7792 static int api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
7794 unformat_input_t * i = vam->input;
7795 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
7798 u8 sw_if_index_set = 0;
7805 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7806 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7807 sw_if_index_set = 1;
7808 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7809 sw_if_index_set = 1;
7810 else if (unformat (i, "vtr_op %d", &vtr_op))
7812 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
7816 else if (unformat (i, "push_dot1q %d", &push_dot1q))
7818 else if (unformat (i, "tag1 %d", &tag1))
7820 else if (unformat (i, "tag2 %d", &tag2))
7823 clib_warning ("parse error '%U'", format_unformat_error, i);
7828 if ((sw_if_index_set == 0)||(vtr_op_set == 0)) {
7829 errmsg ("missing vtr operation or sw_if_index\n");
7833 M(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
7835 mp->sw_if_index = ntohl(sw_if_index);
7836 mp->vtr_op = ntohl(vtr_op);
7837 mp->push_dot1q = ntohl(push_dot1q);
7838 mp->tag1 = ntohl(tag1);
7839 mp->tag2 = ntohl(tag2);
7846 static int api_create_vhost_user_if (vat_main_t * vam)
7848 unformat_input_t * i = vam->input;
7849 vl_api_create_vhost_user_if_t *mp;
7853 u8 file_name_set = 0;
7854 u32 custom_dev_instance = ~0;
7856 u8 use_custom_mac = 0;
7858 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7859 if (unformat (i, "socket %s", &file_name)) {
7862 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
7864 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
7866 else if (unformat (i, "server"))
7872 if (file_name_set == 0) {
7873 errmsg ("missing socket file name\n");
7877 if (vec_len (file_name) > 255) {
7878 errmsg ("socket file name too long\n");
7881 vec_add1 (file_name, 0);
7883 M(CREATE_VHOST_USER_IF, create_vhost_user_if);
7885 mp->is_server = is_server;
7886 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
7887 vec_free(file_name);
7888 if (custom_dev_instance != ~0) {
7890 mp->custom_dev_instance = ntohl(custom_dev_instance);
7892 mp->use_custom_mac = use_custom_mac;
7893 clib_memcpy(mp->mac_address, hwaddr, 6);
7900 static int api_modify_vhost_user_if (vat_main_t * vam)
7902 unformat_input_t * i = vam->input;
7903 vl_api_modify_vhost_user_if_t *mp;
7907 u8 file_name_set = 0;
7908 u32 custom_dev_instance = ~0;
7909 u8 sw_if_index_set = 0;
7910 u32 sw_if_index = (u32)~0;
7912 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7913 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7914 sw_if_index_set = 1;
7915 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7916 sw_if_index_set = 1;
7917 else if (unformat (i, "socket %s", &file_name)) {
7920 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
7922 else if (unformat (i, "server"))
7928 if (sw_if_index_set == 0) {
7929 errmsg ("missing sw_if_index or interface name\n");
7933 if (file_name_set == 0) {
7934 errmsg ("missing socket file name\n");
7938 if (vec_len (file_name) > 255) {
7939 errmsg ("socket file name too long\n");
7942 vec_add1 (file_name, 0);
7944 M(MODIFY_VHOST_USER_IF, modify_vhost_user_if);
7946 mp->sw_if_index = ntohl(sw_if_index);
7947 mp->is_server = is_server;
7948 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
7949 vec_free(file_name);
7950 if (custom_dev_instance != ~0) {
7952 mp->custom_dev_instance = ntohl(custom_dev_instance);
7960 static int api_delete_vhost_user_if (vat_main_t * vam)
7962 unformat_input_t * i = vam->input;
7963 vl_api_delete_vhost_user_if_t *mp;
7965 u32 sw_if_index = ~0;
7966 u8 sw_if_index_set = 0;
7968 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7969 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7970 sw_if_index_set = 1;
7971 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7972 sw_if_index_set = 1;
7977 if (sw_if_index_set == 0) {
7978 errmsg ("missing sw_if_index or interface name\n");
7983 M(DELETE_VHOST_USER_IF, delete_vhost_user_if);
7985 mp->sw_if_index = ntohl(sw_if_index);
7992 static void vl_api_sw_interface_vhost_user_details_t_handler
7993 (vl_api_sw_interface_vhost_user_details_t * mp)
7995 vat_main_t * vam = &vat_main;
7997 fformat(vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
7998 (char *)mp->interface_name,
7999 ntohl(mp->sw_if_index), ntohl(mp->virtio_net_hdr_sz),
8000 clib_net_to_host_u64(mp->features), mp->is_server,
8001 ntohl(mp->num_regions), (char *)mp->sock_filename);
8002 fformat(vam->ofp, " Status: '%s'\n", strerror(ntohl(mp->sock_errno)));
8005 static void vl_api_sw_interface_vhost_user_details_t_handler_json
8006 (vl_api_sw_interface_vhost_user_details_t * mp)
8008 vat_main_t * vam = &vat_main;
8009 vat_json_node_t *node = NULL;
8011 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8012 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8013 vat_json_init_array(&vam->json_tree);
8015 node = vat_json_array_add(&vam->json_tree);
8017 vat_json_init_object(node);
8018 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8019 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
8020 vat_json_object_add_uint(node, "virtio_net_hdr_sz", ntohl(mp->virtio_net_hdr_sz));
8021 vat_json_object_add_uint(node, "features", clib_net_to_host_u64(mp->features));
8022 vat_json_object_add_uint(node, "is_server", mp->is_server);
8023 vat_json_object_add_string_copy(node, "sock_filename", mp->sock_filename);
8024 vat_json_object_add_uint(node, "num_regions", ntohl(mp->num_regions));
8025 vat_json_object_add_uint(node, "sock_errno", ntohl(mp->sock_errno));
8028 static int api_sw_interface_vhost_user_dump (vat_main_t * vam)
8030 vl_api_sw_interface_vhost_user_dump_t *mp;
8032 fformat(vam->ofp, "Interface name idx hdr_sz features server regions filename\n");
8034 /* Get list of vhost-user interfaces */
8035 M(SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
8038 /* Use a control ping for synchronization */
8040 vl_api_control_ping_t * mp;
8041 M(CONTROL_PING, control_ping);
8047 static int api_show_version (vat_main_t * vam)
8049 vl_api_show_version_t *mp;
8052 M(SHOW_VERSION, show_version);
8060 static int api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
8062 unformat_input_t * line_input = vam->input;
8063 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
8065 ip4_address_t local4, remote4;
8066 ip6_address_t local6, remote6;
8068 u8 ipv4_set = 0, ipv6_set = 0;
8071 u32 encap_vrf_id = 0;
8072 u32 decap_vrf_id = 0;
8077 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8078 if (unformat (line_input, "del"))
8080 else if (unformat (line_input, "local %U",
8081 unformat_ip4_address, &local4))
8086 else if (unformat (line_input, "remote %U",
8087 unformat_ip4_address, &remote4))
8092 else if (unformat (line_input, "local %U",
8093 unformat_ip6_address, &local6))
8098 else if (unformat (line_input, "remote %U",
8099 unformat_ip6_address, &remote6))
8104 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
8106 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
8108 else if (unformat (line_input, "vni %d", &vni))
8110 else if (unformat(line_input, "next-ip4"))
8112 else if (unformat(line_input, "next-ip6"))
8114 else if (unformat(line_input, "next-ethernet"))
8116 else if (unformat(line_input, "next-nsh"))
8119 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
8124 if (local_set == 0) {
8125 errmsg ("tunnel local address not specified\n");
8128 if (remote_set == 0) {
8129 errmsg ("tunnel remote address not specified\n");
8132 if (ipv4_set && ipv6_set) {
8133 errmsg ("both IPv4 and IPv6 addresses specified");
8138 errmsg ("vni not specified\n");
8142 M(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
8146 clib_memcpy(&mp->local, &local6, sizeof(local6));
8147 clib_memcpy(&mp->remote, &remote6, sizeof(remote6));
8149 clib_memcpy(&mp->local, &local4, sizeof(local4));
8150 clib_memcpy(&mp->remote, &remote4, sizeof(remote4));
8153 mp->encap_vrf_id = ntohl(encap_vrf_id);
8154 mp->decap_vrf_id = ntohl(decap_vrf_id);
8155 mp->protocol = ntohl(protocol);
8156 mp->vni = ntohl(vni);
8157 mp->is_add = is_add;
8158 mp->is_ipv6 = ipv6_set;
8165 u8 * format_l2_fib_mac_address (u8 * s, va_list * args)
8167 u8 * a = va_arg (*args, u8 *);
8169 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
8170 a[2], a[3], a[4], a[5], a[6], a[7]);
8173 static void vl_api_l2_fib_table_entry_t_handler
8174 (vl_api_l2_fib_table_entry_t * mp)
8176 vat_main_t * vam = &vat_main;
8178 fformat(vam->ofp, "%3" PRIu32 " %U %3" PRIu32
8180 ntohl(mp->bd_id), format_l2_fib_mac_address, &mp->mac,
8181 ntohl(mp->sw_if_index), mp->static_mac, mp->filter_mac,
8185 static void vl_api_l2_fib_table_entry_t_handler_json
8186 (vl_api_l2_fib_table_entry_t * mp)
8188 vat_main_t * vam = &vat_main;
8189 vat_json_node_t *node = NULL;
8191 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8192 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8193 vat_json_init_array(&vam->json_tree);
8195 node = vat_json_array_add(&vam->json_tree);
8197 vat_json_init_object(node);
8198 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
8199 vat_json_object_add_uint(node, "mac", clib_net_to_host_u64(mp->mac));
8200 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8201 vat_json_object_add_uint(node, "static_mac", mp->static_mac);
8202 vat_json_object_add_uint(node, "filter_mac", mp->filter_mac);
8203 vat_json_object_add_uint(node, "bvi_mac", mp->bvi_mac);
8206 static int api_l2_fib_table_dump (vat_main_t * vam)
8208 unformat_input_t * i = vam->input;
8209 vl_api_l2_fib_table_dump_t *mp;
8214 /* Parse args required to build the message */
8215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8216 if (unformat (i, "bd_id %d", &bd_id))
8222 if (bd_id_set == 0) {
8223 errmsg ("missing bridge domain\n");
8227 fformat(vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI\n");
8229 /* Get list of l2 fib entries */
8230 M(L2_FIB_TABLE_DUMP, l2_fib_table_dump);
8232 mp->bd_id = ntohl(bd_id);
8235 /* Use a control ping for synchronization */
8237 vl_api_control_ping_t * mp;
8238 M(CONTROL_PING, control_ping);
8246 api_interface_name_renumber (vat_main_t * vam)
8248 unformat_input_t * line_input = vam->input;
8249 vl_api_interface_name_renumber_t *mp;
8250 u32 sw_if_index = ~0;
8252 u32 new_show_dev_instance = ~0;
8254 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8255 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
8258 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
8260 else if (unformat (line_input, "new_show_dev_instance %d",
8261 &new_show_dev_instance))
8267 if (sw_if_index == ~0) {
8268 errmsg ("missing interface name or sw_if_index\n");
8272 if (new_show_dev_instance == ~0) {
8273 errmsg ("missing new_show_dev_instance\n");
8277 M(INTERFACE_NAME_RENUMBER, interface_name_renumber);
8279 mp->sw_if_index = ntohl (sw_if_index);
8280 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
8286 api_want_ip4_arp_events (vat_main_t * vam)
8288 unformat_input_t * line_input = vam->input;
8289 vl_api_want_ip4_arp_events_t * mp;
8291 ip4_address_t address;
8292 int address_set = 0;
8293 u32 enable_disable = 1;
8295 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8296 if (unformat (line_input, "address %U",
8297 unformat_ip4_address, &address))
8299 else if (unformat (line_input, "del"))
8305 if (address_set == 0) {
8306 errmsg ("missing addresses\n");
8310 M(WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
8311 mp->enable_disable = enable_disable;
8313 mp->address = address.as_u32;
8318 static int api_input_acl_set_interface (vat_main_t * vam)
8320 unformat_input_t * i = vam->input;
8321 vl_api_input_acl_set_interface_t *mp;
8324 int sw_if_index_set;
8325 u32 ip4_table_index = ~0;
8326 u32 ip6_table_index = ~0;
8327 u32 l2_table_index = ~0;
8330 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8331 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8332 sw_if_index_set = 1;
8333 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8334 sw_if_index_set = 1;
8335 else if (unformat (i, "del"))
8337 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8339 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8341 else if (unformat (i, "l2-table %d", &l2_table_index))
8344 clib_warning ("parse error '%U'", format_unformat_error, i);
8349 if (sw_if_index_set == 0) {
8350 errmsg ("missing interface name or sw_if_index\n");
8354 M(INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
8356 mp->sw_if_index = ntohl(sw_if_index);
8357 mp->ip4_table_index = ntohl(ip4_table_index);
8358 mp->ip6_table_index = ntohl(ip6_table_index);
8359 mp->l2_table_index = ntohl(l2_table_index);
8360 mp->is_add = is_add;
8368 api_ip_address_dump (vat_main_t * vam)
8370 unformat_input_t * i = vam->input;
8371 vl_api_ip_address_dump_t * mp;
8372 u32 sw_if_index = ~0;
8373 u8 sw_if_index_set = 0;
8378 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8379 if (unformat (i, "sw_if_index %d", &sw_if_index))
8380 sw_if_index_set = 1;
8381 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8382 sw_if_index_set = 1;
8383 else if (unformat (i, "ipv4"))
8385 else if (unformat (i, "ipv6"))
8391 if (ipv4_set && ipv6_set) {
8392 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8396 if ((!ipv4_set) && (!ipv6_set)) {
8397 errmsg ("no ipv4 nor ipv6 flag set\n");
8401 if (sw_if_index_set == 0) {
8402 errmsg ("missing interface name or sw_if_index\n");
8406 vam->current_sw_if_index = sw_if_index;
8407 vam->is_ipv6 = ipv6_set;
8409 M(IP_ADDRESS_DUMP, ip_address_dump);
8410 mp->sw_if_index = ntohl(sw_if_index);
8411 mp->is_ipv6 = ipv6_set;
8414 /* Use a control ping for synchronization */
8416 vl_api_control_ping_t * mp;
8417 M(CONTROL_PING, control_ping);
8424 api_ip_dump (vat_main_t * vam)
8426 vl_api_ip_dump_t * mp;
8427 unformat_input_t * in = vam->input;
8434 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT) {
8435 if (unformat (in, "ipv4"))
8437 else if (unformat (in, "ipv6"))
8443 if (ipv4_set && ipv6_set) {
8444 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8448 if ((!ipv4_set) && (!ipv6_set)) {
8449 errmsg ("no ipv4 nor ipv6 flag set\n");
8454 vam->is_ipv6 = is_ipv6;
8457 for (i = 0; i < vec_len(vam->ip_details_by_sw_if_index[is_ipv6]); i++) {
8458 vec_free(vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
8460 vec_free(vam->ip_details_by_sw_if_index[is_ipv6]);
8462 M(IP_DUMP, ip_dump);
8463 mp->is_ipv6 = ipv6_set;
8466 /* Use a control ping for synchronization */
8468 vl_api_control_ping_t * mp;
8469 M(CONTROL_PING, control_ping);
8476 api_ipsec_spd_add_del (vat_main_t * vam)
8479 unformat_input_t * i = vam->input;
8480 vl_api_ipsec_spd_add_del_t *mp;
8485 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8486 if (unformat (i, "spd_id %d", &spd_id))
8488 else if (unformat (i, "del"))
8491 clib_warning ("parse error '%U'", format_unformat_error, i);
8496 errmsg ("spd_id must be set\n");
8500 M(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
8502 mp->spd_id = ntohl(spd_id);
8503 mp->is_add = is_add;
8509 clib_warning ("unsupported (no dpdk)");
8515 api_ipsec_interface_add_del_spd (vat_main_t * vam)
8518 unformat_input_t * i = vam->input;
8519 vl_api_ipsec_interface_add_del_spd_t *mp;
8522 u8 sw_if_index_set = 0;
8523 u32 spd_id = (u32) ~0;
8526 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8527 if (unformat (i, "del"))
8529 else if (unformat (i, "spd_id %d", &spd_id))
8531 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8532 sw_if_index_set = 1;
8533 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8534 sw_if_index_set = 1;
8536 clib_warning ("parse error '%U'", format_unformat_error, i);
8542 if (spd_id == (u32) ~0) {
8543 errmsg ("spd_id must be set\n");
8547 if (sw_if_index_set == 0) {
8548 errmsg ("missing interface name or sw_if_index\n");
8552 M(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
8554 mp->spd_id = ntohl(spd_id);
8555 mp->sw_if_index = ntohl (sw_if_index);
8556 mp->is_add = is_add;
8562 clib_warning ("unsupported (no dpdk)");
8568 api_ipsec_spd_add_del_entry (vat_main_t * vam)
8571 unformat_input_t * i = vam->input;
8572 vl_api_ipsec_spd_add_del_entry_t *mp;
8574 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
8575 u32 spd_id, sa_id, protocol = 0, policy = 0;
8577 u32 rport_start = 0, rport_stop = (u32) ~0;
8578 u32 lport_start = 0, lport_stop = (u32) ~0;
8579 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
8580 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
8582 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
8583 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~0;
8584 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
8585 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
8586 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~0;
8587 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~0;
8589 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8590 if (unformat (i, "del"))
8592 if (unformat (i, "outbound"))
8594 if (unformat (i, "inbound"))
8596 else if (unformat (i, "spd_id %d", &spd_id))
8598 else if (unformat (i, "sa_id %d", &sa_id))
8600 else if (unformat (i, "priority %d", &priority))
8602 else if (unformat (i, "protocol %d", &protocol))
8604 else if (unformat (i, "lport_start %d", &lport_start))
8606 else if (unformat (i, "lport_stop %d", &lport_stop))
8608 else if (unformat (i, "rport_start %d", &rport_start))
8610 else if (unformat (i, "rport_stop %d", &rport_stop))
8612 else if (unformat (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
8617 else if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
8622 else if (unformat (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
8627 else if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
8632 else if (unformat (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
8637 else if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
8642 else if (unformat (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
8647 else if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
8652 else if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
8654 if (policy == IPSEC_POLICY_ACTION_RESOLVE) {
8655 clib_warning ("unsupported action: 'resolve'");
8660 clib_warning ("parse error '%U'", format_unformat_error, i);
8666 M(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
8668 mp->spd_id = ntohl(spd_id);
8669 mp->priority = ntohl(priority);
8670 mp->is_outbound = is_outbound;
8672 mp->is_ipv6 = is_ipv6;
8673 if (is_ipv6 || is_ip_any) {
8674 clib_memcpy (mp->remote_address_start, &raddr6_start, sizeof(ip6_address_t));
8675 clib_memcpy (mp->remote_address_stop, &raddr6_stop, sizeof(ip6_address_t));
8676 clib_memcpy (mp->local_address_start, &laddr6_start, sizeof(ip6_address_t));
8677 clib_memcpy (mp->local_address_stop, &laddr6_stop, sizeof(ip6_address_t));
8679 clib_memcpy (mp->remote_address_start, &raddr4_start, sizeof(ip4_address_t));
8680 clib_memcpy (mp->remote_address_stop, &raddr4_stop, sizeof(ip4_address_t));
8681 clib_memcpy (mp->local_address_start, &laddr4_start, sizeof(ip4_address_t));
8682 clib_memcpy (mp->local_address_stop, &laddr4_stop, sizeof(ip4_address_t));
8684 mp->protocol = (u8) protocol;
8685 mp->local_port_start = ntohs((u16) lport_start);
8686 mp->local_port_stop = ntohs((u16) lport_stop);
8687 mp->remote_port_start = ntohs((u16) rport_start);
8688 mp->remote_port_stop = ntohs((u16) rport_stop);
8689 mp->policy = (u8) policy;
8690 mp->sa_id = ntohl(sa_id);
8691 mp->is_add = is_add;
8692 mp->is_ip_any = is_ip_any;
8697 clib_warning ("unsupported (no dpdk)");
8703 api_ipsec_sad_add_del_entry (vat_main_t * vam)
8706 unformat_input_t * i = vam->input;
8707 vl_api_ipsec_sad_add_del_entry_t *mp;
8713 u8 protocol = IPSEC_PROTOCOL_AH;
8714 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
8715 u32 crypto_alg = 0, integ_alg = 0;
8716 ip4_address_t tun_src4;
8717 ip4_address_t tun_dst4;
8718 ip6_address_t tun_src6;
8719 ip6_address_t tun_dst6;
8721 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8722 if (unformat (i, "del"))
8724 else if (unformat (i, "sad_id %d", &sad_id))
8726 else if (unformat (i, "spi %d", &spi))
8728 else if (unformat (i, "esp"))
8729 protocol = IPSEC_PROTOCOL_ESP;
8730 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4)) {
8734 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4)) {
8738 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6)) {
8742 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6)) {
8746 else if (unformat (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg)) {
8747 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
8748 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256) {
8749 clib_warning ("unsupported crypto-alg: '%U'",
8750 format_ipsec_crypto_alg, crypto_alg);
8754 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
8756 else if (unformat (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg)) {
8757 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
8758 integ_alg > IPSEC_INTEG_ALG_SHA_512_256) {
8759 clib_warning ("unsupported integ-alg: '%U'",
8760 format_ipsec_integ_alg, integ_alg);
8764 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
8767 clib_warning ("parse error '%U'", format_unformat_error, i);
8773 M(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
8775 mp->sad_id = ntohl(sad_id);
8776 mp->is_add = is_add;
8777 mp->protocol = protocol;
8778 mp->spi = ntohl(spi);
8779 mp->is_tunnel = is_tunnel;
8780 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
8781 mp->crypto_algorithm = crypto_alg;
8782 mp->integrity_algorithm = integ_alg;
8783 mp->crypto_key_length = vec_len(ck);
8784 mp->integrity_key_length = vec_len(ik);
8786 if (mp->crypto_key_length > sizeof(mp->crypto_key))
8787 mp->crypto_key_length = sizeof(mp->crypto_key);
8789 if (mp->integrity_key_length > sizeof(mp->integrity_key))
8790 mp->integrity_key_length = sizeof(mp->integrity_key);
8792 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
8793 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
8796 if (is_tunnel_ipv6) {
8797 clib_memcpy (mp->tunnel_src_address, &tun_src6, sizeof(ip6_address_t));
8798 clib_memcpy (mp->tunnel_dst_address, &tun_dst6, sizeof(ip6_address_t));
8800 clib_memcpy (mp->tunnel_src_address, &tun_src4, sizeof(ip4_address_t));
8801 clib_memcpy (mp->tunnel_dst_address, &tun_dst4, sizeof(ip4_address_t));
8809 clib_warning ("unsupported (no dpdk)");
8815 api_ipsec_sa_set_key (vat_main_t * vam)
8818 unformat_input_t * i = vam->input;
8819 vl_api_ipsec_sa_set_key_t *mp;
8824 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8825 if (unformat (i, "sa_id %d", &sa_id))
8827 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
8829 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
8832 clib_warning ("parse error '%U'", format_unformat_error, i);
8837 M(IPSEC_SA_SET_KEY, ipsec_set_sa_key);
8839 mp->sa_id = ntohl(sa_id);
8840 mp->crypto_key_length = vec_len(ck);
8841 mp->integrity_key_length = vec_len(ik);
8843 if (mp->crypto_key_length > sizeof(mp->crypto_key))
8844 mp->crypto_key_length = sizeof(mp->crypto_key);
8846 if (mp->integrity_key_length > sizeof(mp->integrity_key))
8847 mp->integrity_key_length = sizeof(mp->integrity_key);
8849 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
8850 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
8856 clib_warning ("unsupported (no dpdk)");
8862 api_ikev2_profile_add_del (vat_main_t * vam)
8865 unformat_input_t * i = vam->input;
8866 vl_api_ikev2_profile_add_del_t * mp;
8871 const char * valid_chars = "a-zA-Z0-9_";
8873 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8874 if (unformat (i, "del"))
8876 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8879 errmsg ("parse error '%U'", format_unformat_error, i);
8884 if (!vec_len (name)) {
8885 errmsg ("profile name must be specified");
8889 if (vec_len (name) > 64) {
8890 errmsg ("profile name too long");
8894 M(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
8896 clib_memcpy(mp->name, name, vec_len (name));
8897 mp->is_add = is_add;
8904 clib_warning ("unsupported (no dpdk)");
8910 api_ikev2_profile_set_auth (vat_main_t * vam)
8913 unformat_input_t * i = vam->input;
8914 vl_api_ikev2_profile_set_auth_t * mp;
8918 u32 auth_method = 0;
8921 const char * valid_chars = "a-zA-Z0-9_";
8923 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8924 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8926 else if (unformat (i, "auth_method %U",
8927 unformat_ikev2_auth_method, &auth_method))
8929 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
8931 else if (unformat (i, "auth_data %v", &data))
8934 errmsg ("parse error '%U'", format_unformat_error, i);
8939 if (!vec_len (name)) {
8940 errmsg ("profile name must be specified");
8944 if (vec_len (name) > 64) {
8945 errmsg ("profile name too long");
8949 if (!vec_len(data)) {
8950 errmsg ("auth_data must be specified");
8955 errmsg ("auth_method must be specified");
8959 M(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
8961 mp->is_hex = is_hex;
8962 mp->auth_method = (u8) auth_method;
8963 mp->data_len = vec_len (data);
8964 clib_memcpy (mp->name, name, vec_len (name));
8965 clib_memcpy (mp->data, data, vec_len (data));
8973 clib_warning ("unsupported (no dpdk)");
8979 api_ikev2_profile_set_id (vat_main_t * vam)
8982 unformat_input_t * i = vam->input;
8983 vl_api_ikev2_profile_set_id_t * mp;
8991 const char * valid_chars = "a-zA-Z0-9_";
8993 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8994 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8996 else if (unformat (i, "id_type %U",
8997 unformat_ikev2_id_type, &id_type))
8999 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
9001 data = vec_new(u8, 4);
9002 clib_memcpy(data, ip4.as_u8, 4);
9004 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
9006 else if (unformat (i, "id_data %v", &data))
9008 else if (unformat (i, "local"))
9010 else if (unformat (i, "remote"))
9013 errmsg ("parse error '%U'", format_unformat_error, i);
9018 if (!vec_len (name)) {
9019 errmsg ("profile name must be specified");
9023 if (vec_len (name) > 64) {
9024 errmsg ("profile name too long");
9028 if (!vec_len(data)) {
9029 errmsg ("id_data must be specified");
9034 errmsg ("id_type must be specified");
9038 M(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
9040 mp->is_local = is_local;
9041 mp->id_type = (u8) id_type;
9042 mp->data_len = vec_len (data);
9043 clib_memcpy (mp->name, name, vec_len (name));
9044 clib_memcpy (mp->data, data, vec_len (data));
9052 clib_warning ("unsupported (no dpdk)");
9058 api_ikev2_profile_set_ts (vat_main_t * vam)
9061 unformat_input_t * i = vam->input;
9062 vl_api_ikev2_profile_set_ts_t * mp;
9066 u32 proto = 0, start_port = 0, end_port = (u32) ~0;
9067 ip4_address_t start_addr, end_addr;
9069 const char * valid_chars = "a-zA-Z0-9_";
9071 start_addr.as_u32 = 0;
9072 end_addr.as_u32 = (u32) ~0;
9074 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9075 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9077 else if (unformat (i, "protocol %d", &proto))
9079 else if (unformat (i, "start_port %d", &start_port))
9081 else if (unformat (i, "end_port %d", &end_port))
9083 else if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
9085 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
9087 else if (unformat (i, "local"))
9089 else if (unformat (i, "remote"))
9092 errmsg ("parse error '%U'", format_unformat_error, i);
9097 if (!vec_len (name)) {
9098 errmsg ("profile name must be specified");
9102 if (vec_len (name) > 64) {
9103 errmsg ("profile name too long");
9107 M(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
9109 mp->is_local = is_local;
9110 mp->proto = (u8) proto;
9111 mp->start_port = (u16) start_port;
9112 mp->end_port = (u16) end_port;
9113 mp->start_addr = start_addr.as_u32;
9114 mp->end_addr = end_addr.as_u32;
9115 clib_memcpy (mp->name, name, vec_len (name));
9122 clib_warning ("unsupported (no dpdk)");
9128 api_ikev2_set_local_key (vat_main_t * vam)
9131 unformat_input_t * i = vam->input;
9132 vl_api_ikev2_set_local_key_t * mp;
9136 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9137 if (unformat (i, "file %v", &file))
9140 errmsg ("parse error '%U'", format_unformat_error, i);
9145 if (!vec_len (file)) {
9146 errmsg ("RSA key file must be specified");
9150 if (vec_len (file) > 256) {
9151 errmsg ("file name too long");
9155 M(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
9157 clib_memcpy (mp->key_file, file, vec_len (file));
9164 clib_warning ("unsupported (no dpdk)");
9172 static int api_map_add_domain (vat_main_t * vam)
9174 unformat_input_t *i = vam->input;
9175 vl_api_map_add_domain_t *mp;
9178 ip4_address_t ip4_prefix;
9179 ip6_address_t ip6_prefix;
9180 ip6_address_t ip6_src;
9182 u32 ip6_prefix_len, ip4_prefix_len, ea_bits_len, psid_offset,
9184 u8 is_translation = 0;
9186 u8 ip6_src_len = 128;
9188 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9189 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
9190 &ip4_prefix, &ip4_prefix_len))
9192 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
9193 &ip6_prefix, &ip6_prefix_len))
9195 else if (unformat (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src, &ip6_src_len))
9197 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
9199 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
9201 else if (unformat (i, "psid-offset %d", &psid_offset))
9203 else if (unformat (i, "psid-len %d", &psid_length))
9205 else if (unformat (i, "mtu %d", &mtu))
9207 else if (unformat (i, "map-t"))
9210 clib_warning ("parse error '%U'", format_unformat_error, i);
9215 if (num_m_args != 6) {
9216 errmsg("mandatory argument(s) missing\n");
9220 /* Construct the API message */
9221 M(MAP_ADD_DOMAIN, map_add_domain);
9223 clib_memcpy(mp->ip4_prefix, &ip4_prefix, sizeof(ip4_prefix));
9224 mp->ip4_prefix_len = ip4_prefix_len;
9226 clib_memcpy(mp->ip6_prefix, &ip6_prefix, sizeof(ip6_prefix));
9227 mp->ip6_prefix_len = ip6_prefix_len;
9229 clib_memcpy(mp->ip6_src, &ip6_src, sizeof(ip6_src));
9230 mp->ip6_src_prefix_len = ip6_src_len;
9232 mp->ea_bits_len = ea_bits_len;
9233 mp->psid_offset = psid_offset;
9234 mp->psid_length = psid_length;
9235 mp->is_translation = is_translation;
9236 mp->mtu = htons(mtu);
9241 /* Wait for a reply, return good/bad news */
9245 static int api_map_del_domain (vat_main_t * vam)
9247 unformat_input_t *i = vam->input;
9248 vl_api_map_del_domain_t *mp;
9254 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9255 if (unformat (i, "index %d", &index))
9258 clib_warning ("parse error '%U'", format_unformat_error, i);
9263 if (num_m_args != 1) {
9264 errmsg("mandatory argument(s) missing\n");
9268 /* Construct the API message */
9269 M(MAP_DEL_DOMAIN, map_del_domain);
9271 mp->index = ntohl(index);
9276 /* Wait for a reply, return good/bad news */
9280 static int api_map_add_del_rule (vat_main_t * vam)
9282 unformat_input_t *i = vam->input;
9283 vl_api_map_add_del_rule_t *mp;
9286 ip6_address_t ip6_dst;
9287 u32 num_m_args = 0, index, psid;
9289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9290 if (unformat (i, "index %d", &index))
9292 else if (unformat (i, "psid %d", &psid))
9294 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
9296 else if (unformat (i, "del")) {
9299 clib_warning ("parse error '%U'", format_unformat_error, i);
9304 /* Construct the API message */
9305 M(MAP_ADD_DEL_RULE, map_add_del_rule);
9307 mp->index = ntohl(index);
9308 mp->is_add = is_add;
9309 clib_memcpy(mp->ip6_dst, &ip6_dst, sizeof(ip6_dst));
9310 mp->psid = ntohs(psid);
9315 /* Wait for a reply, return good/bad news */
9319 static int api_map_domain_dump (vat_main_t * vam)
9321 vl_api_map_domain_dump_t *mp;
9324 /* Construct the API message */
9325 M(MAP_DOMAIN_DUMP, map_domain_dump);
9330 /* Use a control ping for synchronization */
9332 vl_api_control_ping_t * mp;
9333 M(CONTROL_PING, control_ping);
9339 static int api_map_rule_dump (vat_main_t * vam)
9341 unformat_input_t *i = vam->input;
9342 vl_api_map_rule_dump_t *mp;
9344 u32 domain_index = ~0;
9346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9347 if (unformat (i, "index %u", &domain_index))
9353 if (domain_index == ~0) {
9354 clib_warning("parse error: domain index expected");
9358 /* Construct the API message */
9359 M(MAP_RULE_DUMP, map_rule_dump);
9361 mp->domain_index = htonl(domain_index);
9366 /* Use a control ping for synchronization */
9368 vl_api_control_ping_t * mp;
9369 M(CONTROL_PING, control_ping);
9375 static void vl_api_map_add_domain_reply_t_handler
9376 (vl_api_map_add_domain_reply_t * mp)
9378 vat_main_t * vam = &vat_main;
9379 i32 retval = ntohl(mp->retval);
9381 if (vam->async_mode) {
9382 vam->async_errors += (retval < 0);
9384 vam->retval = retval;
9385 vam->result_ready = 1;
9389 static void vl_api_map_add_domain_reply_t_handler_json
9390 (vl_api_map_add_domain_reply_t * mp)
9392 vat_main_t * vam = &vat_main;
9393 vat_json_node_t node;
9395 vat_json_init_object(&node);
9396 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
9397 vat_json_object_add_uint(&node, "index", ntohl(mp->index));
9399 vat_json_print(vam->ofp, &node);
9400 vat_json_free(&node);
9402 vam->retval = ntohl(mp->retval);
9403 vam->result_ready = 1;
9407 api_get_first_msg_id (vat_main_t * vam)
9409 vl_api_get_first_msg_id_t * mp;
9411 unformat_input_t * i = vam->input;
9415 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9416 if (unformat (i, "client %s", &name))
9422 if (name_set == 0) {
9423 errmsg ("missing client name\n");
9428 if (vec_len (name) > 63) {
9429 errmsg ("client name too long\n");
9433 M(GET_FIRST_MSG_ID, get_first_msg_id);
9434 clib_memcpy (mp->name, name, vec_len(name));
9440 static int api_cop_interface_enable_disable (vat_main_t * vam)
9442 unformat_input_t * line_input = vam->input;
9443 vl_api_cop_interface_enable_disable_t * mp;
9445 u32 sw_if_index = ~0;
9446 u8 enable_disable = 1;
9448 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9449 if (unformat (line_input, "disable"))
9451 if (unformat (line_input, "enable"))
9453 else if (unformat (line_input, "%U", unformat_sw_if_index,
9456 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9462 if (sw_if_index == ~0) {
9463 errmsg ("missing interface name or sw_if_index\n");
9467 /* Construct the API message */
9468 M(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
9469 mp->sw_if_index = ntohl(sw_if_index);
9470 mp->enable_disable = enable_disable;
9474 /* Wait for the reply */
9478 static int api_cop_whitelist_enable_disable (vat_main_t * vam)
9480 unformat_input_t * line_input = vam->input;
9481 vl_api_cop_whitelist_enable_disable_t * mp;
9483 u32 sw_if_index = ~0;
9484 u8 ip4=0, ip6=0, default_cop=0;
9487 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9488 if (unformat (line_input, "ip4"))
9490 else if (unformat (line_input, "ip6"))
9492 else if (unformat (line_input, "default"))
9494 else if (unformat (line_input, "%U", unformat_sw_if_index,
9497 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9499 else if (unformat (line_input, "fib-id %d", &fib_id))
9505 if (sw_if_index == ~0) {
9506 errmsg ("missing interface name or sw_if_index\n");
9510 /* Construct the API message */
9511 M(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
9512 mp->sw_if_index = ntohl(sw_if_index);
9513 mp->fib_id = ntohl(fib_id);
9516 mp->default_cop = default_cop;
9520 /* Wait for the reply */
9524 static int api_get_node_graph (vat_main_t * vam)
9526 vl_api_get_node_graph_t * mp;
9529 M(GET_NODE_GRAPH, get_node_graph);
9533 /* Wait for the reply */
9538 api_lisp_add_del_locator_set(vat_main_t * vam)
9540 unformat_input_t * input = vam->input;
9541 vl_api_lisp_add_del_locator_set_t *mp;
9544 u8 *locator_set_name = NULL;
9545 u8 locator_set_name_set = 0;
9547 /* Parse args required to build the message */
9548 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9549 if (unformat(input, "del")) {
9551 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9552 locator_set_name_set = 1;
9557 if (locator_set_name_set == 0) {
9558 errmsg ("missing locator-set name");
9562 if (vec_len(locator_set_name) > 64) {
9563 errmsg ("locator-set name too long\n");
9564 vec_free(locator_set_name);
9567 vec_add1(locator_set_name, 0);
9569 /* Construct the API message */
9570 M(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
9572 mp->is_add = is_add;
9573 clib_memcpy(mp->locator_set_name, locator_set_name,
9574 vec_len(locator_set_name));
9575 vec_free(locator_set_name);
9580 /* Wait for a reply... */
9588 api_lisp_add_del_locator(vat_main_t * vam)
9590 unformat_input_t * input = vam->input;
9591 vl_api_lisp_add_del_locator_t *mp;
9593 u32 tmp_if_index = ~0;
9594 u32 sw_if_index = ~0;
9595 u8 sw_if_index_set = 0;
9596 u8 sw_if_index_if_name_set = 0;
9598 u8 priority_set = 0;
9602 u8 *locator_set_name = NULL;
9603 u8 locator_set_name_set = 0;
9605 /* Parse args required to build the message */
9606 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9607 if (unformat(input, "del")) {
9609 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9610 locator_set_name_set = 1;
9611 } else if (unformat(input, "iface %U", unformat_sw_if_index, vam,
9613 sw_if_index_if_name_set = 1;
9614 sw_if_index = tmp_if_index;
9615 } else if (unformat(input,"sw_if_index %d", &tmp_if_index)) {
9616 sw_if_index_set = 1;
9617 sw_if_index = tmp_if_index;
9618 } else if (unformat(input, "p %d", &priority)) {
9620 } else if (unformat(input, "w %d", &weight)) {
9626 if (locator_set_name_set == 0) {
9627 errmsg ("missing locator-set name");
9631 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0) {
9632 errmsg ("missing sw_if_index");
9633 vec_free(locator_set_name);
9637 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0) {
9638 errmsg ("cannot use both params interface name and sw_if_index");
9639 vec_free(locator_set_name);
9643 if (priority_set == 0) {
9644 errmsg ("missing locator-set priority\n");
9645 vec_free(locator_set_name);
9649 if (weight_set == 0) {
9650 errmsg ("missing locator-set weight\n");
9651 vec_free(locator_set_name);
9655 if (vec_len(locator_set_name) > 64) {
9656 errmsg ("locator-set name too long\n");
9657 vec_free(locator_set_name);
9660 vec_add1(locator_set_name, 0);
9662 /* Construct the API message */
9663 M(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
9665 mp->is_add = is_add;
9666 mp->sw_if_index = ntohl(sw_if_index);
9667 mp->priority = priority;
9668 mp->weight = weight;
9669 clib_memcpy(mp->locator_set_name, locator_set_name,
9670 vec_len(locator_set_name));
9671 vec_free(locator_set_name);
9676 /* Wait for a reply... */
9684 api_lisp_add_del_local_eid(vat_main_t * vam)
9686 unformat_input_t * input = vam->input;
9687 vl_api_lisp_add_del_local_eid_t *mp;
9692 ip4_address_t eidv4;
9693 ip6_address_t eidv6;
9694 u8 tmp_eid_lenght = ~0;
9696 u8 *locator_set_name = NULL;
9697 u8 locator_set_name_set = 0;
9699 /* Parse args required to build the message */
9700 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9701 if (unformat(input, "del")) {
9703 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
9704 &eidv4, &tmp_eid_lenght)) {
9705 eid_lenght = tmp_eid_lenght;
9707 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
9708 &eidv6, &tmp_eid_lenght)) {
9709 eid_lenght = tmp_eid_lenght;
9711 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9712 locator_set_name_set = 1;
9717 if (locator_set_name_set == 0) {
9718 errmsg ("missing locator-set name\n");
9722 if (vec_len(locator_set_name) > 64) {
9723 errmsg ("locator-set name too long\n");
9724 vec_free(locator_set_name);
9727 vec_add1(locator_set_name, 0);
9729 if (eidv4_set && eidv6_set) {
9730 errmsg ("both eid v4 and v6 addresses set\n");
9731 vec_free(locator_set_name);
9735 if (!eidv4_set && !eidv6_set) {
9736 errmsg ("eid addresses not set\n");
9737 vec_free(locator_set_name);
9741 if (eidv4_set && eid_lenght > 32) {
9742 errmsg ("eid prefix to big\n");
9743 vec_free(locator_set_name);
9747 if (eidv6_set && eid_lenght > 128) {
9748 errmsg ("eid prefix to big\n");
9749 vec_free(locator_set_name);
9753 /* Construct the API message */
9754 M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
9756 mp->is_add = is_add;
9759 clib_memcpy(mp->ip_address, &eidv6, sizeof(eidv6));
9762 clib_memcpy(mp->ip_address, &eidv4, sizeof(eidv4));
9764 mp->prefix_len = eid_lenght;
9765 clib_memcpy(mp->locator_set_name, locator_set_name,
9766 vec_len(locator_set_name));
9767 vec_free(locator_set_name);
9772 /* Wait for a reply... */
9780 api_lisp_gpe_add_del_fwd_entry(vat_main_t * vam)
9782 unformat_input_t * input = vam->input;
9783 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
9786 u8 eidv4_set = 0, slocv4_set = 0, dlocv4_set = 0;
9787 u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0;
9788 ip4_address_t eidv4, slocv4, dlocv4;
9789 ip6_address_t eidv6, slocv6, dlocv6;
9790 u8 tmp_eid_lenght = ~0;
9793 /* Parse args required to build the message */
9794 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9795 if (unformat(input, "del")) {
9797 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
9798 &eidv4, &tmp_eid_lenght)) {
9799 eid_lenght = tmp_eid_lenght;
9801 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
9802 &eidv6, &tmp_eid_lenght)) {
9803 eid_lenght = tmp_eid_lenght;
9805 } else if (unformat(input, "sloc %U", unformat_ip4_address, &slocv4)) {
9807 } else if (unformat(input, "sloc %U", unformat_ip6_address, &slocv6)) {
9809 } else if (unformat(input, "dloc %U", unformat_ip4_address, &dlocv4)) {
9811 } else if (unformat(input, "dloc %U", unformat_ip6_address, &dlocv6)) {
9817 if (eidv4_set && eidv6_set) {
9818 errmsg ("both eid v4 and v6 addresses set\n");
9822 if (!eidv4_set && !eidv6_set) {
9823 errmsg ("eid addresses not set\n");
9827 if (slocv4_set && slocv6_set) {
9828 errmsg ("both source v4 and v6 addresses set\n");
9832 if (!slocv4_set && !slocv6_set) {
9833 errmsg ("source addresses not set\n");
9837 if (dlocv4_set && dlocv6_set) {
9838 errmsg ("both destination v4 and v6 addresses set\n");
9842 if (dlocv4_set && dlocv6_set) {
9843 errmsg ("destination addresses not set\n");
9847 if (!(slocv4_set == dlocv4_set && slocv6_set == dlocv6_set)) {
9848 errmsg ("mixing type of source and destination address\n");
9852 /* Construct the API message */
9853 M(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
9855 mp->is_add = is_add;
9857 mp->eid_is_ipv6 = 1;
9858 clib_memcpy(mp->eid_ip_address, &eidv6, sizeof(eidv6));
9860 mp->eid_is_ipv6 = 0;
9861 clib_memcpy(mp->eid_ip_address, &eidv4, sizeof(eidv4));
9863 mp->eid_prefix_len = eid_lenght;
9865 mp->address_is_ipv6 = 1;
9866 clib_memcpy(mp->source_ip_address, &slocv6, sizeof(slocv6));
9867 clib_memcpy(mp->destination_ip_address, &dlocv6, sizeof(dlocv6));
9869 mp->address_is_ipv6 = 0;
9870 clib_memcpy(mp->source_ip_address, &slocv4, sizeof(slocv4));
9871 clib_memcpy(mp->destination_ip_address, &dlocv4, sizeof(dlocv4));
9877 /* Wait for a reply... */
9885 api_lisp_add_del_map_resolver(vat_main_t * vam)
9887 unformat_input_t * input = vam->input;
9888 vl_api_lisp_add_del_map_resolver_t *mp;
9896 /* Parse args required to build the message */
9897 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9898 if (unformat(input, "del")) {
9900 } else if (unformat(input, "%U", unformat_ip4_address, &ipv4)) {
9902 } else if (unformat(input, "%U", unformat_ip6_address, &ipv6)) {
9908 if (ipv4_set && ipv6_set) {
9909 errmsg ("both eid v4 and v6 addresses set\n");
9913 if (!ipv4_set && !ipv6_set) {
9914 errmsg ("eid addresses not set\n");
9918 /* Construct the API message */
9919 M(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
9921 mp->is_add = is_add;
9924 clib_memcpy(mp->ip_address, &ipv6, sizeof(ipv6));
9927 clib_memcpy(mp->ip_address, &ipv4, sizeof(ipv4));
9933 /* Wait for a reply... */
9941 api_lisp_gpe_enable_disable (vat_main_t * vam)
9943 unformat_input_t * input = vam->input;
9944 vl_api_lisp_gpe_enable_disable_t *mp;
9949 /* Parse args required to build the message */
9950 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9951 if (unformat(input, "enable")) {
9954 } else if (unformat(input, "disable")) {
9962 errmsg("Value not set\n");
9966 /* Construct the API message */
9967 M(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
9974 /* Wait for a reply... */
9982 api_lisp_enable_disable (vat_main_t * vam)
9984 unformat_input_t * input = vam->input;
9985 vl_api_lisp_enable_disable_t *mp;
9990 /* Parse args required to build the message */
9991 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9993 if (unformat (input, "enable"))
9998 else if (unformat (input, "disable"))
10008 errmsg ("Value not set\n");
10012 /* Construct the API message */
10013 M(LISP_ENABLE_DISABLE, lisp_enable_disable);
10020 /* Wait for a reply... */
10027 /** Used for transferring locators via VPP API */
10028 typedef CLIB_PACKED(struct
10030 u8 is_ip4; /**< is locator an IPv4 address? */
10031 u8 addr[16]; /**< IPv4/IPv6 address */
10035 * Enable/disable LISP proxy ITR.
10037 * @param vam vpp API test context
10038 * @return return code
10041 api_lisp_pitr_set_locator_set (vat_main_t * vam)
10044 u8 ls_name_set = 0;
10045 unformat_input_t * input = vam->input;
10046 vl_api_lisp_pitr_set_locator_set_t * mp;
10050 /* Parse args required to build the message */
10051 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
10053 if (unformat (input, "del"))
10055 else if (unformat (input, "locator-set %s", &ls_name))
10059 errmsg ("parse error '%U'", format_unformat_error, input);
10066 errmsg ("locator-set name not set!");
10070 M(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set);
10072 mp->is_add = is_add;
10073 clib_memcpy (mp->ls_name, ls_name, vec_len (ls_name));
10074 vec_free (ls_name);
10079 /* wait for reply */
10087 * Add/del remote mapping from LISP control plane and updates
10088 * forwarding entries in data-plane accordingly.
10090 * @param vam vpp API test context
10091 * @return return code
10094 api_lisp_add_del_remote_mapping (vat_main_t * vam)
10096 unformat_input_t * input = vam->input;
10097 vl_api_lisp_add_del_remote_mapping_t *mp;
10100 u8 seid_set = 0, deid_set = 0;
10101 ip4_address_t seid4, deid4, rloc4;
10102 ip6_address_t seid6, deid6, rloc6;
10103 u32 seid_len = 0, deid_len = 0, len;
10104 u8 deid_is_ip4 = 0, seid_is_ip4 = 0;
10107 rloc_t * rlocs = 0, rloc;
10109 /* Parse args required to build the message */
10110 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10111 if (unformat(input, "del")) {
10113 } else if (unformat(input, "add")) {
10115 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10120 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10125 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10130 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10135 } else if (unformat(input, "vni %d", &vni)) {
10137 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10139 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10140 vec_add1 (rlocs, rloc);
10141 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10143 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10144 vec_add1 (rlocs, rloc);
10145 } else if (unformat(input, "action %d", &action)) {
10148 clib_warning ("parse error '%U'", format_unformat_error, input);
10153 if (!seid_set || !deid_set) {
10154 errmsg ("missing params!");
10158 if (seid_is_ip4 != deid_is_ip4) {
10159 errmsg ("source and destination EIDs are not in " "same IP family!");
10163 if (is_add && (~0 == action)
10164 && 0 == vec_len (rlocs)) {
10165 errmsg ("no action set for negative map-reply!");
10169 M(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
10170 mp->is_add = is_add;
10171 mp->vni = htonl (vni);
10172 mp->seid_len = seid_len;
10173 mp->action = (u8) action;
10174 mp->deid_len = deid_len;
10176 mp->eid_is_ip4 = 1;
10177 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10179 mp->eid_is_ip4 = 0;
10180 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10184 mp->eid_is_ip4 = 1;
10185 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10187 mp->eid_is_ip4 = 0;
10188 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10191 mp->rloc_num = vec_len (rlocs);
10192 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10198 /* Wait for a reply... */
10206 api_lisp_gpe_add_del_iface(vat_main_t * vam)
10208 unformat_input_t * input = vam->input;
10209 vl_api_lisp_gpe_add_del_iface_t *mp;
10215 /* Parse args required to build the message */
10216 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10217 if (unformat(input, "up")) {
10220 } else if (unformat(input, "down")) {
10223 } else if (unformat(input, "table_id %d", &table_id)) {
10225 } else if (unformat(input, "vni %d", &vni)) {
10232 errmsg("Value not set\n");
10236 /* Construct the API message */
10237 M(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
10239 mp->is_add = is_add;
10240 mp->table_id = table_id;
10246 /* Wait for a reply... */
10254 api_lisp_locator_set_dump(vat_main_t *vam)
10256 vl_api_lisp_locator_set_dump_t *mp;
10259 if (!vam->json_output) {
10260 fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n",
10261 "Locator-set", "Locator", "Priority", "Weight");
10264 M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
10268 /* Use a control ping for synchronization */
10270 vl_api_control_ping_t * mp;
10271 M(CONTROL_PING, control_ping);
10274 /* Wait for a reply... */
10282 api_lisp_local_eid_table_dump(vat_main_t *vam)
10284 vl_api_lisp_local_eid_table_dump_t *mp;
10287 if (!vam->json_output) {
10288 fformat(vam->ofp, "%=20s%=30s\n",
10289 "Locator-set", "Eid");
10292 M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
10296 /* Use a control ping for synchronization */
10298 vl_api_control_ping_t * mp;
10299 M(CONTROL_PING, control_ping);
10302 /* Wait for a reply... */
10310 api_lisp_gpe_tunnel_dump(vat_main_t *vam)
10312 vl_api_lisp_gpe_tunnel_dump_t *mp;
10315 if (!vam->json_output) {
10316 fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
10317 "%=16s%=16s%=16s%=16s%=16s\n",
10318 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
10319 "Decap next", "Lisp version", "Flags", "Next protocol",
10320 "ver_res", "res", "iid");
10323 M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
10327 /* Use a control ping for synchronization */
10329 vl_api_control_ping_t * mp;
10330 M(CONTROL_PING, control_ping);
10333 /* Wait for a reply... */
10341 api_lisp_map_resolver_dump(vat_main_t *vam)
10343 vl_api_lisp_map_resolver_dump_t *mp;
10346 if (!vam->json_output) {
10347 fformat(vam->ofp, "%=20s\n",
10351 M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
10355 /* Use a control ping for synchronization */
10357 vl_api_control_ping_t * mp;
10358 M(CONTROL_PING, control_ping);
10361 /* Wait for a reply... */
10369 api_lisp_enable_disable_status_dump(vat_main_t *vam)
10371 vl_api_lisp_enable_disable_status_dump_t *mp;
10374 if (!vam->json_output) {
10375 fformat(vam->ofp, "%=20s\n",
10379 M(LISP_ENABLE_DISABLE_STATUS_DUMP,
10380 lisp_enable_disable_status_dump);
10384 /* Use a control ping for synchronization */
10386 vl_api_control_ping_t * mp;
10387 M(CONTROL_PING, control_ping);
10390 /* Wait for a reply... */
10398 api_af_packet_create (vat_main_t * vam)
10400 unformat_input_t * i = vam->input;
10401 vl_api_af_packet_create_t * mp;
10403 u8 * host_if_name = 0;
10405 u8 random_hw_addr = 1;
10407 memset (hw_addr, 0, sizeof (hw_addr));
10409 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10410 if (unformat (i, "name %s", &host_if_name))
10411 vec_add1 (host_if_name, 0);
10412 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
10413 random_hw_addr = 0;
10418 if (!vec_len (host_if_name)) {
10419 errmsg ("host-interface name must be specified");
10423 if (vec_len (host_if_name) > 64) {
10424 errmsg ("host-interface name too long");
10428 M(AF_PACKET_CREATE, af_packet_create);
10430 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
10431 clib_memcpy (mp->hw_addr, hw_addr, 6);
10432 mp->use_random_hw_addr = random_hw_addr;
10433 vec_free (host_if_name);
10441 api_af_packet_delete (vat_main_t * vam)
10443 unformat_input_t * i = vam->input;
10444 vl_api_af_packet_delete_t * mp;
10446 u8 * host_if_name = 0;
10448 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10449 if (unformat (i, "name %s", &host_if_name))
10450 vec_add1 (host_if_name, 0);
10455 if (!vec_len (host_if_name)) {
10456 errmsg ("host-interface name must be specified");
10460 if (vec_len (host_if_name) > 64) {
10461 errmsg ("host-interface name too long");
10465 M(AF_PACKET_DELETE, af_packet_delete);
10467 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
10468 vec_free (host_if_name);
10476 api_policer_add_del (vat_main_t * vam)
10478 unformat_input_t * i = vam->input;
10479 vl_api_policer_add_del_t * mp;
10491 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10492 if (unformat (i, "del"))
10494 else if (unformat (i, "name %s", &name))
10495 vec_add1 (name, 0);
10496 else if (unformat (i, "cir %u", &cir))
10498 else if (unformat (i, "eir %u", &eir))
10500 else if (unformat (i, "cb %u", &cb))
10502 else if (unformat (i, "eb %u", &eb))
10504 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
10507 else if (unformat (i, "round_type %U", unformat_policer_round_type,
10510 else if (unformat (i, "type %U", unformat_policer_type, &type))
10516 if (!vec_len (name)) {
10517 errmsg ("policer name must be specified");
10521 if (vec_len (name) > 64) {
10522 errmsg ("policer name too long");
10526 M(POLICER_ADD_DEL, policer_add_del);
10528 clib_memcpy (mp->name, name, vec_len (name));
10530 mp->is_add = is_add;
10535 mp->rate_type = rate_type;
10536 mp->round_type = round_type;
10545 api_policer_dump(vat_main_t *vam)
10547 unformat_input_t * i = vam->input;
10548 vl_api_policer_dump_t *mp;
10550 u8 *match_name = 0;
10551 u8 match_name_valid = 0;
10553 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10554 if (unformat (i, "name %s", &match_name)) {
10555 vec_add1 (match_name, 0);
10556 match_name_valid = 1;
10561 M(POLICER_DUMP, policer_dump);
10562 mp->match_name_valid = match_name_valid;
10563 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
10564 vec_free (match_name);
10568 /* Use a control ping for synchronization */
10570 vl_api_control_ping_t * mp;
10571 M(CONTROL_PING, control_ping);
10574 /* Wait for a reply... */
10582 api_netmap_create (vat_main_t * vam)
10584 unformat_input_t * i = vam->input;
10585 vl_api_netmap_create_t * mp;
10589 u8 random_hw_addr = 1;
10593 memset (hw_addr, 0, sizeof (hw_addr));
10595 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10596 if (unformat (i, "name %s", &if_name))
10597 vec_add1 (if_name, 0);
10598 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
10599 random_hw_addr = 0;
10600 else if (unformat (i, "pipe"))
10602 else if (unformat (i, "master"))
10604 else if (unformat (i, "slave"))
10610 if (!vec_len (if_name)) {
10611 errmsg ("interface name must be specified");
10615 if (vec_len (if_name) > 64) {
10616 errmsg ("interface name too long");
10620 M(NETMAP_CREATE, netmap_create);
10622 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
10623 clib_memcpy (mp->hw_addr, hw_addr, 6);
10624 mp->use_random_hw_addr = random_hw_addr;
10625 mp->is_pipe = is_pipe;
10626 mp->is_master = is_master;
10627 vec_free (if_name);
10635 api_netmap_delete (vat_main_t * vam)
10637 unformat_input_t * i = vam->input;
10638 vl_api_netmap_delete_t * mp;
10642 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10643 if (unformat (i, "name %s", &if_name))
10644 vec_add1 (if_name, 0);
10649 if (!vec_len (if_name)) {
10650 errmsg ("interface name must be specified");
10654 if (vec_len (if_name) > 64) {
10655 errmsg ("interface name too long");
10659 M(NETMAP_DELETE, netmap_delete);
10661 clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
10662 vec_free (if_name);
10669 static int q_or_quit (vat_main_t * vam)
10671 longjmp (vam->jump_buf, 1);
10672 return 0; /* not so much */
10674 static int q (vat_main_t * vam) {return q_or_quit (vam);}
10675 static int quit (vat_main_t * vam) {return q_or_quit (vam);}
10677 static int comment (vat_main_t * vam)
10682 static int cmd_cmp (void * a1, void * a2)
10687 return strcmp ((char *)(c1[0]), (char *)(c2[0]));
10690 static int help (vat_main_t * vam)
10695 unformat_input_t * i = vam->input;
10698 if (unformat (i, "%s", &name)) {
10703 hs = hash_get_mem (vam->help_by_name, name);
10705 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
10707 fformat (vam->ofp, "No such msg / command '%s'\n", name);
10712 fformat(vam->ofp, "Help is available for the following:\n");
10714 hash_foreach_pair (p, vam->function_by_name,
10716 vec_add1 (cmds, (u8 *)(p->key));
10719 vec_sort_with_function (cmds, cmd_cmp);
10721 for (j = 0; j < vec_len(cmds); j++)
10722 fformat (vam->ofp, "%s\n", cmds[j]);
10728 static int set (vat_main_t * vam)
10730 u8 * name = 0, * value = 0;
10731 unformat_input_t * i = vam->input;
10733 if (unformat (i, "%s", &name)) {
10734 /* The input buffer is a vector, not a string. */
10735 value = vec_dup (i->buffer);
10736 vec_delete (value, i->index, 0);
10737 /* Almost certainly has a trailing newline */
10738 if (value[vec_len(value)-1] == '\n')
10739 value[vec_len(value)-1] = 0;
10740 /* Make sure it's a proper string, one way or the other */
10741 vec_add1 (value, 0);
10742 (void) clib_macro_set_value (&vam->macro_main,
10743 (char *)name, (char *)value);
10746 errmsg ("usage: set <name> <value>\n");
10753 static int unset (vat_main_t * vam)
10757 if (unformat (vam->input, "%s", &name))
10758 if (clib_macro_unset (&vam->macro_main, (char *)name) == 1)
10759 errmsg ("unset: %s wasn't set\n", name);
10770 static int macro_sort_cmp (void * a1, void * a2)
10772 macro_sort_t * s1 = a1;
10773 macro_sort_t * s2 = a2;
10775 return strcmp ((char *)(s1->name), (char *)(s2->name));
10778 static int dump_macro_table (vat_main_t * vam)
10780 macro_sort_t * sort_me = 0, * sm;
10784 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
10786 vec_add2 (sort_me, sm, 1);
10787 sm->name = (u8 *)(p->key);
10788 sm->value = (u8 *) (p->value[0]);
10791 vec_sort_with_function (sort_me, macro_sort_cmp);
10793 if (vec_len(sort_me))
10794 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
10796 fformat (vam->ofp, "The macro table is empty...\n");
10798 for (i = 0; i < vec_len (sort_me); i++)
10799 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name,
10804 static int dump_node_table (vat_main_t * vam)
10807 vlib_node_t * node, * next_node;
10809 if (vec_len (vam->graph_nodes) == 0) {
10810 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
10814 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
10815 node = vam->graph_nodes[i];
10816 fformat (vam->ofp, "[%d] %s\n", i, node->name);
10817 for (j = 0; j < vec_len (node->next_nodes); j++) {
10818 if (node->next_nodes[j] != ~0) {
10819 next_node = vam->graph_nodes[node->next_nodes[j]];
10820 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
10827 static int search_node_table (vat_main_t * vam)
10829 unformat_input_t * line_input = vam->input;
10832 vlib_node_t * node, * next_node;
10835 if (vam->graph_node_index_by_name == 0) {
10836 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
10840 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
10841 if (unformat (line_input, "%s", &node_to_find)) {
10842 vec_add1 (node_to_find, 0);
10843 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
10845 fformat (vam->ofp, "%s not found...\n", node_to_find);
10848 node = vam->graph_nodes[p[0]];
10849 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
10850 for (j = 0; j < vec_len (node->next_nodes); j++) {
10851 if (node->next_nodes[j] != ~0) {
10852 next_node = vam->graph_nodes[node->next_nodes[j]];
10853 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
10859 clib_warning ("parse error '%U'", format_unformat_error,
10865 vec_free(node_to_find);
10873 static int script (vat_main_t * vam)
10876 char * save_current_file;
10877 unformat_input_t save_input;
10878 jmp_buf save_jump_buf;
10879 u32 save_line_number;
10881 FILE * new_fp, * save_ifp;
10883 if (unformat (vam->input, "%s", &s)) {
10884 new_fp = fopen ((char *)s, "r");
10886 errmsg ("Couldn't open script file %s\n", s);
10891 errmsg ("Missing script name\n");
10895 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
10896 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
10897 save_ifp = vam->ifp;
10898 save_line_number = vam->input_line_number;
10899 save_current_file = (char *) vam->current_file;
10901 vam->input_line_number = 0;
10903 vam->current_file = s;
10906 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
10907 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
10908 vam->ifp = save_ifp;
10909 vam->input_line_number = save_line_number;
10910 vam->current_file = (u8 *) save_current_file;
10916 static int echo (vat_main_t * vam)
10918 fformat (vam->ofp, "%v", vam->input->buffer);
10922 /* List of API message constructors, CLI names map to api_xxx */
10923 #define foreach_vpe_api_msg \
10924 _(create_loopback,"[mac <mac-addr>]") \
10925 _(sw_interface_dump,"") \
10926 _(sw_interface_set_flags, \
10927 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
10928 _(sw_interface_add_del_address, \
10929 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
10930 _(sw_interface_set_table, \
10931 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
10932 _(sw_interface_set_vpath, \
10933 "<intfc> | sw_if_index <id> enable | disable") \
10934 _(sw_interface_set_l2_xconnect, \
10935 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
10936 "enable | disable") \
10937 _(sw_interface_set_l2_bridge, \
10938 "rx <intfc> | rx_sw_if_index <id> bd_id <bridge-domain-id>\n" \
10939 "[shg <split-horizon-group>] [bvi]\n" \
10940 "enable | disable") \
10941 _(bridge_domain_add_del, \
10942 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
10943 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
10945 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi]\n") \
10947 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
10949 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
10951 "tapname <name> mac <mac-addr> | random-mac") \
10953 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
10955 "<vpp-if-name> | sw_if_index <id>") \
10956 _(sw_interface_tap_dump, "") \
10957 _(ip_add_del_route, \
10958 "<addr>/<mask> via <addr> [vrf <n>]\n" \
10959 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
10960 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
10961 "[multipath] [count <n>]") \
10962 _(proxy_arp_add_del, \
10963 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
10964 _(proxy_arp_intfc_enable_disable, \
10965 "<intfc> | sw_if_index <id> enable | disable") \
10966 _(mpls_add_del_encap, \
10967 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
10968 _(mpls_add_del_decap, \
10969 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
10970 _(mpls_gre_add_del_tunnel, \
10971 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
10972 "adj <ip4-address>/<mask-width> [del]") \
10973 _(sw_interface_set_unnumbered, \
10974 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
10975 _(ip_neighbor_add_del, \
10976 "<intfc> | sw_if_index <id> dst <ip46-address> mac <mac-addr>") \
10977 _(reset_vrf, "vrf <id> [ipv6]") \
10978 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
10979 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
10980 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
10981 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
10982 "[outer_vlan_id_any][inner_vlan_id_any]") \
10983 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
10984 _(reset_fib, "vrf <n> [ipv6]") \
10985 _(dhcp_proxy_config, \
10986 "svr <v46-address> src <v46-address>\n" \
10987 "insert-cid <n> [del]") \
10988 _(dhcp_proxy_config_2, \
10989 "svr <v46-address> src <v46-address>\n" \
10990 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
10991 _(dhcp_proxy_set_vss, \
10992 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
10993 _(dhcp_client_config, \
10994 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
10995 _(set_ip_flow_hash, \
10996 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
10997 _(sw_interface_ip6_enable_disable, \
10998 "<intfc> | sw_if_index <id> enable | disable") \
10999 _(sw_interface_ip6_set_link_local_address, \
11000 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
11001 _(sw_interface_ip6nd_ra_prefix, \
11002 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
11003 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
11004 "[nolink] [isno]") \
11005 _(sw_interface_ip6nd_ra_config, \
11006 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
11007 "[life <n>] [count <n>] [interval <n>] [surpress]\n" \
11008 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
11009 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
11010 _(l2_patch_add_del, \
11011 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
11012 "enable | disable") \
11013 _(mpls_ethernet_add_del_tunnel, \
11014 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
11015 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
11016 _(mpls_ethernet_add_del_tunnel_2, \
11017 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
11018 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
11019 _(sr_tunnel_add_del, \
11020 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
11021 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
11022 "[policy <policy_name>]") \
11023 _(sr_policy_add_del, \
11024 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
11025 _(sr_multicast_map_add_del, \
11026 "address [ip6 multicast address] sr-policy [policy name] [del]") \
11027 _(classify_add_del_table, \
11028 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
11029 "[del] mask <mask-value>\n" \
11030 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
11031 _(classify_add_del_session, \
11032 "[hit-next|l2-hit-next|acl-hit-next] <name|nn> table-index <nn>\n" \
11033 "skip_n <nn> match_n <nn> match [hex] [l2] [l3 [ip4|ip6]]") \
11034 _(classify_set_interface_ip_table, \
11035 "<intfc> | sw_if_index <nn> table <nn>") \
11036 _(classify_set_interface_l2_tables, \
11037 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
11038 " [other-table <nn>]") \
11039 _(get_node_index, "node <node-name") \
11040 _(add_node_next, "node <node-name> next <next-node-name>") \
11041 _(l2tpv3_create_tunnel, \
11042 "client_address <ip6-addr> our_address <ip6-addr>\n" \
11043 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
11044 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
11045 _(l2tpv3_set_tunnel_cookies, \
11046 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
11047 "[new_remote_cookie <nn>]\n") \
11048 _(l2tpv3_interface_enable_disable, \
11049 "<intfc> | sw_if_index <nn> enable | disable") \
11050 _(l2tpv3_set_lookup_key, \
11051 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
11052 _(sw_if_l2tpv3_tunnel_dump, "") \
11053 _(vxlan_add_del_tunnel, \
11054 "src <ip-addr> dst <ip-addr> vni <vni> [encap-vrf-id <nn>]\n" \
11055 " [decap-next l2|ip4|ip6] [del]") \
11056 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
11057 _(gre_add_del_tunnel, \
11058 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
11059 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
11060 _(l2_fib_clear_table, "") \
11061 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
11062 _(l2_interface_vlan_tag_rewrite, \
11063 "<intfc> | sw_if_index <nn> \n" \
11064 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
11065 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
11066 _(create_vhost_user_if, \
11067 "socket <filename> [server] [renumber <dev_instance>] " \
11068 "[mac <mac_address>]") \
11069 _(modify_vhost_user_if, \
11070 "<intfc> | sw_if_index <nn> socket <filename>\n" \
11071 "[server] [renumber <dev_instance>]") \
11072 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
11073 _(sw_interface_vhost_user_dump, "") \
11074 _(show_version, "") \
11075 _(vxlan_gpe_add_del_tunnel, \
11076 "local <ip4-addr> remote <ip4-addr> vni <nn>\n" \
11077 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
11078 "[next-ethernet] [next-nsh]\n") \
11079 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
11080 _(interface_name_renumber, \
11081 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
11082 _(input_acl_set_interface, \
11083 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
11084 " [l2-table <nn>] [del]") \
11085 _(want_ip4_arp_events, "address <ip4-address> [del]") \
11086 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
11087 _(ip_dump, "ipv4 | ipv6") \
11088 _(ipsec_spd_add_del, "spd_id <n> [del]") \
11089 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
11091 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
11092 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
11093 " integ_alg <alg> integ_key <hex>") \
11094 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
11095 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
11096 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
11097 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
11098 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
11099 _(ikev2_profile_add_del, "name <profile_name> [del]") \
11100 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
11101 "(auth_data 0x<data> | auth_data <data>)") \
11102 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
11103 "(id_data 0x<data> | id_data <data>) (local|remote)") \
11104 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
11105 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
11106 "(local|remote)") \
11107 _(ikev2_set_local_key, "file <absolute_file_path>") \
11108 _(delete_loopback,"sw_if_index <nn>") \
11109 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
11110 _(map_add_domain, \
11111 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
11112 "ip6-src <ip6addr> " \
11113 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
11114 _(map_del_domain, "index <n>") \
11115 _(map_add_del_rule, \
11116 "index <n> psid <n> dst <ip6addr> [del]") \
11117 _(map_domain_dump, "") \
11118 _(map_rule_dump, "index <map-domain>") \
11119 _(want_interface_events, "enable|disable") \
11120 _(want_stats,"enable|disable") \
11121 _(get_first_msg_id, "client <name>") \
11122 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
11123 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
11124 "fib-id <nn> [ip4][ip6][default]") \
11125 _(get_node_graph, " ") \
11126 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
11127 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
11128 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
11129 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
11130 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
11131 " vrf_id <nn> add | pop | none") \
11132 _(trace_profile_del, "") \
11133 _(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \
11134 _(lisp_add_del_locator, "locator-set <locator_name> " \
11135 "iface <intf> | sw_if_index <sw_if_index> " \
11136 "p <priority> w <weight> [del]") \
11137 _(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \
11138 "locator-set <locator_name> [del]") \
11139 _(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \
11140 "sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \
11141 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
11142 _(lisp_gpe_enable_disable, "enable|disable") \
11143 _(lisp_enable_disable, "enable|disable") \
11144 _(lisp_gpe_add_del_iface, "up|down") \
11145 _(lisp_add_del_remote_mapping, "add|del vni <vni> table-id <id> " \
11146 "deid <dest-eid> seid" \
11147 " <src-eid> rloc <locator> " \
11148 "[rloc <loc> ... ]") \
11149 _(lisp_pitr_set_locator_set, "locator-set <loc-set-name> | del") \
11150 _(lisp_locator_set_dump, "") \
11151 _(lisp_local_eid_table_dump, "") \
11152 _(lisp_gpe_tunnel_dump, "") \
11153 _(lisp_map_resolver_dump, "") \
11154 _(lisp_enable_disable_status_dump, "") \
11155 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
11156 _(af_packet_delete, "name <host interface name>") \
11157 _(policer_add_del, "name <policer name> <params> [del]") \
11158 _(policer_dump, "[name <policer name>]") \
11159 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
11160 "[master|slave]") \
11161 _(netmap_delete, "name <interface name>")
11163 /* List of command functions, CLI names map directly to functions */
11164 #define foreach_cli_function \
11165 _(comment, "usage: comment <ignore-rest-of-line>") \
11166 _(dump_interface_table, "usage: dump_interface_table") \
11167 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
11168 _(dump_ipv4_table, "usage: dump_ipv4_table") \
11169 _(dump_ipv6_table, "usage: dump_ipv6_table") \
11170 _(dump_stats_table, "usage: dump_stats_table") \
11171 _(dump_macro_table, "usage: dump_macro_table ") \
11172 _(dump_node_table, "usage: dump_node_table") \
11173 _(echo, "usage: echo <message>") \
11174 _(exec, "usage: exec <vpe-debug-CLI-command>") \
11175 _(help, "usage: help") \
11176 _(q, "usage: quit") \
11177 _(quit, "usage: quit") \
11178 _(search_node_table, "usage: search_node_table <name>...") \
11179 _(set, "usage: set <variable-name> <value>") \
11180 _(script, "usage: script <file-name>") \
11181 _(unset, "usage: unset <variable-name>")
11184 static void vl_api_##n##_t_handler_uni \
11185 (vl_api_##n##_t * mp) \
11187 vat_main_t * vam = &vat_main; \
11188 if (vam->json_output) { \
11189 vl_api_##n##_t_handler_json(mp); \
11191 vl_api_##n##_t_handler(mp); \
11194 foreach_vpe_api_reply_msg;
11197 void vat_api_hookup (vat_main_t *vam)
11200 vl_msg_api_set_handlers(VL_API_##N, #n, \
11201 vl_api_##n##_t_handler_uni, \
11203 vl_api_##n##_t_endian, \
11204 vl_api_##n##_t_print, \
11205 sizeof(vl_api_##n##_t), 1);
11206 foreach_vpe_api_reply_msg;
11209 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
11211 vam->sw_if_index_by_interface_name =
11212 hash_create_string (0, sizeof (uword));
11214 vam->function_by_name =
11215 hash_create_string (0, sizeof(uword));
11217 vam->help_by_name =
11218 hash_create_string (0, sizeof(uword));
11220 /* API messages we can send */
11221 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
11222 foreach_vpe_api_msg;
11226 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
11227 foreach_vpe_api_msg;
11230 /* CLI functions */
11231 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
11232 foreach_cli_function;
11236 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
11237 foreach_cli_function;
11241 #undef vl_api_version
11242 #define vl_api_version(n,v) static u32 vpe_api_version = v;
11243 #include <api/vpe.api.h>
11244 #undef vl_api_version
11246 void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
11249 * Send the main API signature in slot 0. This bit of code must
11250 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
11252 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);