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 _(vxlan_gpe_add_del_tunnel_reply) \
2355 _(af_packet_create_reply) \
2356 _(af_packet_delete_reply) \
2357 _(policer_add_del_reply) \
2358 _(netmap_create_reply) \
2359 _(netmap_delete_reply)
2362 static void vl_api_##n##_t_handler \
2363 (vl_api_##n##_t * mp) \
2365 vat_main_t * vam = &vat_main; \
2366 i32 retval = ntohl(mp->retval); \
2367 if (vam->async_mode) { \
2368 vam->async_errors += (retval < 0); \
2370 vam->retval = retval; \
2371 vam->result_ready = 1; \
2374 foreach_standard_reply_retval_handler;
2378 static void vl_api_##n##_t_handler_json \
2379 (vl_api_##n##_t * mp) \
2381 vat_main_t * vam = &vat_main; \
2382 vat_json_node_t node; \
2383 vat_json_init_object(&node); \
2384 vat_json_object_add_int(&node, "retval", ntohl(mp->retval)); \
2385 vat_json_print(vam->ofp, &node); \
2386 vam->retval = ntohl(mp->retval); \
2387 vam->result_ready = 1; \
2389 foreach_standard_reply_retval_handler;
2393 * Table of message reply handlers, must include boilerplate handlers
2397 #define foreach_vpe_api_reply_msg \
2398 _(CREATE_LOOPBACK_REPLY, create_loopback_reply) \
2399 _(SW_INTERFACE_DETAILS, sw_interface_details) \
2400 _(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
2401 _(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply) \
2402 _(CONTROL_PING_REPLY, control_ping_reply) \
2403 _(CLI_REPLY, cli_reply) \
2404 _(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, \
2405 sw_interface_add_del_address_reply) \
2406 _(SW_INTERFACE_SET_TABLE_REPLY, sw_interface_set_table_reply) \
2407 _(SW_INTERFACE_SET_VPATH_REPLY, sw_interface_set_vpath_reply) \
2408 _(SW_INTERFACE_SET_L2_XCONNECT_REPLY, \
2409 sw_interface_set_l2_xconnect_reply) \
2410 _(SW_INTERFACE_SET_L2_BRIDGE_REPLY, \
2411 sw_interface_set_l2_bridge_reply) \
2412 _(BRIDGE_DOMAIN_ADD_DEL_REPLY, bridge_domain_add_del_reply) \
2413 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
2414 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
2415 _(L2FIB_ADD_DEL_REPLY, l2fib_add_del_reply) \
2416 _(L2_FLAGS_REPLY, l2_flags_reply) \
2417 _(BRIDGE_FLAGS_REPLY, bridge_flags_reply) \
2418 _(TAP_CONNECT_REPLY, tap_connect_reply) \
2419 _(TAP_MODIFY_REPLY, tap_modify_reply) \
2420 _(TAP_DELETE_REPLY, tap_delete_reply) \
2421 _(SW_INTERFACE_TAP_DETAILS, sw_interface_tap_details) \
2422 _(IP_ADD_DEL_ROUTE_REPLY, ip_add_del_route_reply) \
2423 _(PROXY_ARP_ADD_DEL_REPLY, proxy_arp_add_del_reply) \
2424 _(PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY, \
2425 proxy_arp_intfc_enable_disable_reply) \
2426 _(MPLS_ADD_DEL_ENCAP_REPLY, mpls_add_del_encap_reply) \
2427 _(MPLS_ADD_DEL_DECAP_REPLY, mpls_add_del_decap_reply) \
2428 _(MPLS_GRE_ADD_DEL_TUNNEL_REPLY, mpls_gre_add_del_tunnel_reply) \
2429 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_REPLY, \
2430 mpls_ethernet_add_del_tunnel_reply) \
2431 _(MPLS_ETHERNET_ADD_DEL_TUNNEL_2_REPLY, \
2432 mpls_ethernet_add_del_tunnel_2_reply) \
2433 _(SW_INTERFACE_SET_UNNUMBERED_REPLY, \
2434 sw_interface_set_unnumbered_reply) \
2435 _(IP_NEIGHBOR_ADD_DEL_REPLY, ip_neighbor_add_del_reply) \
2436 _(RESET_VRF_REPLY, reset_vrf_reply) \
2437 _(CREATE_VLAN_SUBIF_REPLY, create_vlan_subif_reply) \
2438 _(CREATE_SUBIF_REPLY, create_subif_reply) \
2439 _(OAM_ADD_DEL_REPLY, oam_add_del_reply) \
2440 _(RESET_FIB_REPLY, reset_fib_reply) \
2441 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply) \
2442 _(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply) \
2443 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply) \
2444 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply) \
2445 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply) \
2446 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY, \
2447 sw_interface_ip6_enable_disable_reply) \
2448 _(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS_REPLY, \
2449 sw_interface_ip6_set_link_local_address_reply) \
2450 _(SW_INTERFACE_IP6ND_RA_PREFIX_REPLY, \
2451 sw_interface_ip6nd_ra_prefix_reply) \
2452 _(SW_INTERFACE_IP6ND_RA_CONFIG_REPLY, \
2453 sw_interface_ip6nd_ra_config_reply) \
2454 _(SET_ARP_NEIGHBOR_LIMIT_REPLY, set_arp_neighbor_limit_reply) \
2455 _(L2_PATCH_ADD_DEL_REPLY, l2_patch_add_del_reply) \
2456 _(SR_TUNNEL_ADD_DEL_REPLY, sr_tunnel_add_del_reply) \
2457 _(SR_POLICY_ADD_DEL_REPLY, sr_policy_add_del_reply) \
2458 _(SR_MULTICAST_MAP_ADD_DEL_REPLY, sr_multicast_map_add_del_reply) \
2459 _(CLASSIFY_ADD_DEL_TABLE_REPLY, classify_add_del_table_reply) \
2460 _(CLASSIFY_ADD_DEL_SESSION_REPLY, classify_add_del_session_reply) \
2461 _(CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY, \
2462 classify_set_interface_ip_table_reply) \
2463 _(CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY, \
2464 classify_set_interface_l2_tables_reply) \
2465 _(GET_NODE_INDEX_REPLY, get_node_index_reply) \
2466 _(ADD_NODE_NEXT_REPLY, add_node_next_reply) \
2467 _(L2TPV3_CREATE_TUNNEL_REPLY, l2tpv3_create_tunnel_reply) \
2468 _(L2TPV3_SET_TUNNEL_COOKIES_REPLY, l2tpv3_set_tunnel_cookies_reply) \
2469 _(L2TPV3_INTERFACE_ENABLE_DISABLE_REPLY, \
2470 l2tpv3_interface_enable_disable_reply) \
2471 _(L2TPV3_SET_LOOKUP_KEY_REPLY, l2tpv3_set_lookup_key_reply) \
2472 _(SW_IF_L2TPV3_TUNNEL_DETAILS, sw_if_l2tpv3_tunnel_details) \
2473 _(VXLAN_ADD_DEL_TUNNEL_REPLY, vxlan_add_del_tunnel_reply) \
2474 _(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
2475 _(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
2476 _(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
2477 _(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
2478 _(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
2479 _(L2_INTERFACE_VLAN_TAG_REWRITE_REPLY, l2_interface_vlan_tag_rewrite_reply) \
2480 _(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
2481 _(CREATE_VHOST_USER_IF_REPLY, create_vhost_user_if_reply) \
2482 _(MODIFY_VHOST_USER_IF_REPLY, modify_vhost_user_if_reply) \
2483 _(DELETE_VHOST_USER_IF_REPLY, delete_vhost_user_if_reply) \
2484 _(SHOW_VERSION_REPLY, show_version_reply) \
2485 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
2486 _(VXLAN_GPE_ADD_DEL_TUNNEL_REPLY, vxlan_gpe_add_del_tunnel_reply) \
2487 _(INTERFACE_NAME_RENUMBER_REPLY, interface_name_renumber_reply) \
2488 _(WANT_IP4_ARP_EVENTS_REPLY, want_ip4_arp_events_reply) \
2489 _(IP4_ARP_EVENT, ip4_arp_event) \
2490 _(INPUT_ACL_SET_INTERFACE_REPLY, input_acl_set_interface_reply) \
2491 _(IP_ADDRESS_DETAILS, ip_address_details) \
2492 _(IP_DETAILS, ip_details) \
2493 _(IPSEC_SPD_ADD_DEL_REPLY, ipsec_spd_add_del_reply) \
2494 _(IPSEC_INTERFACE_ADD_DEL_SPD_REPLY, ipsec_interface_add_del_spd_reply) \
2495 _(IPSEC_SPD_ADD_DEL_ENTRY_REPLY, ipsec_spd_add_del_entry_reply) \
2496 _(IPSEC_SAD_ADD_DEL_ENTRY_REPLY, ipsec_sad_add_del_entry_reply) \
2497 _(IPSEC_SA_SET_KEY_REPLY, ipsec_sa_set_key_reply) \
2498 _(IKEV2_PROFILE_ADD_DEL_REPLY, ikev2_profile_add_del_reply) \
2499 _(IKEV2_PROFILE_SET_AUTH_REPLY, ikev2_profile_set_auth_reply) \
2500 _(IKEV2_PROFILE_SET_ID_REPLY, ikev2_profile_set_id_reply) \
2501 _(IKEV2_PROFILE_SET_TS_REPLY, ikev2_profile_set_ts_reply) \
2502 _(IKEV2_SET_LOCAL_KEY_REPLY, ikev2_set_local_key_reply) \
2503 _(DELETE_LOOPBACK_REPLY, delete_loopback_reply) \
2504 _(BD_IP_MAC_ADD_DEL_REPLY, bd_ip_mac_add_del_reply) \
2505 _(DHCP_COMPL_EVENT, dhcp_compl_event) \
2506 _(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \
2507 _(VNET_IP4_FIB_COUNTERS, vnet_ip4_fib_counters) \
2508 _(VNET_IP6_FIB_COUNTERS, vnet_ip6_fib_counters) \
2509 _(MAP_ADD_DOMAIN_REPLY, map_add_domain_reply) \
2510 _(MAP_DEL_DOMAIN_REPLY, map_del_domain_reply) \
2511 _(MAP_ADD_DEL_RULE_REPLY, map_add_del_rule_reply) \
2512 _(MAP_DOMAIN_DETAILS, map_domain_details) \
2513 _(MAP_RULE_DETAILS, map_rule_details) \
2514 _(WANT_INTERFACE_EVENTS_REPLY, want_interface_events_reply) \
2515 _(WANT_STATS_REPLY, want_stats_reply) \
2516 _(GET_FIRST_MSG_ID_REPLY, get_first_msg_id_reply) \
2517 _(COP_INTERFACE_ENABLE_DISABLE_REPLY, cop_interface_enable_disable_reply) \
2518 _(COP_WHITELIST_ENABLE_DISABLE_REPLY, cop_whitelist_enable_disable_reply) \
2519 _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \
2520 _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \
2521 _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \
2522 _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \
2523 _(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \
2524 _(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \
2525 _(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \
2526 _(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \
2527 _(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \
2528 _(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \
2529 _(LISP_GPE_ENABLE_DISABLE_REPLY, lisp_gpe_enable_disable_reply) \
2530 _(LISP_ENABLE_DISABLE_REPLY, lisp_enable_disable_reply) \
2531 _(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \
2532 _(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \
2533 _(LISP_LOCAL_EID_TABLE_DETAILS, lisp_local_eid_table_details) \
2534 _(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \
2535 _(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) \
2536 _(LISP_ENABLE_DISABLE_STATUS_DETAILS, \
2537 lisp_enable_disable_status_details) \
2538 _(AF_PACKET_CREATE_REPLY, af_packet_create_reply) \
2539 _(AF_PACKET_DELETE_REPLY, af_packet_delete_reply) \
2540 _(POLICER_ADD_DEL_REPLY, policer_add_del_reply) \
2541 _(POLICER_DETAILS, policer_details) \
2542 _(NETMAP_CREATE_REPLY, netmap_create_reply) \
2543 _(NETMAP_DELETE_REPLY, netmap_delete_reply)
2545 /* M: construct, but don't yet send a message */
2549 vam->result_ready = 0; \
2550 mp = vl_msg_api_alloc(sizeof(*mp)); \
2551 memset (mp, 0, sizeof (*mp)); \
2552 mp->_vl_msg_id = ntohs (VL_API_##T); \
2553 mp->client_index = vam->my_client_index; \
2558 vam->result_ready = 0; \
2559 mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \
2560 memset (mp, 0, sizeof (*mp)); \
2561 mp->_vl_msg_id = ntohs (VL_API_##T); \
2562 mp->client_index = vam->my_client_index; \
2566 /* S: send a message */
2567 #define S (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))
2569 /* W: wait for results, with timeout */
2572 timeout = vat_time_now (vam) + 1.0; \
2574 while (vat_time_now (vam) < timeout) { \
2575 if (vam->result_ready == 1) { \
2576 return (vam->retval); \
2588 #define STR_VTR_OP_CASE(op) \
2589 case L2_VTR_ ## op: \
2592 static const char *str_vtr_op(u32 vtr_op)
2595 STR_VTR_OP_CASE(DISABLED);
2596 STR_VTR_OP_CASE(PUSH_1);
2597 STR_VTR_OP_CASE(PUSH_2);
2598 STR_VTR_OP_CASE(POP_1);
2599 STR_VTR_OP_CASE(POP_2);
2600 STR_VTR_OP_CASE(TRANSLATE_1_1);
2601 STR_VTR_OP_CASE(TRANSLATE_1_2);
2602 STR_VTR_OP_CASE(TRANSLATE_2_1);
2603 STR_VTR_OP_CASE(TRANSLATE_2_2);
2609 static int dump_sub_interface_table (vat_main_t * vam)
2611 const sw_interface_subif_t * sub = NULL;
2613 if (vam->json_output) {
2614 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2619 "%-30s%-12s%-11s%-7s%-5s%-9s%-9s%-6s%-8s%-10s%-10s\n",
2620 "Interface", "sw_if_index",
2621 "sub id", "dot1ad", "tags", "outer id",
2622 "inner id", "exact", "default",
2623 "outer any", "inner any");
2625 vec_foreach (sub, vam->sw_if_subif_table) {
2627 "%-30s%-12d%-11d%-7s%-5d%-9d%-9d%-6d%-8d%-10d%-10d\n",
2628 sub->interface_name,
2630 sub->sub_id, sub->sub_dot1ad ? "dot1ad" : "dot1q",
2631 sub->sub_number_of_tags, sub->sub_outer_vlan_id,
2632 sub->sub_inner_vlan_id, sub->sub_exact_match, sub->sub_default,
2633 sub->sub_outer_vlan_id_any, sub->sub_inner_vlan_id_any);
2634 if (sub->vtr_op != L2_VTR_DISABLED) {
2636 " vlan-tag-rewrite - op: %-14s [ dot1q: %d "
2637 "tag1: %d tag2: %d ]\n",
2638 str_vtr_op(sub->vtr_op), sub->vtr_push_dot1q,
2639 sub->vtr_tag1, sub->vtr_tag2);
2646 static int name_sort_cmp (void * a1, void * a2)
2648 name_sort_t * n1 = a1;
2649 name_sort_t * n2 = a2;
2651 return strcmp ((char *)n1->name, (char *)n2->name);
2654 static int dump_interface_table (vat_main_t * vam)
2657 name_sort_t * nses = 0, * ns;
2659 if (vam->json_output) {
2660 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2664 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
2666 vec_add2 (nses, ns, 1);
2667 ns->name = (u8 *)(p->key);
2668 ns->value = (u32) p->value[0];
2671 vec_sort_with_function (nses, name_sort_cmp);
2673 fformat (vam->ofp, "%-25s%-15s\n", "Interface", "sw_if_index");
2674 vec_foreach (ns, nses) {
2675 fformat (vam->ofp, "%-25s%-15d\n", ns->name, ns->value);
2681 static int dump_ip_table (vat_main_t * vam, int is_ipv6)
2683 const ip_details_t * det = NULL;
2684 const ip_address_details_t * address = NULL;
2695 vec_foreach (det, vam->ip_details_by_sw_if_index[is_ipv6]) {
2697 if (!det->present) {
2705 "Address", "Prefix length");
2709 vec_foreach (address, det->addr) {
2712 is_ipv6 ? format_ip6_address : format_ip4_address,
2714 address->prefix_length);
2721 static int dump_ipv4_table (vat_main_t * vam)
2723 if (vam->json_output) {
2724 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2728 return dump_ip_table (vam, 0);
2731 static int dump_ipv6_table (vat_main_t * vam)
2733 if (vam->json_output) {
2734 clib_warning ("JSON output supported only for VPE API calls and dump_stats_table");
2738 return dump_ip_table (vam, 1);
2741 static char* counter_type_to_str (u8 counter_type, u8 is_combined)
2744 switch(counter_type) {
2745 case VNET_INTERFACE_COUNTER_DROP:
2747 case VNET_INTERFACE_COUNTER_PUNT:
2749 case VNET_INTERFACE_COUNTER_IP4:
2751 case VNET_INTERFACE_COUNTER_IP6:
2753 case VNET_INTERFACE_COUNTER_RX_NO_BUF:
2755 case VNET_INTERFACE_COUNTER_RX_MISS:
2757 case VNET_INTERFACE_COUNTER_RX_ERROR:
2759 case VNET_INTERFACE_COUNTER_TX_ERROR:
2762 return "INVALID-COUNTER-TYPE";
2765 switch(counter_type) {
2766 case VNET_INTERFACE_COUNTER_RX:
2768 case VNET_INTERFACE_COUNTER_TX:
2771 return "INVALID-COUNTER-TYPE";
2776 static int dump_stats_table (vat_main_t * vam)
2778 vat_json_node_t node;
2779 vat_json_node_t *msg_array;
2780 vat_json_node_t *msg;
2781 vat_json_node_t *counter_array;
2782 vat_json_node_t *counter;
2783 interface_counter_t c;
2785 ip4_fib_counter_t *c4;
2786 ip6_fib_counter_t *c6;
2789 if (!vam->json_output) {
2790 clib_warning ("dump_stats_table supported only in JSON format");
2794 vat_json_init_object(&node);
2796 /* interface counters */
2797 msg_array = vat_json_object_add(&node, "interface_counters");
2798 vat_json_init_array(msg_array);
2799 for (i = 0; i < vec_len(vam->simple_interface_counters); i++) {
2800 msg = vat_json_array_add(msg_array);
2801 vat_json_init_object(msg);
2802 vat_json_object_add_string_copy(msg, "vnet_counter_type",
2803 (u8*)counter_type_to_str(i, 0));
2804 vat_json_object_add_int(msg, "is_combined", 0);
2805 counter_array = vat_json_object_add(msg, "data");
2806 vat_json_init_array(counter_array);
2807 for (j = 0; j < vec_len(vam->simple_interface_counters[i]); j++) {
2808 packets = vam->simple_interface_counters[i][j];
2809 vat_json_array_add_uint(counter_array, packets);
2812 for (i = 0; i < vec_len(vam->combined_interface_counters); i++) {
2813 msg = vat_json_array_add(msg_array);
2814 vat_json_init_object(msg);
2815 vat_json_object_add_string_copy(msg, "vnet_counter_type",
2816 (u8*)counter_type_to_str(i, 1));
2817 vat_json_object_add_int(msg, "is_combined", 1);
2818 counter_array = vat_json_object_add(msg, "data");
2819 vat_json_init_array(counter_array);
2820 for (j = 0; j < vec_len(vam->combined_interface_counters[i]); j++) {
2821 c = vam->combined_interface_counters[i][j];
2822 counter = vat_json_array_add(counter_array);
2823 vat_json_init_object(counter);
2824 vat_json_object_add_uint(counter, "packets", c.packets);
2825 vat_json_object_add_uint(counter, "bytes", c.bytes);
2829 /* ip4 fib counters */
2830 msg_array = vat_json_object_add(&node, "ip4_fib_counters");
2831 vat_json_init_array(msg_array);
2832 for (i = 0; i < vec_len(vam->ip4_fib_counters); i++) {
2833 msg = vat_json_array_add(msg_array);
2834 vat_json_init_object(msg);
2835 vat_json_object_add_uint(msg, "vrf_id", vam->ip4_fib_counters_vrf_id_by_index[i]);
2836 counter_array = vat_json_object_add(msg, "c");
2837 vat_json_init_array(counter_array);
2838 for (j = 0; j < vec_len(vam->ip4_fib_counters[i]); j++) {
2839 counter = vat_json_array_add(counter_array);
2840 vat_json_init_object(counter);
2841 c4 = &vam->ip4_fib_counters[i][j];
2842 vat_json_object_add_ip4(counter, "address", c4->address);
2843 vat_json_object_add_uint(counter, "address_length", c4->address_length);
2844 vat_json_object_add_uint(counter, "packets", c4->packets);
2845 vat_json_object_add_uint(counter, "bytes", c4->bytes);
2849 /* ip6 fib counters */
2850 msg_array = vat_json_object_add(&node, "ip6_fib_counters");
2851 vat_json_init_array(msg_array);
2852 for (i = 0; i < vec_len(vam->ip6_fib_counters); i++) {
2853 msg = vat_json_array_add(msg_array);
2854 vat_json_init_object(msg);
2855 vat_json_object_add_uint(msg, "vrf_id", vam->ip6_fib_counters_vrf_id_by_index[i]);
2856 counter_array = vat_json_object_add(msg, "c");
2857 vat_json_init_array(counter_array);
2858 for (j = 0; j < vec_len(vam->ip6_fib_counters[i]); j++) {
2859 counter = vat_json_array_add(counter_array);
2860 vat_json_init_object(counter);
2861 c6 = &vam->ip6_fib_counters[i][j];
2862 vat_json_object_add_ip6(counter, "address", c6->address);
2863 vat_json_object_add_uint(counter, "address_length", c6->address_length);
2864 vat_json_object_add_uint(counter, "packets", c6->packets);
2865 vat_json_object_add_uint(counter, "bytes", c6->bytes);
2869 vat_json_print(vam->ofp, &node);
2870 vat_json_free(&node);
2875 int exec (vat_main_t * vam)
2877 api_main_t * am = &api_main;
2878 vl_api_cli_request_t *mp;
2882 unformat_input_t * i = vam->input;
2884 if (vec_len(i->buffer) == 0)
2887 if (vam->exec_mode == 0 && unformat (i, "mode")) {
2891 if (vam->exec_mode == 1 &&
2892 (unformat (i, "exit") || unformat (i, "quit"))) {
2898 M(CLI_REQUEST, cli_request);
2901 * Copy cmd into shared memory.
2902 * In order for the CLI command to work, it
2903 * must be a vector ending in \n, not a C-string ending
2906 pthread_mutex_lock (&am->vlib_rp->mutex);
2907 oldheap = svm_push_data_heap (am->vlib_rp);
2909 vec_validate (cmd, vec_len(vam->input->buffer)-1);
2910 clib_memcpy (cmd, vam->input->buffer, vec_len(vam->input->buffer));
2912 svm_pop_heap (oldheap);
2913 pthread_mutex_unlock (&am->vlib_rp->mutex);
2915 mp->cmd_in_shmem = (u64) cmd;
2917 timeout = vat_time_now (vam) + 10.0;
2919 while (vat_time_now (vam) < timeout) {
2920 if (vam->result_ready == 1) {
2922 if (vam->shmem_result != NULL)
2923 fformat (vam->ofp, "%s", vam->shmem_result);
2924 pthread_mutex_lock (&am->vlib_rp->mutex);
2925 oldheap = svm_push_data_heap (am->vlib_rp);
2927 free_me = (u8 *)vam->shmem_result;
2930 svm_pop_heap (oldheap);
2931 pthread_mutex_unlock (&am->vlib_rp->mutex);
2938 static int api_create_loopback (vat_main_t * vam)
2940 unformat_input_t * i = vam->input;
2941 vl_api_create_loopback_t *mp;
2946 memset (mac_address, 0, sizeof (mac_address));
2948 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2950 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address))
2956 /* Construct the API message */
2957 M(CREATE_LOOPBACK, create_loopback);
2959 clib_memcpy (mp->mac_address, mac_address, sizeof (mac_address));
2964 static int api_delete_loopback (vat_main_t * vam)
2966 unformat_input_t * i = vam->input;
2967 vl_api_delete_loopback_t *mp;
2969 u32 sw_if_index = ~0;
2971 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
2973 if (unformat (i, "sw_if_index %d", &sw_if_index))
2979 if (sw_if_index == ~0)
2981 errmsg ("missing sw_if_index\n");
2985 /* Construct the API message */
2986 M(DELETE_LOOPBACK, delete_loopback);
2987 mp->sw_if_index = ntohl (sw_if_index);
2992 static int api_want_stats (vat_main_t * vam)
2994 unformat_input_t * i = vam->input;
2995 vl_api_want_stats_t * mp;
2999 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3001 if (unformat (i, "enable"))
3003 else if (unformat (i, "disable"))
3011 errmsg ("missing enable|disable\n");
3015 M(WANT_STATS, want_stats);
3016 mp->enable_disable = enable;
3021 static int api_want_interface_events (vat_main_t * vam)
3023 unformat_input_t * i = vam->input;
3024 vl_api_want_interface_events_t * mp;
3028 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
3030 if (unformat (i, "enable"))
3032 else if (unformat (i, "disable"))
3040 errmsg ("missing enable|disable\n");
3044 M(WANT_INTERFACE_EVENTS, want_interface_events);
3045 mp->enable_disable = enable;
3047 vam->interface_event_display = enable;
3053 /* Note: non-static, called once to set up the initial intfc table */
3054 int api_sw_interface_dump (vat_main_t * vam)
3056 vl_api_sw_interface_dump_t *mp;
3059 name_sort_t * nses = 0, * ns;
3060 sw_interface_subif_t * sub = NULL;
3062 /* Toss the old name table */
3063 hash_foreach_pair (p, vam->sw_if_index_by_interface_name,
3065 vec_add2 (nses, ns, 1);
3066 ns->name = (u8 *)(p->key);
3067 ns->value = (u32) p->value[0];
3070 hash_free (vam->sw_if_index_by_interface_name);
3072 vec_foreach (ns, nses)
3073 vec_free (ns->name);
3077 vec_foreach (sub, vam->sw_if_subif_table) {
3078 vec_free (sub->interface_name);
3080 vec_free (vam->sw_if_subif_table);
3082 /* recreate the interface name hash table */
3083 vam->sw_if_index_by_interface_name
3084 = hash_create_string (0, sizeof(uword));
3086 /* Get list of ethernets */
3087 M(SW_INTERFACE_DUMP, sw_interface_dump);
3088 mp->name_filter_valid = 1;
3089 strncpy ((char *) mp->name_filter, "Ether", sizeof(mp->name_filter)-1);
3092 /* and local / loopback interfaces */
3093 M(SW_INTERFACE_DUMP, sw_interface_dump);
3094 mp->name_filter_valid = 1;
3095 strncpy ((char *) mp->name_filter, "lo", sizeof(mp->name_filter)-1);
3098 /* and vxlan tunnel interfaces */
3099 M(SW_INTERFACE_DUMP, sw_interface_dump);
3100 mp->name_filter_valid = 1;
3101 strncpy ((char *) mp->name_filter, "vxlan", sizeof(mp->name_filter)-1);
3104 /* and host (af_packet) interfaces */
3105 M(SW_INTERFACE_DUMP, sw_interface_dump);
3106 mp->name_filter_valid = 1;
3107 strncpy ((char *) mp->name_filter, "host", sizeof(mp->name_filter)-1);
3110 /* and l2tpv3 tunnel interfaces */
3111 M(SW_INTERFACE_DUMP, sw_interface_dump);
3112 mp->name_filter_valid = 1;
3113 strncpy ((char *) mp->name_filter, "l2tpv3_tunnel", sizeof(mp->name_filter)-1);
3116 /* and GRE tunnel interfaces */
3117 M(SW_INTERFACE_DUMP, sw_interface_dump);
3118 mp->name_filter_valid = 1;
3119 strncpy ((char *) mp->name_filter, "gre", sizeof(mp->name_filter)-1);
3122 /* Use a control ping for synchronization */
3124 vl_api_control_ping_t * mp;
3125 M(CONTROL_PING, control_ping);
3131 static int api_sw_interface_set_flags (vat_main_t * vam)
3133 unformat_input_t * i = vam->input;
3134 vl_api_sw_interface_set_flags_t *mp;
3137 u8 sw_if_index_set = 0;
3138 u8 admin_up = 0, link_up = 0;
3140 /* Parse args required to build the message */
3141 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3142 if (unformat (i, "admin-up"))
3144 else if (unformat (i, "admin-down"))
3146 else if (unformat (i, "link-up"))
3148 else if (unformat (i, "link-down"))
3150 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3151 sw_if_index_set = 1;
3152 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3153 sw_if_index_set = 1;
3158 if (sw_if_index_set == 0) {
3159 errmsg ("missing interface name or sw_if_index\n");
3163 /* Construct the API message */
3164 M(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags);
3165 mp->sw_if_index = ntohl (sw_if_index);
3166 mp->admin_up_down = admin_up;
3167 mp->link_up_down = link_up;
3172 /* Wait for a reply, return the good/bad news... */
3176 static int api_sw_interface_clear_stats (vat_main_t * vam)
3178 unformat_input_t * i = vam->input;
3179 vl_api_sw_interface_clear_stats_t *mp;
3182 u8 sw_if_index_set = 0;
3184 /* Parse args required to build the message */
3185 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3186 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3187 sw_if_index_set = 1;
3188 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3189 sw_if_index_set = 1;
3194 /* Construct the API message */
3195 M(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats);
3197 if (sw_if_index_set == 1)
3198 mp->sw_if_index = ntohl (sw_if_index);
3200 mp->sw_if_index = ~0;
3205 /* Wait for a reply, return the good/bad news... */
3209 static int api_sw_interface_add_del_address (vat_main_t * vam)
3211 unformat_input_t * i = vam->input;
3212 vl_api_sw_interface_add_del_address_t *mp;
3215 u8 sw_if_index_set = 0;
3216 u8 is_add = 1, del_all = 0;
3217 u32 address_length = 0;
3218 u8 v4_address_set = 0;
3219 u8 v6_address_set = 0;
3220 ip4_address_t v4address;
3221 ip6_address_t v6address;
3223 /* Parse args required to build the message */
3224 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3225 if (unformat (i, "del-all"))
3227 else if (unformat (i, "del"))
3229 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3230 sw_if_index_set = 1;
3231 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3232 sw_if_index_set = 1;
3233 else if (unformat (i, "%U/%d",
3234 unformat_ip4_address, &v4address,
3237 else if (unformat (i, "%U/%d",
3238 unformat_ip6_address, &v6address,
3245 if (sw_if_index_set == 0) {
3246 errmsg ("missing interface name or sw_if_index\n");
3249 if (v4_address_set && v6_address_set) {
3250 errmsg ("both v4 and v6 addresses set\n");
3253 if (!v4_address_set && !v6_address_set && !del_all) {
3254 errmsg ("no addresses set\n");
3258 /* Construct the API message */
3259 M(SW_INTERFACE_ADD_DEL_ADDRESS, sw_interface_add_del_address);
3261 mp->sw_if_index = ntohl (sw_if_index);
3262 mp->is_add = is_add;
3263 mp->del_all = del_all;
3264 if (v6_address_set) {
3266 clib_memcpy (mp->address, &v6address, sizeof (v6address));
3268 clib_memcpy (mp->address, &v4address, sizeof (v4address));
3270 mp->address_length = address_length;
3275 /* Wait for a reply, return good/bad news */
3279 static int api_sw_interface_set_table (vat_main_t * vam)
3281 unformat_input_t * i = vam->input;
3282 vl_api_sw_interface_set_table_t *mp;
3284 u32 sw_if_index, vrf_id = 0;
3285 u8 sw_if_index_set = 0;
3288 /* Parse args required to build the message */
3289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3290 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3291 sw_if_index_set = 1;
3292 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3293 sw_if_index_set = 1;
3294 else if (unformat (i, "vrf %d", &vrf_id))
3296 else if (unformat (i, "ipv6"))
3302 if (sw_if_index_set == 0) {
3303 errmsg ("missing interface name or sw_if_index\n");
3307 /* Construct the API message */
3308 M(SW_INTERFACE_SET_TABLE, sw_interface_set_table);
3310 mp->sw_if_index = ntohl (sw_if_index);
3311 mp->is_ipv6 = is_ipv6;
3312 mp->vrf_id = ntohl (vrf_id);
3317 /* Wait for a reply... */
3321 static int api_sw_interface_set_vpath (vat_main_t * vam)
3323 unformat_input_t * i = vam->input;
3324 vl_api_sw_interface_set_vpath_t *mp;
3326 u32 sw_if_index = 0;
3327 u8 sw_if_index_set = 0;
3330 /* Parse args required to build the message */
3331 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3332 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3333 sw_if_index_set = 1;
3334 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3335 sw_if_index_set = 1;
3336 else if (unformat (i, "enable"))
3338 else if (unformat (i, "disable"))
3344 if (sw_if_index_set == 0) {
3345 errmsg ("missing interface name or sw_if_index\n");
3349 /* Construct the API message */
3350 M(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath);
3352 mp->sw_if_index = ntohl (sw_if_index);
3353 mp->enable = is_enable;
3358 /* Wait for a reply... */
3362 static int api_sw_interface_set_l2_xconnect (vat_main_t * vam)
3364 unformat_input_t * i = vam->input;
3365 vl_api_sw_interface_set_l2_xconnect_t *mp;
3368 u8 rx_sw_if_index_set = 0;
3370 u8 tx_sw_if_index_set = 0;
3373 /* Parse args required to build the message */
3374 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3375 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
3376 rx_sw_if_index_set = 1;
3377 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
3378 tx_sw_if_index_set = 1;
3379 else if (unformat (i, "rx")) {
3380 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3381 if (unformat (i, "%U", unformat_sw_if_index, vam,
3383 rx_sw_if_index_set = 1;
3386 } else if (unformat (i, "tx")) {
3387 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3388 if (unformat (i, "%U", unformat_sw_if_index, vam,
3390 tx_sw_if_index_set = 1;
3393 } else if (unformat (i, "enable"))
3395 else if (unformat (i, "disable"))
3401 if (rx_sw_if_index_set == 0) {
3402 errmsg ("missing rx interface name or rx_sw_if_index\n");
3406 if (enable && (tx_sw_if_index_set == 0)) {
3407 errmsg ("missing tx interface name or tx_sw_if_index\n");
3411 M(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect);
3413 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3414 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
3415 mp->enable = enable;
3422 static int api_sw_interface_set_l2_bridge (vat_main_t * vam)
3424 unformat_input_t * i = vam->input;
3425 vl_api_sw_interface_set_l2_bridge_t *mp;
3428 u8 rx_sw_if_index_set = 0;
3435 /* Parse args required to build the message */
3436 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3437 if (unformat (i, "sw_if_index %d", &rx_sw_if_index))
3438 rx_sw_if_index_set = 1;
3439 else if (unformat (i, "bd_id %d", &bd_id))
3441 else if (unformat (i, "%U", unformat_sw_if_index, vam,
3443 rx_sw_if_index_set = 1;
3444 else if (unformat (i, "shg %d", &shg))
3446 else if (unformat (i, "bvi"))
3448 else if (unformat (i, "enable"))
3450 else if (unformat (i, "disable"))
3456 if (rx_sw_if_index_set == 0) {
3457 errmsg ("missing rx interface name or sw_if_index\n");
3461 if (enable && (bd_id_set == 0)) {
3462 errmsg ("missing bridge domain\n");
3466 M(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge);
3468 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
3469 mp->bd_id = ntohl(bd_id);
3472 mp->enable = enable;
3479 static int api_bridge_domain_dump (vat_main_t * vam)
3481 unformat_input_t * i = vam->input;
3482 vl_api_bridge_domain_dump_t *mp;
3486 /* Parse args required to build the message */
3487 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3488 if (unformat (i, "bd_id %d", &bd_id))
3494 M(BRIDGE_DOMAIN_DUMP, bridge_domain_dump);
3495 mp->bd_id = ntohl(bd_id);
3498 /* Use a control ping for synchronization */
3500 vl_api_control_ping_t * mp;
3501 M(CONTROL_PING, control_ping);
3510 static int api_bridge_domain_add_del (vat_main_t * vam)
3512 unformat_input_t * i = vam->input;
3513 vl_api_bridge_domain_add_del_t *mp;
3517 u32 flood = 1, forward = 1, learn = 1, uu_flood = 1, arp_term = 0;
3519 /* Parse args required to build the message */
3520 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3521 if (unformat (i, "bd_id %d", &bd_id))
3523 else if (unformat (i, "flood %d", &flood))
3525 else if (unformat (i, "uu-flood %d", &uu_flood))
3527 else if (unformat (i, "forward %d", &forward))
3529 else if (unformat (i, "learn %d", &learn))
3531 else if (unformat (i, "arp-term %d", &arp_term))
3533 else if (unformat (i, "del")) {
3535 flood = uu_flood = forward = learn = 0;
3542 errmsg ("missing bridge domain\n");
3546 M(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del);
3548 mp->bd_id = ntohl(bd_id);
3550 mp->uu_flood = uu_flood;
3551 mp->forward = forward;
3553 mp->arp_term = arp_term;
3554 mp->is_add = is_add;
3561 static int api_l2fib_add_del (vat_main_t * vam)
3563 unformat_input_t * i = vam->input;
3564 vl_api_l2fib_add_del_t *mp;
3571 u8 sw_if_index_set = 0;
3576 /* Parse args required to build the message */
3577 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3578 if (unformat (i, "mac %U", unformat_ethernet_address, &mac))
3580 else if (unformat (i, "bd_id %d", &bd_id))
3582 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3583 sw_if_index_set = 1;
3584 else if (unformat (i, "sw_if")) {
3585 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3586 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3587 sw_if_index_set = 1;
3590 } else if (unformat (i, "static"))
3592 else if (unformat (i, "filter")) {
3595 } else if (unformat (i, "del"))
3602 errmsg ("missing mac address\n");
3606 if (bd_id_set == 0) {
3607 errmsg ("missing bridge domain\n");
3611 if (is_add && (sw_if_index_set == 0)) {
3612 errmsg ("missing interface name or sw_if_index\n");
3616 M(L2FIB_ADD_DEL, l2fib_add_del);
3619 mp->bd_id = ntohl(bd_id);
3620 mp->is_add = is_add;
3623 mp->sw_if_index = ntohl(sw_if_index);
3624 mp->static_mac = static_mac;
3625 mp->filter_mac = filter_mac;
3633 static int api_l2_flags (vat_main_t * vam)
3635 unformat_input_t * i = vam->input;
3636 vl_api_l2_flags_t *mp;
3639 u32 feature_bitmap = 0;
3640 u8 sw_if_index_set = 0;
3642 /* Parse args required to build the message */
3643 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3644 if (unformat (i, "sw_if_index %d", &sw_if_index))
3645 sw_if_index_set = 1;
3646 else if (unformat (i, "sw_if")) {
3647 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3648 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3649 sw_if_index_set = 1;
3652 } else if (unformat (i, "learn"))
3653 feature_bitmap |= L2INPUT_FEAT_LEARN;
3654 else if (unformat (i, "forward"))
3655 feature_bitmap |= L2INPUT_FEAT_FWD;
3656 else if (unformat (i, "flood"))
3657 feature_bitmap |= L2INPUT_FEAT_FLOOD;
3658 else if (unformat (i, "uu-flood"))
3659 feature_bitmap |= L2INPUT_FEAT_UU_FLOOD;
3664 if (sw_if_index_set == 0) {
3665 errmsg ("missing interface name or sw_if_index\n");
3669 M(L2_FLAGS, l2_flags);
3671 mp->sw_if_index = ntohl(sw_if_index);
3672 mp->feature_bitmap = ntohl(feature_bitmap);
3679 static int api_bridge_flags (vat_main_t * vam)
3681 unformat_input_t * i = vam->input;
3682 vl_api_bridge_flags_t *mp;
3689 /* Parse args required to build the message */
3690 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3691 if (unformat (i, "bd_id %d", &bd_id))
3693 else if (unformat (i, "learn"))
3695 else if (unformat (i, "forward"))
3697 else if (unformat (i, "flood"))
3699 else if (unformat (i, "uu-flood"))
3700 flags |= L2_UU_FLOOD;
3701 else if (unformat (i, "arp-term"))
3702 flags |= L2_ARP_TERM;
3703 else if (unformat (i, "off"))
3705 else if (unformat (i, "disable"))
3711 if (bd_id_set == 0) {
3712 errmsg ("missing bridge domain\n");
3716 M(BRIDGE_FLAGS, bridge_flags);
3718 mp->bd_id = ntohl(bd_id);
3719 mp->feature_bitmap = ntohl(flags);
3720 mp->is_set = is_set;
3727 static int api_bd_ip_mac_add_del (vat_main_t * vam)
3729 unformat_input_t * i = vam->input;
3730 vl_api_bd_ip_mac_add_del_t *mp;
3738 ip4_address_t v4addr;
3739 ip6_address_t v6addr;
3743 /* Parse args required to build the message */
3744 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3745 if (unformat (i, "bd_id %d", &bd_id)) {
3747 } else if (unformat (i, "%U", unformat_ip4_address, &v4addr)) {
3749 } else if (unformat (i, "%U", unformat_ip6_address, &v6addr)) {
3752 } else if (unformat (i, "%U", unformat_ethernet_address, macaddr)) {
3754 } else if (unformat (i, "del"))
3760 if (bd_id_set == 0) {
3761 errmsg ("missing bridge domain\n");
3763 } else if (ip_set == 0) {
3764 errmsg ("missing IP address\n");
3766 } else if (mac_set == 0) {
3767 errmsg ("missing MAC address\n");
3771 M(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del);
3773 mp->bd_id = ntohl(bd_id);
3774 mp->is_ipv6 = is_ipv6;
3775 mp->is_add = is_add;
3777 clib_memcpy (mp->ip_address, &v6addr, sizeof (v6addr));
3778 else clib_memcpy (mp->ip_address, &v4addr, sizeof (v4addr));
3779 clib_memcpy (mp->mac_address, macaddr, 6);
3785 static int api_tap_connect (vat_main_t * vam)
3787 unformat_input_t * i = vam->input;
3788 vl_api_tap_connect_t *mp;
3795 memset (mac_address, 0, sizeof (mac_address));
3797 /* Parse args required to build the message */
3798 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3799 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
3802 else if (unformat (i, "random-mac"))
3804 else if (unformat (i, "tapname %s", &tap_name))
3810 if (name_set == 0) {
3811 errmsg ("missing tap name\n");
3814 if (vec_len (tap_name) > 63) {
3815 errmsg ("tap name too long\n");
3817 vec_add1 (tap_name, 0);
3819 /* Construct the API message */
3820 M(TAP_CONNECT, tap_connect);
3822 mp->use_random_mac = random_mac;
3823 clib_memcpy (mp->mac_address, mac_address, 6);
3824 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
3825 vec_free (tap_name);
3830 /* Wait for a reply... */
3834 static int api_tap_modify (vat_main_t * vam)
3836 unformat_input_t * i = vam->input;
3837 vl_api_tap_modify_t *mp;
3843 u32 sw_if_index = ~0;
3844 u8 sw_if_index_set = 0;
3846 memset (mac_address, 0, sizeof (mac_address));
3848 /* Parse args required to build the message */
3849 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3850 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3851 sw_if_index_set = 1;
3852 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3853 sw_if_index_set = 1;
3854 else if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
3857 else if (unformat (i, "random-mac"))
3859 else if (unformat (i, "tapname %s", &tap_name))
3865 if (sw_if_index_set == 0) {
3866 errmsg ("missing vpp interface name");
3869 if (name_set == 0) {
3870 errmsg ("missing tap name\n");
3873 if (vec_len (tap_name) > 63) {
3874 errmsg ("tap name too long\n");
3876 vec_add1 (tap_name, 0);
3878 /* Construct the API message */
3879 M(TAP_MODIFY, tap_modify);
3881 mp->use_random_mac = random_mac;
3882 mp->sw_if_index = ntohl(sw_if_index);
3883 clib_memcpy (mp->mac_address, mac_address, 6);
3884 clib_memcpy (mp->tap_name, tap_name, vec_len (tap_name));
3885 vec_free (tap_name);
3890 /* Wait for a reply... */
3894 static int api_tap_delete (vat_main_t * vam)
3896 unformat_input_t * i = vam->input;
3897 vl_api_tap_delete_t *mp;
3899 u32 sw_if_index = ~0;
3900 u8 sw_if_index_set = 0;
3902 /* Parse args required to build the message */
3903 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3904 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3905 sw_if_index_set = 1;
3906 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3907 sw_if_index_set = 1;
3912 if (sw_if_index_set == 0) {
3913 errmsg ("missing vpp interface name");
3917 /* Construct the API message */
3918 M(TAP_DELETE, tap_delete);
3920 mp->sw_if_index = ntohl(sw_if_index);
3925 /* Wait for a reply... */
3929 static int api_ip_add_del_route (vat_main_t * vam)
3931 unformat_input_t * i = vam->input;
3932 vl_api_ip_add_del_route_t *mp;
3934 u32 sw_if_index = 0, vrf_id = 0;
3935 u8 sw_if_index_set = 0;
3937 u8 is_local = 0, is_drop = 0;
3938 u8 create_vrf_if_needed = 0;
3940 u8 next_hop_weight = 1;
3942 u8 is_multipath = 0;
3944 u8 address_length_set = 0;
3945 u32 lookup_in_vrf = 0;
3946 u32 resolve_attempts = 0;
3947 u32 dst_address_length = 0;
3948 u8 next_hop_set = 0;
3949 ip4_address_t v4_dst_address, v4_next_hop_address;
3950 ip6_address_t v6_dst_address, v6_next_hop_address;
3954 u32 random_add_del = 0;
3955 u32 * random_vector = 0;
3956 uword * random_hash;
3957 u32 random_seed = 0xdeaddabe;
3958 u32 classify_table_index = ~0;
3961 /* Parse args required to build the message */
3962 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
3963 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
3964 sw_if_index_set = 1;
3965 else if (unformat (i, "sw_if_index %d", &sw_if_index))
3966 sw_if_index_set = 1;
3967 else if (unformat (i, "%U", unformat_ip4_address,
3972 else if (unformat (i, "%U", unformat_ip6_address, &v6_dst_address)) {
3976 else if (unformat (i, "/%d", &dst_address_length)) {
3977 address_length_set = 1;
3980 else if (is_ipv6 == 0 && unformat (i, "via %U", unformat_ip4_address,
3981 &v4_next_hop_address)) {
3984 else if (is_ipv6 == 1 && unformat (i, "via %U", unformat_ip6_address,
3985 &v6_next_hop_address)) {
3988 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
3990 else if (unformat (i, "weight %d", &next_hop_weight))
3992 else if (unformat (i, "drop")) {
3994 } else if (unformat (i, "local")) {
3996 } else if (unformat (i, "classify %d", &classify_table_index)) {
3998 } else if (unformat (i, "del"))
4000 else if (unformat (i, "add"))
4002 else if (unformat (i, "not-last"))
4004 else if (unformat (i, "multipath"))
4006 else if (unformat (i, "vrf %d", &vrf_id))
4008 else if (unformat (i, "create-vrf"))
4009 create_vrf_if_needed = 1;
4010 else if (unformat (i, "count %d", &count))
4012 else if (unformat (i, "lookup-in-vrf %d", &lookup_in_vrf))
4014 else if (unformat (i, "random"))
4016 else if (unformat (i, "seed %d", &random_seed))
4019 clib_warning ("parse error '%U'", format_unformat_error, i);
4024 if (resolve_attempts > 0 && sw_if_index_set == 0) {
4025 errmsg ("ARP resolution needs explicit interface or sw_if_index\n");
4029 if (!next_hop_set && !is_drop && !is_local && !is_classify) {
4030 errmsg ("next hop / local / drop / classify not set\n");
4034 if (address_set == 0) {
4035 errmsg ("missing addresses\n");
4039 if (address_length_set == 0) {
4040 errmsg ("missing address length\n");
4044 /* Generate a pile of unique, random routes */
4045 if (random_add_del) {
4046 u32 this_random_address;
4047 random_hash = hash_create (count, sizeof(uword));
4049 hash_set (random_hash, v4_next_hop_address.as_u32, 1);
4050 for (j = 0; j <= count; j++) {
4052 this_random_address = random_u32 (&random_seed);
4053 this_random_address =
4054 clib_host_to_net_u32 (this_random_address);
4055 } while (hash_get (random_hash, this_random_address));
4056 vec_add1 (random_vector, this_random_address);
4057 hash_set (random_hash, this_random_address, 1);
4059 hash_free (random_hash);
4060 v4_dst_address.as_u32 = random_vector[0];
4064 /* Turn on async mode */
4065 vam->async_mode = 1;
4066 vam->async_errors = 0;
4067 before = vat_time_now(vam);
4070 for (j = 0; j < count; j++) {
4071 /* Construct the API message */
4072 M(IP_ADD_DEL_ROUTE, ip_add_del_route);
4074 mp->next_hop_sw_if_index = ntohl (sw_if_index);
4075 mp->vrf_id = ntohl (vrf_id);
4076 if (resolve_attempts > 0) {
4077 mp->resolve_attempts = ntohl (resolve_attempts);
4078 mp->resolve_if_needed = 1;
4080 mp->create_vrf_if_needed = create_vrf_if_needed;
4082 mp->is_add = is_add;
4083 mp->is_drop = is_drop;
4084 mp->is_ipv6 = is_ipv6;
4085 mp->is_local = is_local;
4086 mp->is_classify = is_classify;
4087 mp->is_multipath = is_multipath;
4088 mp->not_last = not_last;
4089 mp->next_hop_weight = next_hop_weight;
4090 mp->dst_address_length = dst_address_length;
4091 mp->lookup_in_vrf = ntohl(lookup_in_vrf);
4092 mp->classify_table_index = ntohl(classify_table_index);
4095 clib_memcpy (mp->dst_address, &v6_dst_address, sizeof (v6_dst_address));
4097 clib_memcpy (mp->next_hop_address, &v6_next_hop_address,
4098 sizeof (v6_next_hop_address));
4099 increment_v6_address (&v6_dst_address);
4101 clib_memcpy (mp->dst_address, &v4_dst_address, sizeof (v4_dst_address));
4103 clib_memcpy (mp->next_hop_address, &v4_next_hop_address,
4104 sizeof (v4_next_hop_address));
4106 v4_dst_address.as_u32 = random_vector[j+1];
4108 increment_v4_address (&v4_dst_address);
4114 /* When testing multiple add/del ops, use a control-ping to sync */
4116 vl_api_control_ping_t * mp;
4119 /* Shut off async mode */
4120 vam->async_mode = 0;
4122 M(CONTROL_PING, control_ping);
4125 timeout = vat_time_now(vam) + 1.0;
4126 while (vat_time_now (vam) < timeout)
4127 if (vam->result_ready == 1)
4132 if (vam->retval == -99)
4133 errmsg ("timeout\n");
4135 if (vam->async_errors > 0) {
4136 errmsg ("%d asynchronous errors\n", vam->async_errors);
4139 vam->async_errors = 0;
4140 after = vat_time_now(vam);
4142 fformat(vam->ofp, "%d routes in %.6f secs, %.2f routes/sec\n",
4143 count, after - before, count / (after - before));
4145 /* Wait for a reply... */
4149 /* Return the good/bad news */
4150 return (vam->retval);
4153 static int api_proxy_arp_add_del (vat_main_t * vam)
4155 unformat_input_t * i = vam->input;
4156 vl_api_proxy_arp_add_del_t *mp;
4160 ip4_address_t lo, hi;
4163 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4164 if (unformat (i, "vrf %d", &vrf_id))
4166 else if (unformat (i, "%U - %U", unformat_ip4_address, &lo,
4167 unformat_ip4_address, &hi))
4169 else if (unformat (i, "del"))
4172 clib_warning ("parse error '%U'", format_unformat_error, i);
4177 if (range_set == 0) {
4178 errmsg ("address range not set\n");
4182 M(PROXY_ARP_ADD_DEL, proxy_arp_add_del);
4184 mp->vrf_id = ntohl(vrf_id);
4185 mp->is_add = is_add;
4186 clib_memcpy(mp->low_address, &lo, sizeof (mp->low_address));
4187 clib_memcpy(mp->hi_address, &hi, sizeof (mp->hi_address));
4194 static int api_proxy_arp_intfc_enable_disable (vat_main_t * vam)
4196 unformat_input_t * i = vam->input;
4197 vl_api_proxy_arp_intfc_enable_disable_t *mp;
4201 u8 sw_if_index_set = 0;
4203 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4204 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4205 sw_if_index_set = 1;
4206 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4207 sw_if_index_set = 1;
4208 else if (unformat (i, "enable"))
4210 else if (unformat (i, "disable"))
4213 clib_warning ("parse error '%U'", format_unformat_error, i);
4218 if (sw_if_index_set == 0) {
4219 errmsg ("missing interface name or sw_if_index\n");
4223 M(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable);
4225 mp->sw_if_index = ntohl(sw_if_index);
4226 mp->enable_disable = enable;
4233 static int api_mpls_add_del_decap (vat_main_t * vam)
4235 unformat_input_t * i = vam->input;
4236 vl_api_mpls_add_del_decap_t *mp;
4245 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4246 if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4248 else if (unformat (i, "tx_vrf_id %d", &tx_vrf_id))
4250 else if (unformat (i, "label %d", &label))
4252 else if (unformat (i, "next-index %d", &next_index))
4254 else if (unformat (i, "del"))
4256 else if (unformat (i, "s-bit-clear"))
4259 clib_warning ("parse error '%U'", format_unformat_error, i);
4264 M(MPLS_ADD_DEL_DECAP, mpls_add_del_decap);
4266 mp->rx_vrf_id = ntohl(rx_vrf_id);
4267 mp->tx_vrf_id = ntohl(tx_vrf_id);
4268 mp->label = ntohl(label);
4269 mp->next_index = ntohl(next_index);
4271 mp->is_add = is_add;
4278 static int api_mpls_add_del_encap (vat_main_t * vam)
4280 unformat_input_t * i = vam->input;
4281 vl_api_mpls_add_del_encap_t *mp;
4286 ip4_address_t dst_address;
4289 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4290 if (unformat (i, "vrf %d", &vrf_id))
4292 else if (unformat (i, "label %d", &label))
4293 vec_add1 (labels, ntohl(label));
4294 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4296 else if (unformat (i, "del"))
4299 clib_warning ("parse error '%U'", format_unformat_error, i);
4304 if (vec_len (labels) == 0) {
4305 errmsg ("missing encap label stack\n");
4309 M2(MPLS_ADD_DEL_ENCAP, mpls_add_del_encap,
4310 sizeof (u32) * vec_len (labels));
4312 mp->vrf_id = ntohl(vrf_id);
4313 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4314 mp->is_add = is_add;
4315 mp->nlabels = vec_len (labels);
4316 clib_memcpy(mp->labels, labels, sizeof(u32)*mp->nlabels);
4325 static int api_mpls_gre_add_del_tunnel (vat_main_t * vam)
4327 unformat_input_t * i = vam->input;
4328 vl_api_mpls_gre_add_del_tunnel_t *mp;
4330 u32 inner_vrf_id = 0;
4331 u32 outer_vrf_id = 0;
4332 ip4_address_t src_address;
4333 ip4_address_t dst_address;
4334 ip4_address_t intfc_address;
4336 u8 intfc_address_length = 0;
4340 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4341 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4343 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4345 else if (unformat (i, "src %U", unformat_ip4_address, &src_address))
4347 else if (unformat (i, "dst %U", unformat_ip4_address, &dst_address))
4349 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4350 &intfc_address, &tmp))
4351 intfc_address_length = tmp;
4352 else if (unformat (i, "l2-only"))
4354 else if (unformat (i, "del"))
4357 clib_warning ("parse error '%U'", format_unformat_error, i);
4362 M(MPLS_GRE_ADD_DEL_TUNNEL, mpls_gre_add_del_tunnel);
4364 mp->inner_vrf_id = ntohl(inner_vrf_id);
4365 mp->outer_vrf_id = ntohl(outer_vrf_id);
4366 clib_memcpy(mp->src_address, &src_address, sizeof (src_address));
4367 clib_memcpy(mp->dst_address, &dst_address, sizeof (dst_address));
4368 clib_memcpy(mp->intfc_address, &intfc_address, sizeof (intfc_address));
4369 mp->intfc_address_length = intfc_address_length;
4370 mp->l2_only = l2_only;
4371 mp->is_add = is_add;
4378 static int api_mpls_ethernet_add_del_tunnel (vat_main_t * vam)
4380 unformat_input_t * i = vam->input;
4381 vl_api_mpls_ethernet_add_del_tunnel_t *mp;
4383 u32 inner_vrf_id = 0;
4384 ip4_address_t intfc_address;
4385 u8 dst_mac_address[6];
4388 u8 intfc_address_length = 0;
4392 int tx_sw_if_index_set = 0;
4394 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4395 if (unformat (i, "vrf %d", &inner_vrf_id))
4397 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4398 &intfc_address, &tmp))
4399 intfc_address_length = tmp;
4400 else if (unformat (i, "%U",
4401 unformat_sw_if_index, vam, &tx_sw_if_index))
4402 tx_sw_if_index_set = 1;
4403 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
4404 tx_sw_if_index_set = 1;
4405 else if (unformat (i, "dst %U", unformat_ethernet_address,
4408 else if (unformat (i, "l2-only"))
4410 else if (unformat (i, "del"))
4413 clib_warning ("parse error '%U'", format_unformat_error, i);
4419 errmsg ("dst (mac address) not set\n");
4422 if (!tx_sw_if_index_set) {
4423 errmsg ("tx-intfc not set\n");
4427 M(MPLS_ETHERNET_ADD_DEL_TUNNEL, mpls_ethernet_add_del_tunnel);
4429 mp->vrf_id = ntohl(inner_vrf_id);
4430 clib_memcpy (mp->adj_address, &intfc_address, sizeof (intfc_address));
4431 mp->adj_address_length = intfc_address_length;
4432 clib_memcpy (mp->dst_mac_address, dst_mac_address, sizeof (dst_mac_address));
4433 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
4434 mp->l2_only = l2_only;
4435 mp->is_add = is_add;
4442 static int api_mpls_ethernet_add_del_tunnel_2 (vat_main_t * vam)
4444 unformat_input_t * i = vam->input;
4445 vl_api_mpls_ethernet_add_del_tunnel_2_t *mp;
4447 u32 inner_vrf_id = 0;
4448 u32 outer_vrf_id = 0;
4449 ip4_address_t adj_address;
4450 int adj_address_set = 0;
4451 ip4_address_t next_hop_address;
4452 int next_hop_address_set = 0;
4454 u8 adj_address_length = 0;
4457 u32 resolve_attempts = 5;
4458 u8 resolve_if_needed = 1;
4460 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4461 if (unformat (i, "inner_vrf_id %d", &inner_vrf_id))
4463 else if (unformat (i, "outer_vrf_id %d", &outer_vrf_id))
4465 else if (unformat (i, "adj %U/%d", unformat_ip4_address,
4466 &adj_address, &tmp)) {
4467 adj_address_length = tmp;
4468 adj_address_set = 1;
4470 else if (unformat (i, "next-hop %U", unformat_ip4_address,
4472 next_hop_address_set = 1;
4473 else if (unformat (i, "resolve-attempts %d", &resolve_attempts))
4475 else if (unformat (i, "resolve-if-needed %d", &tmp))
4476 resolve_if_needed = tmp;
4477 else if (unformat (i, "l2-only"))
4479 else if (unformat (i, "del"))
4482 clib_warning ("parse error '%U'", format_unformat_error, i);
4487 if (!adj_address_set) {
4488 errmsg ("adjacency address/mask not set\n");
4491 if (!next_hop_address_set) {
4492 errmsg ("ip4 next hop address (in outer fib) not set\n");
4496 M(MPLS_ETHERNET_ADD_DEL_TUNNEL_2, mpls_ethernet_add_del_tunnel_2);
4498 mp->inner_vrf_id = ntohl(inner_vrf_id);
4499 mp->outer_vrf_id = ntohl(outer_vrf_id);
4500 mp->resolve_attempts = ntohl(resolve_attempts);
4501 mp->resolve_if_needed = resolve_if_needed;
4502 mp->is_add = is_add;
4503 mp->l2_only = l2_only;
4504 clib_memcpy (mp->adj_address, &adj_address, sizeof (adj_address));
4505 mp->adj_address_length = adj_address_length;
4506 clib_memcpy (mp->next_hop_ip4_address_in_outer_vrf, &next_hop_address,
4507 sizeof (next_hop_address));
4514 static int api_sw_interface_set_unnumbered (vat_main_t * vam)
4516 unformat_input_t * i = vam->input;
4517 vl_api_sw_interface_set_unnumbered_t *mp;
4522 u8 sw_if_index_set = 0;
4524 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4525 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4526 sw_if_index_set = 1;
4527 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4528 sw_if_index_set = 1;
4529 else if (unformat (i, "unnum_if_index %d", &unnum_sw_index))
4531 else if (unformat (i, "del"))
4534 clib_warning ("parse error '%U'", format_unformat_error, i);
4539 if (sw_if_index_set == 0) {
4540 errmsg ("missing interface name or sw_if_index\n");
4544 M(SW_INTERFACE_SET_UNNUMBERED, sw_interface_set_unnumbered);
4546 mp->sw_if_index = ntohl(sw_if_index);
4547 mp->unnumbered_sw_if_index = ntohl(unnum_sw_index);
4548 mp->is_add = is_add;
4555 static int api_ip_neighbor_add_del (vat_main_t * vam)
4557 unformat_input_t * i = vam->input;
4558 vl_api_ip_neighbor_add_del_t *mp;
4561 u8 sw_if_index_set = 0;
4567 u8 v4_address_set = 0;
4568 u8 v6_address_set = 0;
4569 ip4_address_t v4address;
4570 ip6_address_t v6address;
4572 memset (mac_address, 0, sizeof (mac_address));
4574 /* Parse args required to build the message */
4575 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4576 if (unformat (i, "mac %U", unformat_ethernet_address, mac_address)) {
4579 else if (unformat (i, "del"))
4581 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4582 sw_if_index_set = 1;
4583 else if (unformat (i, "sw_if_index %d", &sw_if_index))
4584 sw_if_index_set = 1;
4585 else if (unformat (i, "is_static"))
4587 else if (unformat (i, "vrf %d", &vrf_id))
4589 else if (unformat (i, "dst %U",
4590 unformat_ip4_address, &v4address))
4592 else if (unformat (i, "dst %U",
4593 unformat_ip6_address, &v6address))
4596 clib_warning ("parse error '%U'", format_unformat_error, i);
4601 if (sw_if_index_set == 0) {
4602 errmsg ("missing interface name or sw_if_index\n");
4605 if (v4_address_set && v6_address_set) {
4606 errmsg ("both v4 and v6 addresses set\n");
4609 if (!v4_address_set && !v6_address_set) {
4610 errmsg ("no addresses set\n");
4614 /* Construct the API message */
4615 M(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del);
4617 mp->sw_if_index = ntohl (sw_if_index);
4618 mp->is_add = is_add;
4619 mp->vrf_id = ntohl (vrf_id);
4620 mp->is_static = is_static;
4622 clib_memcpy (mp->mac_address, mac_address, 6);
4623 if (v6_address_set) {
4625 clib_memcpy (mp->dst_address, &v6address, sizeof (v6address));
4627 /* mp->is_ipv6 = 0; via memset in M macro above */
4628 clib_memcpy (mp->dst_address, &v4address, sizeof (v4address));
4634 /* Wait for a reply, return good/bad news */
4641 static int api_reset_vrf (vat_main_t * vam)
4643 unformat_input_t * i = vam->input;
4644 vl_api_reset_vrf_t *mp;
4650 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4651 if (unformat (i, "vrf %d", &vrf_id))
4653 else if (unformat (i, "ipv6"))
4656 clib_warning ("parse error '%U'", format_unformat_error, i);
4661 if (vrf_id_set == 0) {
4662 errmsg ("missing vrf id\n");
4666 M(RESET_VRF, reset_vrf);
4668 mp->vrf_id = ntohl(vrf_id);
4669 mp->is_ipv6 = is_ipv6;
4676 static int api_create_vlan_subif (vat_main_t * vam)
4678 unformat_input_t * i = vam->input;
4679 vl_api_create_vlan_subif_t *mp;
4682 u8 sw_if_index_set = 0;
4686 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4687 if (unformat (i, "sw_if_index %d", &sw_if_index))
4688 sw_if_index_set = 1;
4689 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4690 sw_if_index_set = 1;
4691 else if (unformat (i, "vlan %d", &vlan_id))
4694 clib_warning ("parse error '%U'", format_unformat_error, i);
4699 if (sw_if_index_set == 0) {
4700 errmsg ("missing interface name or sw_if_index\n");
4704 if (vlan_id_set == 0) {
4705 errmsg ("missing vlan_id\n");
4708 M(CREATE_VLAN_SUBIF, create_vlan_subif);
4710 mp->sw_if_index = ntohl(sw_if_index);
4711 mp->vlan_id = ntohl(vlan_id);
4718 #define foreach_create_subif_bit \
4725 _(outer_vlan_id_any) \
4726 _(inner_vlan_id_any)
4728 static int api_create_subif (vat_main_t * vam)
4730 unformat_input_t * i = vam->input;
4731 vl_api_create_subif_t *mp;
4734 u8 sw_if_index_set = 0;
4741 u32 exact_match = 0;
4742 u32 default_sub = 0;
4743 u32 outer_vlan_id_any = 0;
4744 u32 inner_vlan_id_any = 0;
4746 u16 outer_vlan_id = 0;
4747 u16 inner_vlan_id = 0;
4749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4750 if (unformat (i, "sw_if_index %d", &sw_if_index))
4751 sw_if_index_set = 1;
4752 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
4753 sw_if_index_set = 1;
4754 else if (unformat (i, "sub_id %d", &sub_id))
4756 else if (unformat (i, "outer_vlan_id %d", &tmp))
4757 outer_vlan_id = tmp;
4758 else if (unformat (i, "inner_vlan_id %d", &tmp))
4759 inner_vlan_id = tmp;
4761 #define _(a) else if (unformat (i, #a)) a = 1 ;
4762 foreach_create_subif_bit
4766 clib_warning ("parse error '%U'", format_unformat_error, i);
4771 if (sw_if_index_set == 0) {
4772 errmsg ("missing interface name or sw_if_index\n");
4776 if (sub_id_set == 0) {
4777 errmsg ("missing sub_id\n");
4780 M(CREATE_SUBIF, create_subif);
4782 mp->sw_if_index = ntohl(sw_if_index);
4783 mp->sub_id = ntohl(sub_id);
4785 #define _(a) mp->a = a;
4786 foreach_create_subif_bit;
4789 mp->outer_vlan_id = ntohs (outer_vlan_id);
4790 mp->inner_vlan_id = ntohs (inner_vlan_id);
4797 static int api_oam_add_del (vat_main_t * vam)
4799 unformat_input_t * i = vam->input;
4800 vl_api_oam_add_del_t *mp;
4804 ip4_address_t src, dst;
4808 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4809 if (unformat (i, "vrf %d", &vrf_id))
4811 else if (unformat (i, "src %U", unformat_ip4_address, &src))
4813 else if (unformat (i, "dst %U", unformat_ip4_address, &dst))
4815 else if (unformat (i, "del"))
4818 clib_warning ("parse error '%U'", format_unformat_error, i);
4824 errmsg ("missing src addr\n");
4829 errmsg ("missing dst addr\n");
4833 M(OAM_ADD_DEL, oam_add_del);
4835 mp->vrf_id = ntohl(vrf_id);
4836 mp->is_add = is_add;
4837 clib_memcpy(mp->src_address, &src, sizeof (mp->src_address));
4838 clib_memcpy(mp->dst_address, &dst, sizeof (mp->dst_address));
4845 static int api_reset_fib (vat_main_t * vam)
4847 unformat_input_t * i = vam->input;
4848 vl_api_reset_fib_t *mp;
4854 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4855 if (unformat (i, "vrf %d", &vrf_id))
4857 else if (unformat (i, "ipv6"))
4860 clib_warning ("parse error '%U'", format_unformat_error, i);
4865 if (vrf_id_set == 0) {
4866 errmsg ("missing vrf id\n");
4870 M(RESET_FIB, reset_fib);
4872 mp->vrf_id = ntohl(vrf_id);
4873 mp->is_ipv6 = is_ipv6;
4880 static int api_dhcp_proxy_config (vat_main_t * vam)
4882 unformat_input_t * i = vam->input;
4883 vl_api_dhcp_proxy_config_t *mp;
4888 u8 v4_address_set = 0;
4889 u8 v6_address_set = 0;
4890 ip4_address_t v4address;
4891 ip6_address_t v6address;
4892 u8 v4_src_address_set = 0;
4893 u8 v6_src_address_set = 0;
4894 ip4_address_t v4srcaddress;
4895 ip6_address_t v6srcaddress;
4897 /* Parse args required to build the message */
4898 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4899 if (unformat (i, "del"))
4901 else if (unformat (i, "vrf %d", &vrf_id))
4903 else if (unformat (i, "insert-cid %d", &insert_cid))
4905 else if (unformat (i, "svr %U",
4906 unformat_ip4_address, &v4address))
4908 else if (unformat (i, "svr %U",
4909 unformat_ip6_address, &v6address))
4911 else if (unformat (i, "src %U",
4912 unformat_ip4_address, &v4srcaddress))
4913 v4_src_address_set = 1;
4914 else if (unformat (i, "src %U",
4915 unformat_ip6_address, &v6srcaddress))
4916 v6_src_address_set = 1;
4921 if (v4_address_set && v6_address_set) {
4922 errmsg ("both v4 and v6 server addresses set\n");
4925 if (!v4_address_set && !v6_address_set) {
4926 errmsg ("no server addresses set\n");
4930 if (v4_src_address_set && v6_src_address_set) {
4931 errmsg ("both v4 and v6 src addresses set\n");
4934 if (!v4_src_address_set && !v6_src_address_set) {
4935 errmsg ("no src addresses set\n");
4939 if (!(v4_src_address_set && v4_address_set) &&
4940 !(v6_src_address_set && v6_address_set)) {
4941 errmsg ("no matching server and src addresses set\n");
4945 /* Construct the API message */
4946 M(DHCP_PROXY_CONFIG, dhcp_proxy_config);
4948 mp->insert_circuit_id = insert_cid;
4949 mp->is_add = is_add;
4950 mp->vrf_id = ntohl (vrf_id);
4951 if (v6_address_set) {
4953 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
4954 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
4956 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
4957 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
4963 /* Wait for a reply, return good/bad news */
4969 static int api_dhcp_proxy_config_2 (vat_main_t * vam)
4971 unformat_input_t * i = vam->input;
4972 vl_api_dhcp_proxy_config_2_t *mp;
4975 u32 server_vrf_id = 0;
4978 u8 v4_address_set = 0;
4979 u8 v6_address_set = 0;
4980 ip4_address_t v4address;
4981 ip6_address_t v6address;
4982 u8 v4_src_address_set = 0;
4983 u8 v6_src_address_set = 0;
4984 ip4_address_t v4srcaddress;
4985 ip6_address_t v6srcaddress;
4987 /* Parse args required to build the message */
4988 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
4989 if (unformat (i, "del"))
4991 else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
4993 else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
4995 else if (unformat (i, "insert-cid %d", &insert_cid))
4997 else if (unformat (i, "svr %U",
4998 unformat_ip4_address, &v4address))
5000 else if (unformat (i, "svr %U",
5001 unformat_ip6_address, &v6address))
5003 else if (unformat (i, "src %U",
5004 unformat_ip4_address, &v4srcaddress))
5005 v4_src_address_set = 1;
5006 else if (unformat (i, "src %U",
5007 unformat_ip6_address, &v6srcaddress))
5008 v6_src_address_set = 1;
5013 if (v4_address_set && v6_address_set) {
5014 errmsg ("both v4 and v6 server addresses set\n");
5017 if (!v4_address_set && !v6_address_set) {
5018 errmsg ("no server addresses set\n");
5022 if (v4_src_address_set && v6_src_address_set) {
5023 errmsg ("both v4 and v6 src addresses set\n");
5026 if (!v4_src_address_set && !v6_src_address_set) {
5027 errmsg ("no src addresses set\n");
5031 if (!(v4_src_address_set && v4_address_set) &&
5032 !(v6_src_address_set && v6_address_set)) {
5033 errmsg ("no matching server and src addresses set\n");
5037 /* Construct the API message */
5038 M(DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2);
5040 mp->insert_circuit_id = insert_cid;
5041 mp->is_add = is_add;
5042 mp->rx_vrf_id = ntohl (rx_vrf_id);
5043 mp->server_vrf_id = ntohl (server_vrf_id);
5044 if (v6_address_set) {
5046 clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
5047 clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
5049 clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
5050 clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
5056 /* Wait for a reply, return good/bad news */
5062 static int api_dhcp_proxy_set_vss (vat_main_t * vam)
5064 unformat_input_t * i = vam->input;
5065 vl_api_dhcp_proxy_set_vss_t *mp;
5076 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5077 if (unformat (i, "tbl_id %d", &tbl_id))
5079 if (unformat (i, "fib_id %d", &fib_id))
5081 if (unformat (i, "oui %d", &oui))
5083 else if (unformat (i, "ipv6"))
5085 else if (unformat (i, "del"))
5088 clib_warning ("parse error '%U'", format_unformat_error, i);
5093 if (tbl_id_set == 0) {
5094 errmsg ("missing tbl id\n");
5098 if (fib_id_set == 0) {
5099 errmsg ("missing fib id\n");
5103 errmsg ("missing oui\n");
5107 M(DHCP_PROXY_SET_VSS, dhcp_proxy_set_vss);
5108 mp->tbl_id = ntohl(tbl_id);
5109 mp->fib_id = ntohl(fib_id);
5110 mp->oui = ntohl(oui);
5111 mp->is_ipv6 = is_ipv6;
5112 mp->is_add = is_add;
5119 static int api_dhcp_client_config (vat_main_t * vam)
5121 unformat_input_t * i = vam->input;
5122 vl_api_dhcp_client_config_t *mp;
5125 u8 sw_if_index_set = 0;
5128 u8 disable_event = 0;
5130 /* Parse args required to build the message */
5131 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5132 if (unformat (i, "del"))
5134 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5135 sw_if_index_set = 1;
5136 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5137 sw_if_index_set = 1;
5138 else if (unformat (i, "hostname %s", &hostname))
5140 else if (unformat (i, "disable_event"))
5146 if (sw_if_index_set == 0) {
5147 errmsg ("missing interface name or sw_if_index\n");
5151 if (vec_len (hostname) > 63) {
5152 errmsg ("hostname too long\n");
5154 vec_add1 (hostname, 0);
5156 /* Construct the API message */
5157 M(DHCP_CLIENT_CONFIG, dhcp_client_config);
5159 mp->sw_if_index = ntohl (sw_if_index);
5160 clib_memcpy (mp->hostname, hostname, vec_len (hostname));
5161 vec_free (hostname);
5162 mp->is_add = is_add;
5163 mp->want_dhcp_event = disable_event ? 0 : 1;
5169 /* Wait for a reply, return good/bad news */
5175 static int api_set_ip_flow_hash (vat_main_t * vam)
5177 unformat_input_t * i = vam->input;
5178 vl_api_set_ip_flow_hash_t *mp;
5190 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5191 if (unformat (i, "vrf %d", &vrf_id))
5193 else if (unformat (i, "ipv6"))
5195 else if (unformat (i, "src"))
5197 else if (unformat (i, "dst"))
5199 else if (unformat (i, "sport"))
5201 else if (unformat (i, "dport"))
5203 else if (unformat (i, "proto"))
5205 else if (unformat (i, "reverse"))
5209 clib_warning ("parse error '%U'", format_unformat_error, i);
5214 if (vrf_id_set == 0) {
5215 errmsg ("missing vrf id\n");
5219 M(SET_IP_FLOW_HASH, set_ip_flow_hash);
5225 mp->reverse = reverse;
5226 mp->vrf_id = ntohl(vrf_id);
5227 mp->is_ipv6 = is_ipv6;
5234 static int api_sw_interface_ip6_enable_disable (vat_main_t * vam)
5236 unformat_input_t * i = vam->input;
5237 vl_api_sw_interface_ip6_enable_disable_t *mp;
5240 u8 sw_if_index_set = 0;
5243 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5244 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5245 sw_if_index_set = 1;
5246 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5247 sw_if_index_set = 1;
5248 else if (unformat (i, "enable"))
5250 else if (unformat (i, "disable"))
5253 clib_warning ("parse error '%U'", format_unformat_error, i);
5258 if (sw_if_index_set == 0) {
5259 errmsg ("missing interface name or sw_if_index\n");
5263 M(SW_INTERFACE_IP6_ENABLE_DISABLE, sw_interface_ip6_enable_disable);
5265 mp->sw_if_index = ntohl(sw_if_index);
5266 mp->enable = enable;
5273 static int api_sw_interface_ip6_set_link_local_address (vat_main_t * vam)
5275 unformat_input_t * i = vam->input;
5276 vl_api_sw_interface_ip6_set_link_local_address_t *mp;
5279 u8 sw_if_index_set = 0;
5280 u32 address_length = 0;
5281 u8 v6_address_set = 0;
5282 ip6_address_t v6address;
5284 /* Parse args required to build the message */
5285 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5286 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5287 sw_if_index_set = 1;
5288 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5289 sw_if_index_set = 1;
5290 else if (unformat (i, "%U/%d",
5291 unformat_ip6_address, &v6address,
5298 if (sw_if_index_set == 0) {
5299 errmsg ("missing interface name or sw_if_index\n");
5302 if (!v6_address_set) {
5303 errmsg ("no address set\n");
5307 /* Construct the API message */
5308 M(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \
5309 sw_interface_ip6_set_link_local_address);
5311 mp->sw_if_index = ntohl (sw_if_index);
5312 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5313 mp->address_length = address_length;
5318 /* Wait for a reply, return good/bad news */
5326 static int api_sw_interface_ip6nd_ra_prefix (vat_main_t * vam)
5328 unformat_input_t * i = vam->input;
5329 vl_api_sw_interface_ip6nd_ra_prefix_t *mp;
5332 u8 sw_if_index_set = 0;
5333 u32 address_length = 0;
5334 u8 v6_address_set = 0;
5335 ip6_address_t v6address;
5337 u8 no_advertise = 0;
5339 u8 no_autoconfig = 0;
5342 u32 val_lifetime = 0;
5343 u32 pref_lifetime = 0;
5345 /* Parse args required to build the message */
5346 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5347 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5348 sw_if_index_set = 1;
5349 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5350 sw_if_index_set = 1;
5351 else if (unformat (i, "%U/%d",
5352 unformat_ip6_address, &v6address,
5355 else if (unformat (i, "val_life %d", &val_lifetime))
5357 else if (unformat (i, "pref_life %d", &pref_lifetime))
5359 else if (unformat (i, "def"))
5361 else if (unformat (i, "noadv"))
5363 else if (unformat (i, "offl"))
5365 else if (unformat (i, "noauto"))
5367 else if (unformat (i, "nolink"))
5369 else if (unformat (i, "isno"))
5372 clib_warning ("parse error '%U'", format_unformat_error, i);
5377 if (sw_if_index_set == 0) {
5378 errmsg ("missing interface name or sw_if_index\n");
5381 if (!v6_address_set) {
5382 errmsg ("no address set\n");
5386 /* Construct the API message */
5387 M(SW_INTERFACE_IP6ND_RA_PREFIX, sw_interface_ip6nd_ra_prefix);
5389 mp->sw_if_index = ntohl (sw_if_index);
5390 clib_memcpy (mp->address, &v6address, sizeof (v6address));
5391 mp->address_length = address_length;
5392 mp->use_default = use_default;
5393 mp->no_advertise = no_advertise;
5394 mp->off_link = off_link;
5395 mp->no_autoconfig = no_autoconfig;
5396 mp->no_onlink = no_onlink;
5398 mp->val_lifetime = ntohl(val_lifetime);
5399 mp->pref_lifetime = ntohl(pref_lifetime);
5404 /* Wait for a reply, return good/bad news */
5411 static int api_sw_interface_ip6nd_ra_config (vat_main_t * vam)
5413 unformat_input_t * i = vam->input;
5414 vl_api_sw_interface_ip6nd_ra_config_t *mp;
5417 u8 sw_if_index_set = 0;
5422 u8 send_unicast = 0;
5425 u8 default_router = 0;
5426 u32 max_interval = 0;
5427 u32 min_interval = 0;
5429 u32 initial_count = 0;
5430 u32 initial_interval = 0;
5433 /* Parse args required to build the message */
5434 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5435 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
5436 sw_if_index_set = 1;
5437 else if (unformat (i, "sw_if_index %d", &sw_if_index))
5438 sw_if_index_set = 1;
5439 else if (unformat (i, "maxint %d", &max_interval))
5441 else if (unformat (i, "minint %d", &min_interval))
5443 else if (unformat (i, "life %d", &lifetime))
5445 else if (unformat (i, "count %d", &initial_count))
5447 else if (unformat (i, "interval %d", &initial_interval))
5449 else if (unformat (i, "surpress"))
5451 else if (unformat (i, "managed"))
5453 else if (unformat (i, "other"))
5455 else if (unformat (i, "ll"))
5457 else if (unformat (i, "send"))
5459 else if (unformat (i, "cease"))
5461 else if (unformat (i, "isno"))
5463 else if (unformat (i, "def"))
5466 clib_warning ("parse error '%U'", format_unformat_error, i);
5471 if (sw_if_index_set == 0) {
5472 errmsg ("missing interface name or sw_if_index\n");
5476 /* Construct the API message */
5477 M(SW_INTERFACE_IP6ND_RA_CONFIG, sw_interface_ip6nd_ra_config);
5479 mp->sw_if_index = ntohl (sw_if_index);
5480 mp->max_interval = ntohl(max_interval);
5481 mp->min_interval = ntohl(min_interval);
5482 mp->lifetime = ntohl(lifetime);
5483 mp->initial_count = ntohl(initial_count);
5484 mp->initial_interval = ntohl(initial_interval);
5485 mp->surpress = surpress;
5486 mp->managed = managed;
5488 mp->ll_option = ll_option;
5489 mp->send_unicast = send_unicast;
5492 mp->default_router = default_router;
5497 /* Wait for a reply, return good/bad news */
5504 static int api_set_arp_neighbor_limit (vat_main_t * vam)
5506 unformat_input_t * i = vam->input;
5507 vl_api_set_arp_neighbor_limit_t *mp;
5513 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5514 if (unformat (i, "arp_nbr_limit %d", &arp_nbr_limit))
5516 else if (unformat (i, "ipv6"))
5519 clib_warning ("parse error '%U'", format_unformat_error, i);
5524 if (limit_set == 0) {
5525 errmsg ("missing limit value\n");
5529 M(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit);
5531 mp->arp_neighbor_limit = ntohl(arp_nbr_limit);
5532 mp->is_ipv6 = is_ipv6;
5539 static int api_l2_patch_add_del (vat_main_t * vam)
5541 unformat_input_t * i = vam->input;
5542 vl_api_l2_patch_add_del_t *mp;
5545 u8 rx_sw_if_index_set = 0;
5547 u8 tx_sw_if_index_set = 0;
5550 /* Parse args required to build the message */
5551 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5552 if (unformat (i, "rx_sw_if_index %d", &rx_sw_if_index))
5553 rx_sw_if_index_set = 1;
5554 else if (unformat (i, "tx_sw_if_index %d", &tx_sw_if_index))
5555 tx_sw_if_index_set = 1;
5556 else if (unformat (i, "rx")) {
5557 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5558 if (unformat (i, "%U", unformat_sw_if_index, vam,
5560 rx_sw_if_index_set = 1;
5563 } else if (unformat (i, "tx")) {
5564 if (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
5565 if (unformat (i, "%U", unformat_sw_if_index, vam,
5567 tx_sw_if_index_set = 1;
5570 } else if (unformat (i, "del"))
5576 if (rx_sw_if_index_set == 0) {
5577 errmsg ("missing rx interface name or rx_sw_if_index\n");
5581 if (tx_sw_if_index_set == 0) {
5582 errmsg ("missing tx interface name or tx_sw_if_index\n");
5586 M(L2_PATCH_ADD_DEL, l2_patch_add_del);
5588 mp->rx_sw_if_index = ntohl(rx_sw_if_index);
5589 mp->tx_sw_if_index = ntohl(tx_sw_if_index);
5590 mp->is_add = is_add;
5596 static int api_trace_profile_add (vat_main_t *vam)
5598 unformat_input_t * input = vam->input;
5599 vl_api_trace_profile_add_t *mp;
5602 u32 trace_option_elts = 0;
5603 u32 trace_type = 0, node_id = 0, app_data = 0, trace_tsp = 2;
5604 int has_pow_option = 0;
5605 int has_ppc_option = 0;
5607 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5609 if (unformat (input, "id %d trace-type 0x%x trace-elts %d "
5610 "trace-tsp %d node-id 0x%x app-data 0x%x",
5611 &id, &trace_type, &trace_option_elts, &trace_tsp,
5612 &node_id, &app_data))
5614 else if (unformat (input, "pow"))
5616 else if (unformat (input, "ppc encap"))
5617 has_ppc_option = PPC_ENCAP;
5618 else if (unformat (input, "ppc decap"))
5619 has_ppc_option = PPC_DECAP;
5620 else if (unformat (input, "ppc none"))
5621 has_ppc_option = PPC_NONE;
5625 M(TRACE_PROFILE_ADD, trace_profile_add);
5627 mp->trace_type = trace_type;
5628 mp->trace_num_elt = trace_option_elts;
5629 mp->trace_ppc = has_ppc_option;
5630 mp->trace_app_data = htonl(app_data);
5631 mp->pow_enable = has_pow_option;
5632 mp->trace_tsp = trace_tsp;
5633 mp->node_id = htonl(node_id);
5640 static int api_trace_profile_apply (vat_main_t *vam)
5642 unformat_input_t * input = vam->input;
5643 vl_api_trace_profile_apply_t *mp;
5646 u32 mask_width = ~0;
5653 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5655 if (unformat (input, "%U/%d",
5656 unformat_ip6_address, &addr, &mask_width))
5658 else if (unformat (input, "id %d", &id))
5660 else if (unformat (input, "vrf-id %d", &vrf_id))
5662 else if (unformat (input, "add"))
5664 else if (unformat (input, "pop"))
5666 else if (unformat (input, "none"))
5672 if ((is_add + is_pop + is_none) != 1) {
5673 errmsg("One of (add, pop, none) required");
5676 if (mask_width == ~0) {
5677 errmsg("<address>/<mask-width> required");
5680 M(TRACE_PROFILE_APPLY, trace_profile_apply);
5681 clib_memcpy(mp->dest_ipv6, &addr, sizeof(mp->dest_ipv6));
5683 mp->prefix_length = htonl(mask_width);
5684 mp->vrf_id = htonl(vrf_id);
5686 mp->trace_op = IOAM_HBYH_ADD;
5688 mp->trace_op = IOAM_HBYH_POP;
5690 mp->trace_op = IOAM_HBYH_MOD;
5702 static int api_trace_profile_del (vat_main_t *vam)
5704 vl_api_trace_profile_del_t *mp;
5707 M(TRACE_PROFILE_DEL, trace_profile_del);
5712 static int api_sr_tunnel_add_del (vat_main_t * vam)
5714 unformat_input_t * i = vam->input;
5715 vl_api_sr_tunnel_add_del_t *mp;
5719 ip6_address_t src_address;
5720 int src_address_set = 0;
5721 ip6_address_t dst_address;
5723 int dst_address_set = 0;
5725 u32 rx_table_id = 0;
5726 u32 tx_table_id = 0;
5727 ip6_address_t * segments = 0;
5728 ip6_address_t * this_seg;
5729 ip6_address_t * tags = 0;
5730 ip6_address_t * this_tag;
5731 ip6_address_t next_address, tag;
5733 u8 * policy_name = 0;
5735 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
5737 if (unformat (i, "del"))
5739 else if (unformat (i, "name %s", &name))
5741 else if (unformat (i, "policy %s", &policy_name))
5743 else if (unformat (i, "rx_fib_id %d", &rx_table_id))
5745 else if (unformat (i, "tx_fib_id %d", &tx_table_id))
5747 else if (unformat (i, "src %U", unformat_ip6_address, &src_address))
5748 src_address_set = 1;
5749 else if (unformat (i, "dst %U/%d",
5750 unformat_ip6_address, &dst_address,
5752 dst_address_set = 1;
5753 else if (unformat (i, "next %U", unformat_ip6_address,
5756 vec_add2 (segments, this_seg, 1);
5757 clib_memcpy (this_seg->as_u8, next_address.as_u8, sizeof (*this_seg));
5759 else if (unformat (i, "tag %U", unformat_ip6_address,
5762 vec_add2 (tags, this_tag, 1);
5763 clib_memcpy (this_tag->as_u8, tag.as_u8, sizeof (*this_tag));
5765 else if (unformat (i, "clean"))
5766 flags |= IP6_SR_HEADER_FLAG_CLEANUP;
5767 else if (unformat (i, "protected"))
5768 flags |= IP6_SR_HEADER_FLAG_PROTECTED;
5769 else if (unformat (i, "InPE %d", &pl_index))
5771 if (pl_index <= 0 || pl_index > 4)
5773 pl_index_range_error:
5774 errmsg ("pl index %d out of range\n", pl_index);
5777 flags |= IP6_SR_HEADER_FLAG_PL_ELT_INGRESS_PE << (3*(pl_index - 1));
5779 else if (unformat (i, "EgPE %d", &pl_index))
5781 if (pl_index <= 0 || pl_index > 4)
5782 goto pl_index_range_error;
5783 flags |= IP6_SR_HEADER_FLAG_PL_ELT_EGRESS_PE << (3*(pl_index - 1));
5785 else if (unformat (i, "OrgSrc %d", &pl_index))
5787 if (pl_index <= 0 || pl_index > 4)
5788 goto pl_index_range_error;
5789 flags |= IP6_SR_HEADER_FLAG_PL_ELT_ORIG_SRC_ADDR << (3*(pl_index - 1));
5795 if (!src_address_set)
5797 errmsg ("src address required\n");
5801 if (!dst_address_set)
5803 errmsg ("dst address required\n");
5809 errmsg ("at least one sr segment required\n");
5813 M2(SR_TUNNEL_ADD_DEL, sr_tunnel_add_del,
5814 vec_len(segments) * sizeof (ip6_address_t)
5815 + vec_len(tags) * sizeof (ip6_address_t));
5817 clib_memcpy (mp->src_address, &src_address, sizeof (mp->src_address));
5818 clib_memcpy (mp->dst_address, &dst_address, sizeof (mp->dst_address));
5819 mp->dst_mask_width = dst_mask_width;
5820 mp->flags_net_byte_order = clib_host_to_net_u16 (flags);
5821 mp->n_segments = vec_len (segments);
5822 mp->n_tags = vec_len (tags);
5823 mp->is_add = is_del == 0;
5824 clib_memcpy (mp->segs_and_tags, segments,
5825 vec_len(segments)* sizeof (ip6_address_t));
5826 clib_memcpy (mp->segs_and_tags + vec_len(segments)*sizeof (ip6_address_t),
5827 tags, vec_len(tags)* sizeof (ip6_address_t));
5829 mp->outer_vrf_id = ntohl (rx_table_id);
5830 mp->inner_vrf_id = ntohl (tx_table_id);
5831 memcpy (mp->name, name, vec_len(name));
5832 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
5834 vec_free (segments);
5841 static int api_sr_policy_add_del (vat_main_t * vam)
5843 unformat_input_t * input = vam->input;
5844 vl_api_sr_policy_add_del_t *mp;
5848 u8 * tunnel_name = 0;
5849 u8 ** tunnel_names = 0;
5854 int tunnel_names_length = 1; // Init to 1 to offset the #tunnel_names counter byte
5855 int tun_name_len = 0; // Different naming convention used as confusing these would be "bad" (TM)
5857 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5859 if (unformat (input, "del"))
5861 else if (unformat (input, "name %s", &name))
5863 else if (unformat (input, "tunnel %s", &tunnel_name))
5867 vec_add1 (tunnel_names, tunnel_name);
5869 - length = #bytes to store in serial vector
5870 - +1 = byte to store that length
5872 tunnel_names_length += (vec_len (tunnel_name) + 1);
5883 errmsg ("policy name required\n");
5887 if ((!tunnel_set) && (!is_del))
5889 errmsg ("tunnel name required\n");
5893 M2(SR_POLICY_ADD_DEL, sr_policy_add_del, tunnel_names_length);
5897 mp->is_add = !is_del;
5899 memcpy (mp->name, name, vec_len(name));
5900 // Since mp->tunnel_names is of type u8[0] and not a u8 *, u8 ** needs to be serialized
5901 u8 * serial_orig = 0;
5902 vec_validate (serial_orig, tunnel_names_length);
5903 *serial_orig = vec_len(tunnel_names); // Store the number of tunnels as length in first byte of serialized vector
5904 serial_orig += 1; // Move along one byte to store the length of first tunnel_name
5906 for (j=0; j < vec_len(tunnel_names); j++)
5908 tun_name_len = vec_len (tunnel_names[j]);
5909 *serial_orig = tun_name_len; // Store length of tunnel name in first byte of Length/Value pair
5910 serial_orig += 1; // Move along one byte to store the actual tunnel name
5911 memcpy (serial_orig, tunnel_names[j], tun_name_len);
5912 serial_orig += tun_name_len; // Advance past the copy
5914 memcpy (mp->tunnel_names, serial_orig - tunnel_names_length, tunnel_names_length); // Regress serial_orig to head then copy fwd
5916 vec_free (tunnel_names);
5917 vec_free (tunnel_name);
5923 static int api_sr_multicast_map_add_del (vat_main_t * vam)
5925 unformat_input_t * input = vam->input;
5926 vl_api_sr_multicast_map_add_del_t *mp;
5929 ip6_address_t multicast_address;
5930 u8 * policy_name = 0;
5931 int multicast_address_set = 0;
5933 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5935 if (unformat (input, "del"))
5937 else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address))
5938 multicast_address_set = 1;
5939 else if (unformat (input, "sr-policy %s", &policy_name))
5945 if (!is_del && !policy_name)
5947 errmsg ("sr-policy name required\n");
5952 if (!multicast_address_set)
5954 errmsg ("address required\n");
5958 M(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del);
5960 mp->is_add = !is_del;
5961 memcpy (mp->policy_name, policy_name, vec_len(policy_name));
5962 clib_memcpy (mp->multicast_address, &multicast_address, sizeof (mp->multicast_address));
5965 vec_free (policy_name);
5972 #define foreach_ip4_proto_field \
5982 uword unformat_ip4_mask (unformat_input_t * input, va_list * args)
5984 u8 ** maskp = va_arg (*args, u8 **);
5986 u8 found_something = 0;
5989 #define _(a) u8 a=0;
5990 foreach_ip4_proto_field;
5996 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
5998 if (unformat (input, "version"))
6000 else if (unformat (input, "hdr_length"))
6002 else if (unformat (input, "src"))
6004 else if (unformat (input, "dst"))
6006 else if (unformat (input, "proto"))
6009 #define _(a) else if (unformat (input, #a)) a=1;
6010 foreach_ip4_proto_field
6016 #define _(a) found_something += a;
6017 foreach_ip4_proto_field;
6020 if (found_something == 0)
6023 vec_validate (mask, sizeof (*ip) - 1);
6025 ip = (ip4_header_t *) mask;
6027 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6028 foreach_ip4_proto_field;
6031 ip->ip_version_and_header_length = 0;
6034 ip->ip_version_and_header_length |= 0xF0;
6037 ip->ip_version_and_header_length |= 0x0F;
6043 #define foreach_ip6_proto_field \
6050 uword unformat_ip6_mask (unformat_input_t * input, va_list * args)
6052 u8 ** maskp = va_arg (*args, u8 **);
6054 u8 found_something = 0;
6056 u32 ip_version_traffic_class_and_flow_label;
6058 #define _(a) u8 a=0;
6059 foreach_ip6_proto_field;
6062 u8 traffic_class = 0;
6065 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6067 if (unformat (input, "version"))
6069 else if (unformat (input, "traffic-class"))
6071 else if (unformat (input, "flow-label"))
6073 else if (unformat (input, "src"))
6075 else if (unformat (input, "dst"))
6077 else if (unformat (input, "proto"))
6080 #define _(a) else if (unformat (input, #a)) a=1;
6081 foreach_ip6_proto_field
6087 #define _(a) found_something += a;
6088 foreach_ip6_proto_field;
6091 if (found_something == 0)
6094 vec_validate (mask, sizeof (*ip) - 1);
6096 ip = (ip6_header_t *) mask;
6098 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a));
6099 foreach_ip6_proto_field;
6102 ip_version_traffic_class_and_flow_label = 0;
6105 ip_version_traffic_class_and_flow_label |= 0xF0000000;
6108 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
6111 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
6113 ip->ip_version_traffic_class_and_flow_label =
6114 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6120 uword unformat_l3_mask (unformat_input_t * input, va_list * args)
6122 u8 ** maskp = va_arg (*args, u8 **);
6124 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6125 if (unformat (input, "ip4 %U", unformat_ip4_mask, maskp))
6127 else if (unformat (input, "ip6 %U", unformat_ip6_mask, maskp))
6135 uword unformat_l2_mask (unformat_input_t * input, va_list * args)
6137 u8 ** maskp = va_arg (*args, u8 **);
6152 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6153 if (unformat (input, "src"))
6155 else if (unformat (input, "dst"))
6157 else if (unformat (input, "proto"))
6159 else if (unformat (input, "tag1"))
6161 else if (unformat (input, "tag2"))
6163 else if (unformat (input, "ignore-tag1"))
6165 else if (unformat (input, "ignore-tag2"))
6167 else if (unformat (input, "cos1"))
6169 else if (unformat (input, "cos2"))
6171 else if (unformat (input, "dot1q"))
6173 else if (unformat (input, "dot1ad"))
6178 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
6179 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6182 if (tag1 || ignore_tag1 || cos1 || dot1q)
6184 if (tag2 || ignore_tag2 || cos2 || dot1ad)
6187 vec_validate (mask, len-1);
6190 memset (mask, 0xff, 6);
6193 memset (mask + 6, 0xff, 6);
6197 /* inner vlan tag */
6206 mask[21] = mask [20] = 0xff;
6227 mask[16] = mask [17] = 0xff;
6237 mask[12] = mask [13] = 0xff;
6243 uword unformat_classify_mask (unformat_input_t * input, va_list * args)
6245 u8 ** maskp = va_arg (*args, u8 **);
6246 u32 * skipp = va_arg (*args, u32 *);
6247 u32 * matchp = va_arg (*args, u32 *);
6254 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6255 if (unformat (input, "hex %U", unformat_hex_string, &mask))
6257 else if (unformat (input, "l2 %U", unformat_l2_mask, &l2))
6259 else if (unformat (input, "l3 %U", unformat_l3_mask, &l3))
6265 if (mask || l2 || l3)
6269 /* "With a free Ethernet header in every package" */
6271 vec_validate (l2, 13);
6273 vec_append (mask, l3);
6277 /* Scan forward looking for the first significant mask octet */
6278 for (i = 0; i < vec_len (mask); i++)
6282 /* compute (skip, match) params */
6283 *skipp = i / sizeof(u32x4);
6284 vec_delete (mask, *skipp * sizeof(u32x4), 0);
6286 /* Pad mask to an even multiple of the vector size */
6287 while (vec_len (mask) % sizeof (u32x4))
6290 match = vec_len (mask) / sizeof (u32x4);
6292 for (i = match*sizeof(u32x4); i > 0; i-= sizeof(u32x4))
6294 u64 *tmp = (u64 *)(mask + (i-sizeof(u32x4)));
6295 if (*tmp || *(tmp+1))
6300 clib_warning ("BUG: match 0");
6302 _vec_len (mask) = match * sizeof(u32x4);
6313 #define foreach_l2_next \
6315 _(ethernet, ETHERNET_INPUT) \
6319 uword unformat_l2_next_index (unformat_input_t * input, va_list * args)
6321 u32 * miss_next_indexp = va_arg (*args, u32 *);
6326 if (unformat (input, #n)) { next_index = L2_CLASSIFY_NEXT_##N; goto out;}
6330 if (unformat (input, "%d", &tmp))
6339 *miss_next_indexp = next_index;
6343 #define foreach_ip_next \
6349 uword unformat_ip_next_index (unformat_input_t * input, va_list * args)
6351 u32 * miss_next_indexp = va_arg (*args, u32 *);
6356 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;}
6360 if (unformat (input, "%d", &tmp))
6369 *miss_next_indexp = next_index;
6373 #define foreach_acl_next \
6376 uword unformat_acl_next_index (unformat_input_t * input, va_list * args)
6378 u32 * miss_next_indexp = va_arg (*args, u32 *);
6383 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;}
6387 if (unformat (input, "permit"))
6392 else if (unformat (input, "%d", &tmp))
6401 *miss_next_indexp = next_index;
6405 static int api_classify_add_del_table (vat_main_t * vam)
6407 unformat_input_t * i = vam->input;
6408 vl_api_classify_add_del_table_t *mp;
6414 u32 table_index = ~0;
6415 u32 next_table_index = ~0;
6416 u32 miss_next_index = ~0;
6417 u32 memory_size = 32<<20;
6421 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6422 if (unformat (i, "del"))
6424 else if (unformat (i, "buckets %d", &nbuckets))
6426 else if (unformat (i, "memory_size %d", &memory_size))
6428 else if (unformat (i, "skip %d", &skip))
6430 else if (unformat (i, "match %d", &match))
6432 else if (unformat (i, "table %d", &table_index))
6434 else if (unformat (i, "mask %U", unformat_classify_mask,
6435 &mask, &skip, &match))
6437 else if (unformat (i, "next-table %d", &next_table_index))
6439 else if (unformat (i, "miss-next %U", unformat_ip_next_index,
6442 else if (unformat (i, "l2-miss-next %U", unformat_l2_next_index,
6445 else if (unformat (i, "acl-miss-next %U", unformat_acl_next_index,
6452 if (is_add && mask == 0) {
6453 errmsg ("Mask required\n");
6457 if (is_add && skip == ~0) {
6458 errmsg ("skip count required\n");
6462 if (is_add && match == ~0) {
6463 errmsg ("match count required\n");
6467 if (!is_add && table_index == ~0) {
6468 errmsg ("table index required for delete\n");
6472 M2 (CLASSIFY_ADD_DEL_TABLE, classify_add_del_table,
6475 mp->is_add = is_add;
6476 mp->table_index = ntohl(table_index);
6477 mp->nbuckets = ntohl(nbuckets);
6478 mp->memory_size = ntohl(memory_size);
6479 mp->skip_n_vectors = ntohl(skip);
6480 mp->match_n_vectors = ntohl(match);
6481 mp->next_table_index = ntohl(next_table_index);
6482 mp->miss_next_index = ntohl(miss_next_index);
6483 clib_memcpy (mp->mask, mask, vec_len(mask));
6491 uword unformat_ip4_match (unformat_input_t * input, va_list * args)
6493 u8 ** matchp = va_arg (*args, u8 **);
6500 int src = 0, dst = 0;
6501 ip4_address_t src_val, dst_val;
6508 int fragment_id = 0;
6509 u32 fragment_id_val;
6515 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6517 if (unformat (input, "version %d", &version_val))
6519 else if (unformat (input, "hdr_length %d", &hdr_length_val))
6521 else if (unformat (input, "src %U", unformat_ip4_address, &src_val))
6523 else if (unformat (input, "dst %U", unformat_ip4_address, &dst_val))
6525 else if (unformat (input, "proto %d", &proto_val))
6527 else if (unformat (input, "tos %d", &tos_val))
6529 else if (unformat (input, "length %d", &length_val))
6531 else if (unformat (input, "fragment_id %d", &fragment_id_val))
6533 else if (unformat (input, "ttl %d", &ttl_val))
6535 else if (unformat (input, "checksum %d", &checksum_val))
6541 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
6542 + ttl + checksum == 0)
6546 * Aligned because we use the real comparison functions
6548 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6550 ip = (ip4_header_t *) match;
6552 /* These are realistically matched in practice */
6554 ip->src_address.as_u32 = src_val.as_u32;
6557 ip->dst_address.as_u32 = dst_val.as_u32;
6560 ip->protocol = proto_val;
6563 /* These are not, but they're included for completeness */
6565 ip->ip_version_and_header_length |= (version_val & 0xF)<<4;
6568 ip->ip_version_and_header_length |= (hdr_length_val & 0xF);
6574 ip->length = length_val;
6580 ip->checksum = checksum_val;
6586 uword unformat_ip6_match (unformat_input_t * input, va_list * args)
6588 u8 ** matchp = va_arg (*args, u8 **);
6594 u32 traffic_class_val;
6597 int src = 0, dst = 0;
6598 ip6_address_t src_val, dst_val;
6601 int payload_length = 0;
6602 u32 payload_length_val;
6605 u32 ip_version_traffic_class_and_flow_label;
6607 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6609 if (unformat (input, "version %d", &version_val))
6611 else if (unformat (input, "traffic_class %d", &traffic_class_val))
6613 else if (unformat (input, "flow_label %d", &flow_label_val))
6615 else if (unformat (input, "src %U", unformat_ip6_address, &src_val))
6617 else if (unformat (input, "dst %U", unformat_ip6_address, &dst_val))
6619 else if (unformat (input, "proto %d", &proto_val))
6621 else if (unformat (input, "payload_length %d", &payload_length_val))
6623 else if (unformat (input, "hop_limit %d", &hop_limit_val))
6629 if (version + traffic_class + flow_label + src + dst + proto +
6630 payload_length + hop_limit == 0)
6634 * Aligned because we use the real comparison functions
6636 vec_validate_aligned (match, sizeof (*ip) - 1, sizeof(u32x4));
6638 ip = (ip6_header_t *) match;
6641 clib_memcpy (&ip->src_address, &src_val, sizeof (ip->src_address));
6644 clib_memcpy (&ip->dst_address, &dst_val, sizeof (ip->dst_address));
6647 ip->protocol = proto_val;
6649 ip_version_traffic_class_and_flow_label = 0;
6652 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
6655 ip_version_traffic_class_and_flow_label |= (traffic_class_val & 0xFF) << 20;
6658 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
6660 ip->ip_version_traffic_class_and_flow_label =
6661 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
6664 ip->payload_length = clib_host_to_net_u16 (payload_length_val);
6667 ip->hop_limit = hop_limit_val;
6673 uword unformat_l3_match (unformat_input_t * input, va_list * args)
6675 u8 ** matchp = va_arg (*args, u8 **);
6677 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6678 if (unformat (input, "ip4 %U", unformat_ip4_match, matchp))
6680 else if (unformat (input, "ip6 %U", unformat_ip6_match, matchp))
6688 uword unformat_vlan_tag (unformat_input_t * input, va_list * args)
6690 u8 * tagp = va_arg (*args, u8 *);
6693 if (unformat(input, "%d", &tag))
6695 tagp[0] = (tag>>8) & 0x0F;
6696 tagp[1] = tag & 0xFF;
6703 uword unformat_l2_match (unformat_input_t * input, va_list * args)
6705 u8 ** matchp = va_arg (*args, u8 **);
6725 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6726 if (unformat (input, "src %U", unformat_ethernet_address, &src_val))
6728 else if (unformat (input, "dst %U", unformat_ethernet_address, &dst_val))
6730 else if (unformat (input, "proto %U",
6731 unformat_ethernet_type_host_byte_order, &proto_val))
6733 else if (unformat (input, "tag1 %U", unformat_vlan_tag, tag1_val))
6735 else if (unformat (input, "tag2 %U", unformat_vlan_tag, tag2_val))
6737 else if (unformat (input, "ignore-tag1"))
6739 else if (unformat (input, "ignore-tag2"))
6741 else if (unformat (input, "cos1 %d", &cos1_val))
6743 else if (unformat (input, "cos2 %d", &cos2_val))
6748 if ((src + dst + proto + tag1 + tag2 +
6749 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
6752 if (tag1 || ignore_tag1 || cos1)
6754 if (tag2 || ignore_tag2 || cos2)
6757 vec_validate_aligned (match, len-1, sizeof(u32x4));
6760 clib_memcpy (match, dst_val, 6);
6763 clib_memcpy (match + 6, src_val, 6);
6767 /* inner vlan tag */
6768 match[19] = tag2_val[1];
6769 match[18] = tag2_val[0];
6771 match [18] |= (cos2_val & 0x7) << 5;
6774 match[21] = proto_val & 0xff;
6775 match[20] = proto_val >> 8;
6779 match [15] = tag1_val[1];
6780 match [14] = tag1_val[0];
6783 match [14] |= (cos1_val & 0x7) << 5;
6789 match [15] = tag1_val[1];
6790 match [14] = tag1_val[0];
6793 match[17] = proto_val & 0xff;
6794 match[16] = proto_val >> 8;
6797 match [14] |= (cos1_val & 0x7) << 5;
6803 match [18] |= (cos2_val & 0x7) << 5;
6805 match [14] |= (cos1_val & 0x7) << 5;
6808 match[13] = proto_val & 0xff;
6809 match[12] = proto_val >> 8;
6817 uword unformat_classify_match (unformat_input_t * input, va_list * args)
6819 u8 ** matchp = va_arg (*args, u8 **);
6820 u32 skip_n_vectors = va_arg (*args, u32);
6821 u32 match_n_vectors = va_arg (*args, u32);
6827 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
6828 if (unformat (input, "hex %U", unformat_hex_string, &match))
6830 else if (unformat (input, "l2 %U", unformat_l2_match, &l2))
6832 else if (unformat (input, "l3 %U", unformat_l3_match, &l3))
6838 if (match || l2 || l3)
6842 /* "Win a free Ethernet header in every packet" */
6844 vec_validate_aligned (l2, 13, sizeof(u32x4));
6846 vec_append_aligned (match, l3, sizeof(u32x4));
6850 /* Make sure the vector is big enough even if key is all 0's */
6851 vec_validate_aligned
6852 (match, ((match_n_vectors + skip_n_vectors) * sizeof(u32x4)) - 1,
6855 /* Set size, include skipped vectors*/
6856 _vec_len (match) = (match_n_vectors+skip_n_vectors) * sizeof(u32x4);
6866 static int api_classify_add_del_session (vat_main_t * vam)
6868 unformat_input_t * i = vam->input;
6869 vl_api_classify_add_del_session_t *mp;
6871 u32 table_index = ~0;
6872 u32 hit_next_index = ~0;
6873 u32 opaque_index = ~0;
6877 u32 skip_n_vectors = 0;
6878 u32 match_n_vectors = 0;
6881 * Warning: you have to supply skip_n and match_n
6882 * because the API client cant simply look at the classify
6886 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6887 if (unformat (i, "del"))
6889 else if (unformat (i, "hit-next %U", unformat_ip_next_index,
6892 else if (unformat (i, "l2-hit-next %U", unformat_l2_next_index,
6895 else if (unformat (i, "acl-hit-next %U", unformat_acl_next_index,
6898 else if (unformat (i, "opaque-index %d", &opaque_index))
6900 else if (unformat (i, "skip_n %d", &skip_n_vectors))
6902 else if (unformat (i, "match_n %d", &match_n_vectors))
6904 else if (unformat (i, "match %U", unformat_classify_match,
6905 &match, skip_n_vectors, match_n_vectors))
6907 else if (unformat (i, "advance %d", &advance))
6909 else if (unformat (i, "table-index %d", &table_index))
6915 if (table_index == ~0) {
6916 errmsg ("Table index required\n");
6920 if (is_add && match == 0) {
6921 errmsg ("Match value required\n");
6925 M2 (CLASSIFY_ADD_DEL_SESSION, classify_add_del_session,
6928 mp->is_add = is_add;
6929 mp->table_index = ntohl(table_index);
6930 mp->hit_next_index = ntohl(hit_next_index);
6931 mp->opaque_index = ntohl(opaque_index);
6932 mp->advance = ntohl(advance);
6933 clib_memcpy (mp->match, match, vec_len(match));
6940 static int api_classify_set_interface_ip_table (vat_main_t * vam)
6942 unformat_input_t * i = vam->input;
6943 vl_api_classify_set_interface_ip_table_t *mp;
6946 int sw_if_index_set;
6947 u32 table_index = ~0;
6950 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6951 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6952 sw_if_index_set = 1;
6953 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6954 sw_if_index_set = 1;
6955 else if (unformat (i, "table %d", &table_index))
6958 clib_warning ("parse error '%U'", format_unformat_error, i);
6963 if (sw_if_index_set == 0) {
6964 errmsg ("missing interface name or sw_if_index\n");
6969 M(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table);
6971 mp->sw_if_index = ntohl(sw_if_index);
6972 mp->table_index = ntohl(table_index);
6973 mp->is_ipv6 = is_ipv6;
6980 static int api_classify_set_interface_l2_tables (vat_main_t * vam)
6982 unformat_input_t * i = vam->input;
6983 vl_api_classify_set_interface_l2_tables_t *mp;
6986 int sw_if_index_set;
6987 u32 ip4_table_index = ~0;
6988 u32 ip6_table_index = ~0;
6989 u32 other_table_index = ~0;
6991 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
6992 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
6993 sw_if_index_set = 1;
6994 else if (unformat (i, "sw_if_index %d", &sw_if_index))
6995 sw_if_index_set = 1;
6996 else if (unformat (i, "ip4-table %d", &ip4_table_index))
6998 else if (unformat (i, "ip6-table %d", &ip6_table_index))
7000 else if (unformat (i, "other-table %d", &other_table_index))
7003 clib_warning ("parse error '%U'", format_unformat_error, i);
7008 if (sw_if_index_set == 0) {
7009 errmsg ("missing interface name or sw_if_index\n");
7014 M(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables);
7016 mp->sw_if_index = ntohl(sw_if_index);
7017 mp->ip4_table_index = ntohl(ip4_table_index);
7018 mp->ip6_table_index = ntohl(ip6_table_index);
7019 mp->other_table_index = ntohl(other_table_index);
7027 static int api_get_node_index (vat_main_t * vam)
7029 unformat_input_t * i = vam->input;
7030 vl_api_get_node_index_t * mp;
7034 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7035 if (unformat (i, "node %s", &name))
7041 errmsg ("node name required\n");
7044 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7045 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7049 M(GET_NODE_INDEX, get_node_index);
7050 clib_memcpy (mp->node_name, name, vec_len(name));
7058 static int api_add_node_next (vat_main_t * vam)
7060 unformat_input_t * i = vam->input;
7061 vl_api_add_node_next_t * mp;
7066 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7067 if (unformat (i, "node %s", &name))
7069 else if (unformat (i, "next %s", &next))
7075 errmsg ("node name required\n");
7078 if (vec_len (name) >= ARRAY_LEN(mp->node_name)) {
7079 errmsg ("node name too long, max %d\n", ARRAY_LEN(mp->node_name));
7083 errmsg ("next node required\n");
7086 if (vec_len (next) >= ARRAY_LEN(mp->next_name)) {
7087 errmsg ("next name too long, max %d\n", ARRAY_LEN(mp->next_name));
7091 M(ADD_NODE_NEXT, add_node_next);
7092 clib_memcpy (mp->node_name, name, vec_len(name));
7093 clib_memcpy (mp->next_name, next, vec_len(next));
7102 static int api_l2tpv3_create_tunnel (vat_main_t * vam)
7104 unformat_input_t * i = vam->input;
7105 ip6_address_t client_address, our_address;
7106 int client_address_set = 0;
7107 int our_address_set = 0;
7108 u32 local_session_id = 0;
7109 u32 remote_session_id = 0;
7110 u64 local_cookie = 0;
7111 u64 remote_cookie = 0;
7112 u8 l2_sublayer_present = 0;
7113 vl_api_l2tpv3_create_tunnel_t * mp;
7116 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7117 if (unformat (i, "client_address %U", unformat_ip6_address,
7119 client_address_set = 1;
7120 else if (unformat (i, "our_address %U", unformat_ip6_address,
7122 our_address_set = 1;
7123 else if (unformat (i, "local_session_id %d", &local_session_id))
7125 else if (unformat (i, "remote_session_id %d", &remote_session_id))
7127 else if (unformat (i, "local_cookie %lld", &local_cookie))
7129 else if (unformat (i, "remote_cookie %lld", &remote_cookie))
7131 else if (unformat (i, "l2-sublayer-present"))
7132 l2_sublayer_present = 1;
7137 if (client_address_set == 0) {
7138 errmsg ("client_address required\n");
7142 if (our_address_set == 0) {
7143 errmsg ("our_address required\n");
7147 M(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel);
7149 clib_memcpy (mp->client_address, client_address.as_u8,
7150 sizeof (mp->client_address));
7152 clib_memcpy (mp->our_address, our_address.as_u8,
7153 sizeof (mp->our_address));
7155 mp->local_session_id = ntohl (local_session_id);
7156 mp->remote_session_id = ntohl (remote_session_id);
7157 mp->local_cookie = clib_host_to_net_u64 (local_cookie);
7158 mp->remote_cookie = clib_host_to_net_u64 (remote_cookie);
7159 mp->l2_sublayer_present = l2_sublayer_present;
7167 static int api_l2tpv3_set_tunnel_cookies (vat_main_t * vam)
7169 unformat_input_t * i = vam->input;
7171 u8 sw_if_index_set = 0;
7172 u64 new_local_cookie = 0;
7173 u64 new_remote_cookie = 0;
7174 vl_api_l2tpv3_set_tunnel_cookies_t *mp;
7177 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7178 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7179 sw_if_index_set = 1;
7180 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7181 sw_if_index_set = 1;
7182 else if (unformat (i, "new_local_cookie %lld", &new_local_cookie))
7184 else if (unformat (i, "new_remote_cookie %lld", &new_remote_cookie))
7190 if (sw_if_index_set == 0) {
7191 errmsg ("missing interface name or sw_if_index\n");
7195 M(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies);
7197 mp->sw_if_index = ntohl(sw_if_index);
7198 mp->new_local_cookie = clib_host_to_net_u64 (new_local_cookie);
7199 mp->new_remote_cookie = clib_host_to_net_u64 (new_remote_cookie);
7206 static int api_l2tpv3_interface_enable_disable (vat_main_t * vam)
7208 unformat_input_t * i = vam->input;
7209 vl_api_l2tpv3_interface_enable_disable_t *mp;
7212 u8 sw_if_index_set = 0;
7213 u8 enable_disable = 1;
7215 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7216 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7217 sw_if_index_set = 1;
7218 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7219 sw_if_index_set = 1;
7220 else if (unformat (i, "enable"))
7222 else if (unformat (i, "disable"))
7228 if (sw_if_index_set == 0) {
7229 errmsg ("missing interface name or sw_if_index\n");
7233 M(L2TPV3_INTERFACE_ENABLE_DISABLE, l2tpv3_interface_enable_disable);
7235 mp->sw_if_index = ntohl(sw_if_index);
7236 mp->enable_disable = enable_disable;
7243 static int api_l2tpv3_set_lookup_key (vat_main_t * vam)
7245 unformat_input_t * i = vam->input;
7246 vl_api_l2tpv3_set_lookup_key_t * mp;
7250 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7251 if (unformat (i, "lookup_v6_src"))
7252 key = L2T_LOOKUP_SRC_ADDRESS;
7253 else if (unformat (i, "lookup_v6_dst"))
7254 key = L2T_LOOKUP_DST_ADDRESS;
7255 else if (unformat (i, "lookup_session_id"))
7256 key = L2T_LOOKUP_SESSION_ID;
7261 if (key == (u8) ~0) {
7262 errmsg ("l2tp session lookup key unset\n");
7266 M(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key);
7275 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler
7276 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7278 vat_main_t * vam = &vat_main;
7280 fformat(vam->ofp, "* %U (our) %U (client) (sw_if_index %d)\n",
7281 format_ip6_address, mp->our_address,
7282 format_ip6_address, mp->client_address,
7283 clib_net_to_host_u32(mp->sw_if_index));
7285 fformat (vam->ofp, " local cookies %016llx %016llx remote cookie %016llx\n",
7286 clib_net_to_host_u64 (mp->local_cookie[0]),
7287 clib_net_to_host_u64 (mp->local_cookie[1]),
7288 clib_net_to_host_u64 (mp->remote_cookie));
7290 fformat (vam->ofp, " local session-id %d remote session-id %d\n",
7291 clib_net_to_host_u32 (mp->local_session_id),
7292 clib_net_to_host_u32 (mp->remote_session_id));
7294 fformat (vam->ofp, " l2 specific sublayer %s\n\n",
7295 mp->l2_sublayer_present ? "preset" : "absent");
7299 static void vl_api_sw_if_l2tpv3_tunnel_details_t_handler_json
7300 (vl_api_sw_if_l2tpv3_tunnel_details_t * mp)
7302 vat_main_t * vam = &vat_main;
7303 vat_json_node_t *node = NULL;
7304 struct in6_addr addr;
7306 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7307 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7308 vat_json_init_array(&vam->json_tree);
7310 node = vat_json_array_add(&vam->json_tree);
7312 vat_json_init_object(node);
7314 clib_memcpy(&addr, mp->our_address, sizeof(addr));
7315 vat_json_object_add_ip6(node, "our_address", addr);
7316 clib_memcpy(&addr, mp->client_address, sizeof(addr));
7317 vat_json_object_add_ip6(node, "client_address", addr);
7319 vat_json_node_t * lc = vat_json_object_add(node, "local_cookie");
7320 vat_json_init_array(lc);
7321 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[0]));
7322 vat_json_array_add_uint(lc, clib_net_to_host_u64(mp->local_cookie[1]));
7323 vat_json_object_add_uint(node, "remote_cookie", clib_net_to_host_u64(mp->remote_cookie));
7325 printf("local id: %u", clib_net_to_host_u32(mp->local_session_id));
7326 vat_json_object_add_uint(node, "local_session_id", clib_net_to_host_u32(mp->local_session_id));
7327 vat_json_object_add_uint(node, "remote_session_id", clib_net_to_host_u32(mp->remote_session_id));
7328 vat_json_object_add_string_copy(node, "l2_sublayer", mp->l2_sublayer_present ?
7329 (u8*)"present" : (u8*)"absent");
7332 static int api_sw_if_l2tpv3_tunnel_dump (vat_main_t * vam)
7334 vl_api_sw_if_l2tpv3_tunnel_dump_t *mp;
7337 /* Get list of l2tpv3-tunnel interfaces */
7338 M(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump);
7341 /* Use a control ping for synchronization */
7343 vl_api_control_ping_t * mp;
7344 M(CONTROL_PING, control_ping);
7351 static void vl_api_sw_interface_tap_details_t_handler
7352 (vl_api_sw_interface_tap_details_t * mp)
7354 vat_main_t * vam = &vat_main;
7356 fformat(vam->ofp, "%-16s %d\n",
7358 clib_net_to_host_u32(mp->sw_if_index));
7361 static void vl_api_sw_interface_tap_details_t_handler_json
7362 (vl_api_sw_interface_tap_details_t * mp)
7364 vat_main_t * vam = &vat_main;
7365 vat_json_node_t *node = NULL;
7367 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7368 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7369 vat_json_init_array(&vam->json_tree);
7371 node = vat_json_array_add(&vam->json_tree);
7373 vat_json_init_object(node);
7374 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7375 vat_json_object_add_string_copy(node, "dev_name", mp->dev_name);
7378 static int api_sw_interface_tap_dump (vat_main_t * vam)
7380 vl_api_sw_interface_tap_dump_t *mp;
7383 fformat(vam->ofp, "\n%-16s %s\n", "dev_name", "sw_if_index");
7384 /* Get list of tap interfaces */
7385 M(SW_INTERFACE_TAP_DUMP, sw_interface_tap_dump);
7388 /* Use a control ping for synchronization */
7390 vl_api_control_ping_t * mp;
7391 M(CONTROL_PING, control_ping);
7397 static uword unformat_vxlan_decap_next
7398 (unformat_input_t * input, va_list * args)
7400 u32 * result = va_arg (*args, u32 *);
7403 if (unformat (input, "drop"))
7404 *result = VXLAN_INPUT_NEXT_DROP;
7405 else if (unformat (input, "ip4"))
7406 *result = VXLAN_INPUT_NEXT_IP4_INPUT;
7407 else if (unformat (input, "ip6"))
7408 *result = VXLAN_INPUT_NEXT_IP6_INPUT;
7409 else if (unformat (input, "l2"))
7410 *result = VXLAN_INPUT_NEXT_L2_INPUT;
7411 else if (unformat (input, "%d", &tmp))
7418 static int api_vxlan_add_del_tunnel (vat_main_t * vam)
7420 unformat_input_t * line_input = vam->input;
7421 vl_api_vxlan_add_del_tunnel_t *mp;
7423 ip4_address_t src4, dst4;
7424 ip6_address_t src6, dst6;
7426 u8 ipv4_set = 0, ipv6_set = 0;
7429 u32 encap_vrf_id = 0;
7430 u32 decap_next_index = ~0;
7433 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7434 if (unformat (line_input, "del"))
7436 else if (unformat (line_input, "src %U",
7437 unformat_ip4_address, &src4))
7442 else if (unformat (line_input, "dst %U",
7443 unformat_ip4_address, &dst4))
7448 else if (unformat (line_input, "src %U",
7449 unformat_ip6_address, &src6))
7454 else if (unformat (line_input, "dst %U",
7455 unformat_ip6_address, &dst6))
7460 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
7462 else if (unformat (line_input, "decap-next %U",
7463 unformat_vxlan_decap_next, &decap_next_index))
7465 else if (unformat (line_input, "vni %d", &vni))
7468 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7474 errmsg ("tunnel src address not specified\n");
7478 errmsg ("tunnel dst address not specified\n");
7482 if (ipv4_set && ipv6_set) {
7483 errmsg ("both IPv4 and IPv6 addresses specified");
7487 if ((vni == 0) || (vni>>24)) {
7488 errmsg ("vni not specified or out of range\n");
7492 M (VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel);
7495 clib_memcpy(&mp->src_address, &src6, sizeof(src6));
7496 clib_memcpy(&mp->dst_address, &dst6, sizeof(dst6));
7498 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7499 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7501 mp->encap_vrf_id = ntohl(encap_vrf_id);
7502 mp->decap_next_index = ntohl(decap_next_index);
7503 mp->vni = ntohl(vni);
7504 mp->is_add = is_add;
7505 mp->is_ipv6 = ipv6_set;
7512 static void vl_api_vxlan_tunnel_details_t_handler
7513 (vl_api_vxlan_tunnel_details_t * mp)
7515 vat_main_t * vam = &vat_main;
7517 fformat(vam->ofp, "%11d%24U%24U%14d%18d%13d\n",
7518 ntohl(mp->sw_if_index),
7519 format_ip46_address, &(mp->src_address[0]),
7520 format_ip46_address, &(mp->dst_address[0]),
7521 ntohl(mp->encap_vrf_id),
7522 ntohl(mp->decap_next_index),
7526 static void vl_api_vxlan_tunnel_details_t_handler_json
7527 (vl_api_vxlan_tunnel_details_t * mp)
7529 vat_main_t * vam = &vat_main;
7530 vat_json_node_t *node = NULL;
7532 struct in6_addr ip6;
7534 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7535 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7536 vat_json_init_array(&vam->json_tree);
7538 node = vat_json_array_add(&vam->json_tree);
7540 vat_json_init_object(node);
7541 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7543 clib_memcpy(&ip6, &(mp->src_address[0]), sizeof(ip6));
7544 vat_json_object_add_ip6(node, "src_address", ip6);
7545 clib_memcpy(&ip6, &(mp->dst_address[0]), sizeof(ip6));
7546 vat_json_object_add_ip6(node, "dst_address", ip6);
7548 clib_memcpy(&ip4, &(mp->src_address[0]), sizeof(ip4));
7549 vat_json_object_add_ip4(node, "src_address", ip4);
7550 clib_memcpy(&ip4, &(mp->dst_address[0]), sizeof(ip4));
7551 vat_json_object_add_ip4(node, "dst_address", ip4);
7553 vat_json_object_add_uint(node, "encap_vrf_id", ntohl(mp->encap_vrf_id));
7554 vat_json_object_add_uint(node, "decap_next_index", ntohl(mp->decap_next_index));
7555 vat_json_object_add_uint(node, "vni", ntohl(mp->vni));
7556 vat_json_object_add_uint(node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
7559 static int api_vxlan_tunnel_dump (vat_main_t * vam)
7561 unformat_input_t * i = vam->input;
7562 vl_api_vxlan_tunnel_dump_t *mp;
7565 u8 sw_if_index_set = 0;
7567 /* Parse args required to build the message */
7568 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7569 if (unformat (i, "sw_if_index %d", &sw_if_index))
7570 sw_if_index_set = 1;
7575 if (sw_if_index_set == 0) {
7579 if (!vam->json_output) {
7580 fformat(vam->ofp, "%11s%24s%24s%14s%18s%13s\n",
7581 "sw_if_index", "src_address", "dst_address",
7582 "encap_vrf_id", "decap_next_index", "vni");
7585 /* Get list of vxlan-tunnel interfaces */
7586 M(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
7588 mp->sw_if_index = htonl(sw_if_index);
7592 /* Use a control ping for synchronization */
7594 vl_api_control_ping_t * mp;
7595 M(CONTROL_PING, control_ping);
7601 static int api_gre_add_del_tunnel (vat_main_t * vam)
7603 unformat_input_t * line_input = vam->input;
7604 vl_api_gre_add_del_tunnel_t *mp;
7606 ip4_address_t src4, dst4;
7610 u32 outer_fib_id = 0;
7612 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
7613 if (unformat (line_input, "del"))
7615 else if (unformat (line_input, "src %U",
7616 unformat_ip4_address, &src4))
7618 else if (unformat (line_input, "dst %U",
7619 unformat_ip4_address, &dst4))
7621 else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
7624 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
7630 errmsg ("tunnel src address not specified\n");
7634 errmsg ("tunnel dst address not specified\n");
7639 M (GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel);
7641 clib_memcpy(&mp->src_address, &src4, sizeof(src4));
7642 clib_memcpy(&mp->dst_address, &dst4, sizeof(dst4));
7643 mp->outer_table_id = ntohl(outer_fib_id);
7644 mp->is_add = is_add;
7651 static void vl_api_gre_tunnel_details_t_handler
7652 (vl_api_gre_tunnel_details_t * mp)
7654 vat_main_t * vam = &vat_main;
7656 fformat(vam->ofp, "%11d%15U%15U%14d\n",
7657 ntohl(mp->sw_if_index),
7658 format_ip4_address, &mp->src_address,
7659 format_ip4_address, &mp->dst_address,
7660 ntohl(mp->outer_table_id));
7663 static void vl_api_gre_tunnel_details_t_handler_json
7664 (vl_api_gre_tunnel_details_t * mp)
7666 vat_main_t * vam = &vat_main;
7667 vat_json_node_t *node = NULL;
7670 if (VAT_JSON_ARRAY != vam->json_tree.type) {
7671 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
7672 vat_json_init_array(&vam->json_tree);
7674 node = vat_json_array_add(&vam->json_tree);
7676 vat_json_init_object(node);
7677 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
7678 clib_memcpy(&ip4, &mp->src_address, sizeof(ip4));
7679 vat_json_object_add_ip4(node, "src_address", ip4);
7680 clib_memcpy(&ip4, &mp->dst_address, sizeof(ip4));
7681 vat_json_object_add_ip4(node, "dst_address", ip4);
7682 vat_json_object_add_uint(node, "outer_fib_id", ntohl(mp->outer_table_id));
7685 static int api_gre_tunnel_dump (vat_main_t * vam)
7687 unformat_input_t * i = vam->input;
7688 vl_api_gre_tunnel_dump_t *mp;
7691 u8 sw_if_index_set = 0;
7693 /* Parse args required to build the message */
7694 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7695 if (unformat (i, "sw_if_index %d", &sw_if_index))
7696 sw_if_index_set = 1;
7701 if (sw_if_index_set == 0) {
7705 if (!vam->json_output) {
7706 fformat(vam->ofp, "%11s%15s%15s%14s\n",
7707 "sw_if_index", "src_address", "dst_address",
7711 /* Get list of gre-tunnel interfaces */
7712 M(GRE_TUNNEL_DUMP, gre_tunnel_dump);
7714 mp->sw_if_index = htonl(sw_if_index);
7718 /* Use a control ping for synchronization */
7720 vl_api_control_ping_t * mp;
7721 M(CONTROL_PING, control_ping);
7727 static int api_l2_fib_clear_table (vat_main_t * vam)
7729 // unformat_input_t * i = vam->input;
7730 vl_api_l2_fib_clear_table_t *mp;
7733 M(L2_FIB_CLEAR_TABLE, l2_fib_clear_table);
7740 static int api_l2_interface_efp_filter (vat_main_t * vam)
7742 unformat_input_t * i = vam->input;
7743 vl_api_l2_interface_efp_filter_t *mp;
7747 u8 sw_if_index_set = 0;
7749 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7750 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7751 sw_if_index_set = 1;
7752 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7753 sw_if_index_set = 1;
7754 else if (unformat (i, "enable"))
7756 else if (unformat (i, "disable"))
7759 clib_warning ("parse error '%U'", format_unformat_error, i);
7764 if (sw_if_index_set == 0) {
7765 errmsg ("missing sw_if_index\n");
7769 M(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter);
7771 mp->sw_if_index = ntohl(sw_if_index);
7772 mp->enable_disable = enable;
7779 #define foreach_vtr_op \
7780 _("disable", L2_VTR_DISABLED) \
7781 _("push-1", L2_VTR_PUSH_1) \
7782 _("push-2", L2_VTR_PUSH_2) \
7783 _("pop-1", L2_VTR_POP_1) \
7784 _("pop-2", L2_VTR_POP_2) \
7785 _("translate-1-1", L2_VTR_TRANSLATE_1_1) \
7786 _("translate-1-2", L2_VTR_TRANSLATE_1_2) \
7787 _("translate-2-1", L2_VTR_TRANSLATE_2_1) \
7788 _("translate-2-2", L2_VTR_TRANSLATE_2_2)
7790 static int api_l2_interface_vlan_tag_rewrite (vat_main_t * vam)
7792 unformat_input_t * i = vam->input;
7793 vl_api_l2_interface_vlan_tag_rewrite_t *mp;
7796 u8 sw_if_index_set = 0;
7803 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7804 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7805 sw_if_index_set = 1;
7806 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7807 sw_if_index_set = 1;
7808 else if (unformat (i, "vtr_op %d", &vtr_op))
7810 #define _(n,v) else if (unformat(i, n)) {vtr_op = v; vtr_op_set = 1;}
7814 else if (unformat (i, "push_dot1q %d", &push_dot1q))
7816 else if (unformat (i, "tag1 %d", &tag1))
7818 else if (unformat (i, "tag2 %d", &tag2))
7821 clib_warning ("parse error '%U'", format_unformat_error, i);
7826 if ((sw_if_index_set == 0)||(vtr_op_set == 0)) {
7827 errmsg ("missing vtr operation or sw_if_index\n");
7831 M(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite)
7833 mp->sw_if_index = ntohl(sw_if_index);
7834 mp->vtr_op = ntohl(vtr_op);
7835 mp->push_dot1q = ntohl(push_dot1q);
7836 mp->tag1 = ntohl(tag1);
7837 mp->tag2 = ntohl(tag2);
7844 static int api_create_vhost_user_if (vat_main_t * vam)
7846 unformat_input_t * i = vam->input;
7847 vl_api_create_vhost_user_if_t *mp;
7851 u8 file_name_set = 0;
7852 u32 custom_dev_instance = ~0;
7854 u8 use_custom_mac = 0;
7856 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7857 if (unformat (i, "socket %s", &file_name)) {
7860 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
7862 else if (unformat (i, "mac %U", unformat_ethernet_address, hwaddr))
7864 else if (unformat (i, "server"))
7870 if (file_name_set == 0) {
7871 errmsg ("missing socket file name\n");
7875 if (vec_len (file_name) > 255) {
7876 errmsg ("socket file name too long\n");
7879 vec_add1 (file_name, 0);
7881 M(CREATE_VHOST_USER_IF, create_vhost_user_if);
7883 mp->is_server = is_server;
7884 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
7885 vec_free(file_name);
7886 if (custom_dev_instance != ~0) {
7888 mp->custom_dev_instance = ntohl(custom_dev_instance);
7890 mp->use_custom_mac = use_custom_mac;
7891 clib_memcpy(mp->mac_address, hwaddr, 6);
7898 static int api_modify_vhost_user_if (vat_main_t * vam)
7900 unformat_input_t * i = vam->input;
7901 vl_api_modify_vhost_user_if_t *mp;
7905 u8 file_name_set = 0;
7906 u32 custom_dev_instance = ~0;
7907 u8 sw_if_index_set = 0;
7908 u32 sw_if_index = (u32)~0;
7910 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7911 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7912 sw_if_index_set = 1;
7913 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7914 sw_if_index_set = 1;
7915 else if (unformat (i, "socket %s", &file_name)) {
7918 else if (unformat (i, "renumber %"PRIu32, &custom_dev_instance))
7920 else if (unformat (i, "server"))
7926 if (sw_if_index_set == 0) {
7927 errmsg ("missing sw_if_index or interface name\n");
7931 if (file_name_set == 0) {
7932 errmsg ("missing socket file name\n");
7936 if (vec_len (file_name) > 255) {
7937 errmsg ("socket file name too long\n");
7940 vec_add1 (file_name, 0);
7942 M(MODIFY_VHOST_USER_IF, modify_vhost_user_if);
7944 mp->sw_if_index = ntohl(sw_if_index);
7945 mp->is_server = is_server;
7946 clib_memcpy(mp->sock_filename, file_name, vec_len(file_name));
7947 vec_free(file_name);
7948 if (custom_dev_instance != ~0) {
7950 mp->custom_dev_instance = ntohl(custom_dev_instance);
7958 static int api_delete_vhost_user_if (vat_main_t * vam)
7960 unformat_input_t * i = vam->input;
7961 vl_api_delete_vhost_user_if_t *mp;
7963 u32 sw_if_index = ~0;
7964 u8 sw_if_index_set = 0;
7966 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
7967 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
7968 sw_if_index_set = 1;
7969 else if (unformat (i, "sw_if_index %d", &sw_if_index))
7970 sw_if_index_set = 1;
7975 if (sw_if_index_set == 0) {
7976 errmsg ("missing sw_if_index or interface name\n");
7981 M(DELETE_VHOST_USER_IF, delete_vhost_user_if);
7983 mp->sw_if_index = ntohl(sw_if_index);
7990 static void vl_api_sw_interface_vhost_user_details_t_handler
7991 (vl_api_sw_interface_vhost_user_details_t * mp)
7993 vat_main_t * vam = &vat_main;
7995 fformat(vam->ofp, "%-25s %3" PRIu32 " %6" PRIu32 " %8x %6d %7d %s\n",
7996 (char *)mp->interface_name,
7997 ntohl(mp->sw_if_index), ntohl(mp->virtio_net_hdr_sz),
7998 clib_net_to_host_u64(mp->features), mp->is_server,
7999 ntohl(mp->num_regions), (char *)mp->sock_filename);
8000 fformat(vam->ofp, " Status: '%s'\n", strerror(ntohl(mp->sock_errno)));
8003 static void vl_api_sw_interface_vhost_user_details_t_handler_json
8004 (vl_api_sw_interface_vhost_user_details_t * mp)
8006 vat_main_t * vam = &vat_main;
8007 vat_json_node_t *node = NULL;
8009 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8010 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8011 vat_json_init_array(&vam->json_tree);
8013 node = vat_json_array_add(&vam->json_tree);
8015 vat_json_init_object(node);
8016 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8017 vat_json_object_add_string_copy(node, "interface_name", mp->interface_name);
8018 vat_json_object_add_uint(node, "virtio_net_hdr_sz", ntohl(mp->virtio_net_hdr_sz));
8019 vat_json_object_add_uint(node, "features", clib_net_to_host_u64(mp->features));
8020 vat_json_object_add_uint(node, "is_server", mp->is_server);
8021 vat_json_object_add_string_copy(node, "sock_filename", mp->sock_filename);
8022 vat_json_object_add_uint(node, "num_regions", ntohl(mp->num_regions));
8023 vat_json_object_add_uint(node, "sock_errno", ntohl(mp->sock_errno));
8026 static int api_sw_interface_vhost_user_dump (vat_main_t * vam)
8028 vl_api_sw_interface_vhost_user_dump_t *mp;
8030 fformat(vam->ofp, "Interface name idx hdr_sz features server regions filename\n");
8032 /* Get list of vhost-user interfaces */
8033 M(SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump);
8036 /* Use a control ping for synchronization */
8038 vl_api_control_ping_t * mp;
8039 M(CONTROL_PING, control_ping);
8045 static int api_show_version (vat_main_t * vam)
8047 vl_api_show_version_t *mp;
8050 M(SHOW_VERSION, show_version);
8058 static int api_vxlan_gpe_add_del_tunnel (vat_main_t * vam)
8060 unformat_input_t * line_input = vam->input;
8061 vl_api_vxlan_gpe_add_del_tunnel_t *mp;
8063 ip4_address_t local, remote;
8067 u32 encap_vrf_id = 0;
8068 u32 decap_vrf_id = 0;
8073 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8074 if (unformat (line_input, "del"))
8076 else if (unformat (line_input, "local %U",
8077 unformat_ip4_address, &local))
8079 else if (unformat (line_input, "remote %U",
8080 unformat_ip4_address, &remote))
8082 else if (unformat (line_input, "encap-vrf-id %d", &encap_vrf_id))
8084 else if (unformat (line_input, "decap-vrf-id %d", &decap_vrf_id))
8086 else if (unformat (line_input, "vni %d", &vni))
8088 else if (unformat(line_input, "next-ip4"))
8090 else if (unformat(line_input, "next-ip6"))
8092 else if (unformat(line_input, "next-ethernet"))
8094 else if (unformat(line_input, "next-nsh"))
8097 errmsg ("parse error '%U'\n", format_unformat_error, line_input);
8102 if (local_set == 0) {
8103 errmsg ("tunnel local address not specified\n");
8106 if (remote_set == 0) {
8107 errmsg ("tunnel remote address not specified\n");
8112 errmsg ("vni not specified\n");
8116 M(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel);
8118 mp->local = local.as_u32;
8119 mp->remote = remote.as_u32;
8120 mp->encap_vrf_id = ntohl(encap_vrf_id);
8121 mp->decap_vrf_id = ntohl(decap_vrf_id);
8122 mp->protocol = ntohl(protocol);
8123 mp->vni = ntohl(vni);
8124 mp->is_add = is_add;
8132 u8 * format_l2_fib_mac_address (u8 * s, va_list * args)
8134 u8 * a = va_arg (*args, u8 *);
8136 return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
8137 a[2], a[3], a[4], a[5], a[6], a[7]);
8140 static void vl_api_l2_fib_table_entry_t_handler
8141 (vl_api_l2_fib_table_entry_t * mp)
8143 vat_main_t * vam = &vat_main;
8145 fformat(vam->ofp, "%3" PRIu32 " %U %3" PRIu32
8147 ntohl(mp->bd_id), format_l2_fib_mac_address, &mp->mac,
8148 ntohl(mp->sw_if_index), mp->static_mac, mp->filter_mac,
8152 static void vl_api_l2_fib_table_entry_t_handler_json
8153 (vl_api_l2_fib_table_entry_t * mp)
8155 vat_main_t * vam = &vat_main;
8156 vat_json_node_t *node = NULL;
8158 if (VAT_JSON_ARRAY != vam->json_tree.type) {
8159 ASSERT(VAT_JSON_NONE == vam->json_tree.type);
8160 vat_json_init_array(&vam->json_tree);
8162 node = vat_json_array_add(&vam->json_tree);
8164 vat_json_init_object(node);
8165 vat_json_object_add_uint(node, "bd_id", ntohl(mp->bd_id));
8166 vat_json_object_add_uint(node, "mac", clib_net_to_host_u64(mp->mac));
8167 vat_json_object_add_uint(node, "sw_if_index", ntohl(mp->sw_if_index));
8168 vat_json_object_add_uint(node, "static_mac", mp->static_mac);
8169 vat_json_object_add_uint(node, "filter_mac", mp->filter_mac);
8170 vat_json_object_add_uint(node, "bvi_mac", mp->bvi_mac);
8173 static int api_l2_fib_table_dump (vat_main_t * vam)
8175 unformat_input_t * i = vam->input;
8176 vl_api_l2_fib_table_dump_t *mp;
8181 /* Parse args required to build the message */
8182 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8183 if (unformat (i, "bd_id %d", &bd_id))
8189 if (bd_id_set == 0) {
8190 errmsg ("missing bridge domain\n");
8194 fformat(vam->ofp, "BD-ID Mac Address sw-ndx Static Filter BVI\n");
8196 /* Get list of l2 fib entries */
8197 M(L2_FIB_TABLE_DUMP, l2_fib_table_dump);
8199 mp->bd_id = ntohl(bd_id);
8202 /* Use a control ping for synchronization */
8204 vl_api_control_ping_t * mp;
8205 M(CONTROL_PING, control_ping);
8213 api_interface_name_renumber (vat_main_t * vam)
8215 unformat_input_t * line_input = vam->input;
8216 vl_api_interface_name_renumber_t *mp;
8217 u32 sw_if_index = ~0;
8219 u32 new_show_dev_instance = ~0;
8221 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8222 if (unformat (line_input, "%U", unformat_sw_if_index, vam,
8225 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
8227 else if (unformat (line_input, "new_show_dev_instance %d",
8228 &new_show_dev_instance))
8234 if (sw_if_index == ~0) {
8235 errmsg ("missing interface name or sw_if_index\n");
8239 if (new_show_dev_instance == ~0) {
8240 errmsg ("missing new_show_dev_instance\n");
8244 M(INTERFACE_NAME_RENUMBER, interface_name_renumber);
8246 mp->sw_if_index = ntohl (sw_if_index);
8247 mp->new_show_dev_instance = ntohl (new_show_dev_instance);
8253 api_want_ip4_arp_events (vat_main_t * vam)
8255 unformat_input_t * line_input = vam->input;
8256 vl_api_want_ip4_arp_events_t * mp;
8258 ip4_address_t address;
8259 int address_set = 0;
8260 u32 enable_disable = 1;
8262 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
8263 if (unformat (line_input, "address %U",
8264 unformat_ip4_address, &address))
8266 else if (unformat (line_input, "del"))
8272 if (address_set == 0) {
8273 errmsg ("missing addresses\n");
8277 M(WANT_IP4_ARP_EVENTS, want_ip4_arp_events);
8278 mp->enable_disable = enable_disable;
8280 mp->address = address.as_u32;
8285 static int api_input_acl_set_interface (vat_main_t * vam)
8287 unformat_input_t * i = vam->input;
8288 vl_api_input_acl_set_interface_t *mp;
8291 int sw_if_index_set;
8292 u32 ip4_table_index = ~0;
8293 u32 ip6_table_index = ~0;
8294 u32 l2_table_index = ~0;
8297 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8298 if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8299 sw_if_index_set = 1;
8300 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8301 sw_if_index_set = 1;
8302 else if (unformat (i, "del"))
8304 else if (unformat (i, "ip4-table %d", &ip4_table_index))
8306 else if (unformat (i, "ip6-table %d", &ip6_table_index))
8308 else if (unformat (i, "l2-table %d", &l2_table_index))
8311 clib_warning ("parse error '%U'", format_unformat_error, i);
8316 if (sw_if_index_set == 0) {
8317 errmsg ("missing interface name or sw_if_index\n");
8321 M(INPUT_ACL_SET_INTERFACE, input_acl_set_interface);
8323 mp->sw_if_index = ntohl(sw_if_index);
8324 mp->ip4_table_index = ntohl(ip4_table_index);
8325 mp->ip6_table_index = ntohl(ip6_table_index);
8326 mp->l2_table_index = ntohl(l2_table_index);
8327 mp->is_add = is_add;
8335 api_ip_address_dump (vat_main_t * vam)
8337 unformat_input_t * i = vam->input;
8338 vl_api_ip_address_dump_t * mp;
8339 u32 sw_if_index = ~0;
8340 u8 sw_if_index_set = 0;
8345 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8346 if (unformat (i, "sw_if_index %d", &sw_if_index))
8347 sw_if_index_set = 1;
8348 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8349 sw_if_index_set = 1;
8350 else if (unformat (i, "ipv4"))
8352 else if (unformat (i, "ipv6"))
8358 if (ipv4_set && ipv6_set) {
8359 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8363 if ((!ipv4_set) && (!ipv6_set)) {
8364 errmsg ("no ipv4 nor ipv6 flag set\n");
8368 if (sw_if_index_set == 0) {
8369 errmsg ("missing interface name or sw_if_index\n");
8373 vam->current_sw_if_index = sw_if_index;
8374 vam->is_ipv6 = ipv6_set;
8376 M(IP_ADDRESS_DUMP, ip_address_dump);
8377 mp->sw_if_index = ntohl(sw_if_index);
8378 mp->is_ipv6 = ipv6_set;
8381 /* Use a control ping for synchronization */
8383 vl_api_control_ping_t * mp;
8384 M(CONTROL_PING, control_ping);
8391 api_ip_dump (vat_main_t * vam)
8393 vl_api_ip_dump_t * mp;
8394 unformat_input_t * in = vam->input;
8401 while (unformat_check_input (in) != UNFORMAT_END_OF_INPUT) {
8402 if (unformat (in, "ipv4"))
8404 else if (unformat (in, "ipv6"))
8410 if (ipv4_set && ipv6_set) {
8411 errmsg ("ipv4 and ipv6 flags cannot be both set\n");
8415 if ((!ipv4_set) && (!ipv6_set)) {
8416 errmsg ("no ipv4 nor ipv6 flag set\n");
8421 vam->is_ipv6 = is_ipv6;
8424 for (i = 0; i < vec_len(vam->ip_details_by_sw_if_index[is_ipv6]); i++) {
8425 vec_free(vam->ip_details_by_sw_if_index[is_ipv6][i].addr);
8427 vec_free(vam->ip_details_by_sw_if_index[is_ipv6]);
8429 M(IP_DUMP, ip_dump);
8430 mp->is_ipv6 = ipv6_set;
8433 /* Use a control ping for synchronization */
8435 vl_api_control_ping_t * mp;
8436 M(CONTROL_PING, control_ping);
8443 api_ipsec_spd_add_del (vat_main_t * vam)
8446 unformat_input_t * i = vam->input;
8447 vl_api_ipsec_spd_add_del_t *mp;
8452 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8453 if (unformat (i, "spd_id %d", &spd_id))
8455 else if (unformat (i, "del"))
8458 clib_warning ("parse error '%U'", format_unformat_error, i);
8463 errmsg ("spd_id must be set\n");
8467 M(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del);
8469 mp->spd_id = ntohl(spd_id);
8470 mp->is_add = is_add;
8476 clib_warning ("unsupported (no dpdk)");
8482 api_ipsec_interface_add_del_spd (vat_main_t * vam)
8485 unformat_input_t * i = vam->input;
8486 vl_api_ipsec_interface_add_del_spd_t *mp;
8489 u8 sw_if_index_set = 0;
8490 u32 spd_id = (u32) ~0;
8493 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8494 if (unformat (i, "del"))
8496 else if (unformat (i, "spd_id %d", &spd_id))
8498 else if (unformat (i, "%U", unformat_sw_if_index, vam, &sw_if_index))
8499 sw_if_index_set = 1;
8500 else if (unformat (i, "sw_if_index %d", &sw_if_index))
8501 sw_if_index_set = 1;
8503 clib_warning ("parse error '%U'", format_unformat_error, i);
8509 if (spd_id == (u32) ~0) {
8510 errmsg ("spd_id must be set\n");
8514 if (sw_if_index_set == 0) {
8515 errmsg ("missing interface name or sw_if_index\n");
8519 M(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd);
8521 mp->spd_id = ntohl(spd_id);
8522 mp->sw_if_index = ntohl (sw_if_index);
8523 mp->is_add = is_add;
8529 clib_warning ("unsupported (no dpdk)");
8535 api_ipsec_spd_add_del_entry (vat_main_t * vam)
8538 unformat_input_t * i = vam->input;
8539 vl_api_ipsec_spd_add_del_entry_t *mp;
8541 u8 is_add = 1, is_outbound = 0, is_ipv6 = 0, is_ip_any = 1;
8542 u32 spd_id, sa_id, protocol = 0, policy = 0;
8544 u32 rport_start = 0, rport_stop = (u32) ~0;
8545 u32 lport_start = 0, lport_stop = (u32) ~0;
8546 ip4_address_t laddr4_start, laddr4_stop, raddr4_start, raddr4_stop;
8547 ip6_address_t laddr6_start, laddr6_stop, raddr6_start, raddr6_stop;
8549 laddr4_start.as_u32 = raddr4_start.as_u32 = 0;
8550 laddr4_stop.as_u32 = raddr4_stop.as_u32 = (u32) ~0;
8551 laddr6_start.as_u64[0] = raddr6_start.as_u64[0] = 0;
8552 laddr6_start.as_u64[1] = raddr6_start.as_u64[1] = 0;
8553 laddr6_stop.as_u64[0] = raddr6_stop.as_u64[0] = (u64) ~0;
8554 laddr6_stop.as_u64[1] = raddr6_stop.as_u64[1] = (u64) ~0;
8556 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8557 if (unformat (i, "del"))
8559 if (unformat (i, "outbound"))
8561 if (unformat (i, "inbound"))
8563 else if (unformat (i, "spd_id %d", &spd_id))
8565 else if (unformat (i, "sa_id %d", &sa_id))
8567 else if (unformat (i, "priority %d", &priority))
8569 else if (unformat (i, "protocol %d", &protocol))
8571 else if (unformat (i, "lport_start %d", &lport_start))
8573 else if (unformat (i, "lport_stop %d", &lport_stop))
8575 else if (unformat (i, "rport_start %d", &rport_start))
8577 else if (unformat (i, "rport_stop %d", &rport_stop))
8579 else if (unformat (i, "laddr_start %U", unformat_ip4_address, &laddr4_start))
8584 else if (unformat (i, "laddr_stop %U", unformat_ip4_address, &laddr4_stop))
8589 else if (unformat (i, "raddr_start %U", unformat_ip4_address, &raddr4_start))
8594 else if (unformat (i, "raddr_stop %U", unformat_ip4_address, &raddr4_stop))
8599 else if (unformat (i, "laddr_start %U", unformat_ip6_address, &laddr6_start))
8604 else if (unformat (i, "laddr_stop %U", unformat_ip6_address, &laddr6_stop))
8609 else if (unformat (i, "raddr_start %U", unformat_ip6_address, &raddr6_start))
8614 else if (unformat (i, "raddr_stop %U", unformat_ip6_address, &raddr6_stop))
8619 else if (unformat (i, "action %U", unformat_ipsec_policy_action, &policy))
8621 if (policy == IPSEC_POLICY_ACTION_RESOLVE) {
8622 clib_warning ("unsupported action: 'resolve'");
8627 clib_warning ("parse error '%U'", format_unformat_error, i);
8633 M(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry);
8635 mp->spd_id = ntohl(spd_id);
8636 mp->priority = ntohl(priority);
8637 mp->is_outbound = is_outbound;
8639 mp->is_ipv6 = is_ipv6;
8640 if (is_ipv6 || is_ip_any) {
8641 clib_memcpy (mp->remote_address_start, &raddr6_start, sizeof(ip6_address_t));
8642 clib_memcpy (mp->remote_address_stop, &raddr6_stop, sizeof(ip6_address_t));
8643 clib_memcpy (mp->local_address_start, &laddr6_start, sizeof(ip6_address_t));
8644 clib_memcpy (mp->local_address_stop, &laddr6_stop, sizeof(ip6_address_t));
8646 clib_memcpy (mp->remote_address_start, &raddr4_start, sizeof(ip4_address_t));
8647 clib_memcpy (mp->remote_address_stop, &raddr4_stop, sizeof(ip4_address_t));
8648 clib_memcpy (mp->local_address_start, &laddr4_start, sizeof(ip4_address_t));
8649 clib_memcpy (mp->local_address_stop, &laddr4_stop, sizeof(ip4_address_t));
8651 mp->protocol = (u8) protocol;
8652 mp->local_port_start = ntohs((u16) lport_start);
8653 mp->local_port_stop = ntohs((u16) lport_stop);
8654 mp->remote_port_start = ntohs((u16) rport_start);
8655 mp->remote_port_stop = ntohs((u16) rport_stop);
8656 mp->policy = (u8) policy;
8657 mp->sa_id = ntohl(sa_id);
8658 mp->is_add = is_add;
8659 mp->is_ip_any = is_ip_any;
8664 clib_warning ("unsupported (no dpdk)");
8670 api_ipsec_sad_add_del_entry (vat_main_t * vam)
8673 unformat_input_t * i = vam->input;
8674 vl_api_ipsec_sad_add_del_entry_t *mp;
8680 u8 protocol = IPSEC_PROTOCOL_AH;
8681 u8 is_tunnel = 0, is_tunnel_ipv6 = 0;
8682 u32 crypto_alg = 0, integ_alg = 0;
8683 ip4_address_t tun_src4;
8684 ip4_address_t tun_dst4;
8685 ip6_address_t tun_src6;
8686 ip6_address_t tun_dst6;
8688 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8689 if (unformat (i, "del"))
8691 else if (unformat (i, "sad_id %d", &sad_id))
8693 else if (unformat (i, "spi %d", &spi))
8695 else if (unformat (i, "esp"))
8696 protocol = IPSEC_PROTOCOL_ESP;
8697 else if (unformat (i, "tunnel_src %U", unformat_ip4_address, &tun_src4)) {
8701 else if (unformat (i, "tunnel_dst %U", unformat_ip4_address, &tun_dst4)) {
8705 else if (unformat (i, "tunnel_src %U", unformat_ip6_address, &tun_src6)) {
8709 else if (unformat (i, "tunnel_dst %U", unformat_ip6_address, &tun_dst6)) {
8713 else if (unformat (i, "crypto_alg %U", unformat_ipsec_crypto_alg, &crypto_alg)) {
8714 if (crypto_alg < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
8715 crypto_alg > IPSEC_INTEG_ALG_SHA_512_256) {
8716 clib_warning ("unsupported crypto-alg: '%U'",
8717 format_ipsec_crypto_alg, crypto_alg);
8721 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
8723 else if (unformat (i, "integ_alg %U", unformat_ipsec_integ_alg, &integ_alg)) {
8724 if (integ_alg < IPSEC_INTEG_ALG_SHA1_96 ||
8725 integ_alg > IPSEC_INTEG_ALG_SHA_512_256) {
8726 clib_warning ("unsupported integ-alg: '%U'",
8727 format_ipsec_integ_alg, integ_alg);
8731 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
8734 clib_warning ("parse error '%U'", format_unformat_error, i);
8740 M(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry);
8742 mp->sad_id = ntohl(sad_id);
8743 mp->is_add = is_add;
8744 mp->protocol = protocol;
8745 mp->spi = ntohl(spi);
8746 mp->is_tunnel = is_tunnel;
8747 mp->is_tunnel_ipv6 = is_tunnel_ipv6;
8748 mp->crypto_algorithm = crypto_alg;
8749 mp->integrity_algorithm = integ_alg;
8750 mp->crypto_key_length = vec_len(ck);
8751 mp->integrity_key_length = vec_len(ik);
8753 if (mp->crypto_key_length > sizeof(mp->crypto_key))
8754 mp->crypto_key_length = sizeof(mp->crypto_key);
8756 if (mp->integrity_key_length > sizeof(mp->integrity_key))
8757 mp->integrity_key_length = sizeof(mp->integrity_key);
8759 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
8760 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
8763 if (is_tunnel_ipv6) {
8764 clib_memcpy (mp->tunnel_src_address, &tun_src6, sizeof(ip6_address_t));
8765 clib_memcpy (mp->tunnel_dst_address, &tun_dst6, sizeof(ip6_address_t));
8767 clib_memcpy (mp->tunnel_src_address, &tun_src4, sizeof(ip4_address_t));
8768 clib_memcpy (mp->tunnel_dst_address, &tun_dst4, sizeof(ip4_address_t));
8776 clib_warning ("unsupported (no dpdk)");
8782 api_ipsec_sa_set_key (vat_main_t * vam)
8785 unformat_input_t * i = vam->input;
8786 vl_api_ipsec_sa_set_key_t *mp;
8791 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8792 if (unformat (i, "sa_id %d", &sa_id))
8794 else if (unformat (i, "crypto_key %U", unformat_hex_string, &ck))
8796 else if (unformat (i, "integ_key %U", unformat_hex_string, &ik))
8799 clib_warning ("parse error '%U'", format_unformat_error, i);
8804 M(IPSEC_SA_SET_KEY, ipsec_set_sa_key);
8806 mp->sa_id = ntohl(sa_id);
8807 mp->crypto_key_length = vec_len(ck);
8808 mp->integrity_key_length = vec_len(ik);
8810 if (mp->crypto_key_length > sizeof(mp->crypto_key))
8811 mp->crypto_key_length = sizeof(mp->crypto_key);
8813 if (mp->integrity_key_length > sizeof(mp->integrity_key))
8814 mp->integrity_key_length = sizeof(mp->integrity_key);
8816 clib_memcpy (mp->crypto_key, ck, mp->crypto_key_length);
8817 clib_memcpy (mp->integrity_key, ik, mp->integrity_key_length);
8823 clib_warning ("unsupported (no dpdk)");
8829 api_ikev2_profile_add_del (vat_main_t * vam)
8832 unformat_input_t * i = vam->input;
8833 vl_api_ikev2_profile_add_del_t * mp;
8838 const char * valid_chars = "a-zA-Z0-9_";
8840 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8841 if (unformat (i, "del"))
8843 else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8846 errmsg ("parse error '%U'", format_unformat_error, i);
8851 if (!vec_len (name)) {
8852 errmsg ("profile name must be specified");
8856 if (vec_len (name) > 64) {
8857 errmsg ("profile name too long");
8861 M(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del);
8863 clib_memcpy(mp->name, name, vec_len (name));
8864 mp->is_add = is_add;
8871 clib_warning ("unsupported (no dpdk)");
8877 api_ikev2_profile_set_auth (vat_main_t * vam)
8880 unformat_input_t * i = vam->input;
8881 vl_api_ikev2_profile_set_auth_t * mp;
8885 u32 auth_method = 0;
8888 const char * valid_chars = "a-zA-Z0-9_";
8890 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8891 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8893 else if (unformat (i, "auth_method %U",
8894 unformat_ikev2_auth_method, &auth_method))
8896 else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
8898 else if (unformat (i, "auth_data %v", &data))
8901 errmsg ("parse error '%U'", format_unformat_error, i);
8906 if (!vec_len (name)) {
8907 errmsg ("profile name must be specified");
8911 if (vec_len (name) > 64) {
8912 errmsg ("profile name too long");
8916 if (!vec_len(data)) {
8917 errmsg ("auth_data must be specified");
8922 errmsg ("auth_method must be specified");
8926 M(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth);
8928 mp->is_hex = is_hex;
8929 mp->auth_method = (u8) auth_method;
8930 mp->data_len = vec_len (data);
8931 clib_memcpy (mp->name, name, vec_len (name));
8932 clib_memcpy (mp->data, data, vec_len (data));
8940 clib_warning ("unsupported (no dpdk)");
8946 api_ikev2_profile_set_id (vat_main_t * vam)
8949 unformat_input_t * i = vam->input;
8950 vl_api_ikev2_profile_set_id_t * mp;
8958 const char * valid_chars = "a-zA-Z0-9_";
8960 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
8961 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
8963 else if (unformat (i, "id_type %U",
8964 unformat_ikev2_id_type, &id_type))
8966 else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
8968 data = vec_new(u8, 4);
8969 clib_memcpy(data, ip4.as_u8, 4);
8971 else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
8973 else if (unformat (i, "id_data %v", &data))
8975 else if (unformat (i, "local"))
8977 else if (unformat (i, "remote"))
8980 errmsg ("parse error '%U'", format_unformat_error, i);
8985 if (!vec_len (name)) {
8986 errmsg ("profile name must be specified");
8990 if (vec_len (name) > 64) {
8991 errmsg ("profile name too long");
8995 if (!vec_len(data)) {
8996 errmsg ("id_data must be specified");
9001 errmsg ("id_type must be specified");
9005 M(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id);
9007 mp->is_local = is_local;
9008 mp->id_type = (u8) id_type;
9009 mp->data_len = vec_len (data);
9010 clib_memcpy (mp->name, name, vec_len (name));
9011 clib_memcpy (mp->data, data, vec_len (data));
9019 clib_warning ("unsupported (no dpdk)");
9025 api_ikev2_profile_set_ts (vat_main_t * vam)
9028 unformat_input_t * i = vam->input;
9029 vl_api_ikev2_profile_set_ts_t * mp;
9033 u32 proto = 0, start_port = 0, end_port = (u32) ~0;
9034 ip4_address_t start_addr, end_addr;
9036 const char * valid_chars = "a-zA-Z0-9_";
9038 start_addr.as_u32 = 0;
9039 end_addr.as_u32 = (u32) ~0;
9041 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9042 if (unformat (i, "name %U", unformat_token, valid_chars, &name))
9044 else if (unformat (i, "protocol %d", &proto))
9046 else if (unformat (i, "start_port %d", &start_port))
9048 else if (unformat (i, "end_port %d", &end_port))
9050 else if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
9052 else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
9054 else if (unformat (i, "local"))
9056 else if (unformat (i, "remote"))
9059 errmsg ("parse error '%U'", format_unformat_error, i);
9064 if (!vec_len (name)) {
9065 errmsg ("profile name must be specified");
9069 if (vec_len (name) > 64) {
9070 errmsg ("profile name too long");
9074 M(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts);
9076 mp->is_local = is_local;
9077 mp->proto = (u8) proto;
9078 mp->start_port = (u16) start_port;
9079 mp->end_port = (u16) end_port;
9080 mp->start_addr = start_addr.as_u32;
9081 mp->end_addr = end_addr.as_u32;
9082 clib_memcpy (mp->name, name, vec_len (name));
9089 clib_warning ("unsupported (no dpdk)");
9095 api_ikev2_set_local_key (vat_main_t * vam)
9098 unformat_input_t * i = vam->input;
9099 vl_api_ikev2_set_local_key_t * mp;
9103 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9104 if (unformat (i, "file %v", &file))
9107 errmsg ("parse error '%U'", format_unformat_error, i);
9112 if (!vec_len (file)) {
9113 errmsg ("RSA key file must be specified");
9117 if (vec_len (file) > 256) {
9118 errmsg ("file name too long");
9122 M(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key);
9124 clib_memcpy (mp->key_file, file, vec_len (file));
9131 clib_warning ("unsupported (no dpdk)");
9139 static int api_map_add_domain (vat_main_t * vam)
9141 unformat_input_t *i = vam->input;
9142 vl_api_map_add_domain_t *mp;
9145 ip4_address_t ip4_prefix;
9146 ip6_address_t ip6_prefix;
9147 ip6_address_t ip6_src;
9149 u32 ip6_prefix_len, ip4_prefix_len, ea_bits_len, psid_offset,
9151 u8 is_translation = 0;
9153 u8 ip6_src_len = 128;
9155 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9156 if (unformat (i, "ip4-pfx %U/%d", unformat_ip4_address,
9157 &ip4_prefix, &ip4_prefix_len))
9159 else if (unformat (i, "ip6-pfx %U/%d", unformat_ip6_address,
9160 &ip6_prefix, &ip6_prefix_len))
9162 else if (unformat (i, "ip6-src %U/%d", unformat_ip6_address, &ip6_src, &ip6_src_len))
9164 else if (unformat (i, "ip6-src %U", unformat_ip6_address, &ip6_src))
9166 else if (unformat (i, "ea-bits-len %d", &ea_bits_len))
9168 else if (unformat (i, "psid-offset %d", &psid_offset))
9170 else if (unformat (i, "psid-len %d", &psid_length))
9172 else if (unformat (i, "mtu %d", &mtu))
9174 else if (unformat (i, "map-t"))
9177 clib_warning ("parse error '%U'", format_unformat_error, i);
9182 if (num_m_args != 6) {
9183 errmsg("mandatory argument(s) missing\n");
9187 /* Construct the API message */
9188 M(MAP_ADD_DOMAIN, map_add_domain);
9190 clib_memcpy(mp->ip4_prefix, &ip4_prefix, sizeof(ip4_prefix));
9191 mp->ip4_prefix_len = ip4_prefix_len;
9193 clib_memcpy(mp->ip6_prefix, &ip6_prefix, sizeof(ip6_prefix));
9194 mp->ip6_prefix_len = ip6_prefix_len;
9196 clib_memcpy(mp->ip6_src, &ip6_src, sizeof(ip6_src));
9197 mp->ip6_src_prefix_len = ip6_src_len;
9199 mp->ea_bits_len = ea_bits_len;
9200 mp->psid_offset = psid_offset;
9201 mp->psid_length = psid_length;
9202 mp->is_translation = is_translation;
9203 mp->mtu = htons(mtu);
9208 /* Wait for a reply, return good/bad news */
9212 static int api_map_del_domain (vat_main_t * vam)
9214 unformat_input_t *i = vam->input;
9215 vl_api_map_del_domain_t *mp;
9221 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9222 if (unformat (i, "index %d", &index))
9225 clib_warning ("parse error '%U'", format_unformat_error, i);
9230 if (num_m_args != 1) {
9231 errmsg("mandatory argument(s) missing\n");
9235 /* Construct the API message */
9236 M(MAP_DEL_DOMAIN, map_del_domain);
9238 mp->index = ntohl(index);
9243 /* Wait for a reply, return good/bad news */
9247 static int api_map_add_del_rule (vat_main_t * vam)
9249 unformat_input_t *i = vam->input;
9250 vl_api_map_add_del_rule_t *mp;
9253 ip6_address_t ip6_dst;
9254 u32 num_m_args = 0, index, psid;
9256 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9257 if (unformat (i, "index %d", &index))
9259 else if (unformat (i, "psid %d", &psid))
9261 else if (unformat (i, "dst %U", unformat_ip6_address, &ip6_dst))
9263 else if (unformat (i, "del")) {
9266 clib_warning ("parse error '%U'", format_unformat_error, i);
9271 /* Construct the API message */
9272 M(MAP_ADD_DEL_RULE, map_add_del_rule);
9274 mp->index = ntohl(index);
9275 mp->is_add = is_add;
9276 clib_memcpy(mp->ip6_dst, &ip6_dst, sizeof(ip6_dst));
9277 mp->psid = ntohs(psid);
9282 /* Wait for a reply, return good/bad news */
9286 static int api_map_domain_dump (vat_main_t * vam)
9288 vl_api_map_domain_dump_t *mp;
9291 /* Construct the API message */
9292 M(MAP_DOMAIN_DUMP, map_domain_dump);
9297 /* Use a control ping for synchronization */
9299 vl_api_control_ping_t * mp;
9300 M(CONTROL_PING, control_ping);
9306 static int api_map_rule_dump (vat_main_t * vam)
9308 unformat_input_t *i = vam->input;
9309 vl_api_map_rule_dump_t *mp;
9311 u32 domain_index = ~0;
9313 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9314 if (unformat (i, "index %u", &domain_index))
9320 if (domain_index == ~0) {
9321 clib_warning("parse error: domain index expected");
9325 /* Construct the API message */
9326 M(MAP_RULE_DUMP, map_rule_dump);
9328 mp->domain_index = htonl(domain_index);
9333 /* Use a control ping for synchronization */
9335 vl_api_control_ping_t * mp;
9336 M(CONTROL_PING, control_ping);
9342 static void vl_api_map_add_domain_reply_t_handler
9343 (vl_api_map_add_domain_reply_t * mp)
9345 vat_main_t * vam = &vat_main;
9346 i32 retval = ntohl(mp->retval);
9348 if (vam->async_mode) {
9349 vam->async_errors += (retval < 0);
9351 vam->retval = retval;
9352 vam->result_ready = 1;
9356 static void vl_api_map_add_domain_reply_t_handler_json
9357 (vl_api_map_add_domain_reply_t * mp)
9359 vat_main_t * vam = &vat_main;
9360 vat_json_node_t node;
9362 vat_json_init_object(&node);
9363 vat_json_object_add_int(&node, "retval", ntohl(mp->retval));
9364 vat_json_object_add_uint(&node, "index", ntohl(mp->index));
9366 vat_json_print(vam->ofp, &node);
9367 vat_json_free(&node);
9369 vam->retval = ntohl(mp->retval);
9370 vam->result_ready = 1;
9374 api_get_first_msg_id (vat_main_t * vam)
9376 vl_api_get_first_msg_id_t * mp;
9378 unformat_input_t * i = vam->input;
9382 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
9383 if (unformat (i, "client %s", &name))
9389 if (name_set == 0) {
9390 errmsg ("missing client name\n");
9395 if (vec_len (name) > 63) {
9396 errmsg ("client name too long\n");
9400 M(GET_FIRST_MSG_ID, get_first_msg_id);
9401 clib_memcpy (mp->name, name, vec_len(name));
9407 static int api_cop_interface_enable_disable (vat_main_t * vam)
9409 unformat_input_t * line_input = vam->input;
9410 vl_api_cop_interface_enable_disable_t * mp;
9412 u32 sw_if_index = ~0;
9413 u8 enable_disable = 1;
9415 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9416 if (unformat (line_input, "disable"))
9418 if (unformat (line_input, "enable"))
9420 else if (unformat (line_input, "%U", unformat_sw_if_index,
9423 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9429 if (sw_if_index == ~0) {
9430 errmsg ("missing interface name or sw_if_index\n");
9434 /* Construct the API message */
9435 M(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable);
9436 mp->sw_if_index = ntohl(sw_if_index);
9437 mp->enable_disable = enable_disable;
9441 /* Wait for the reply */
9445 static int api_cop_whitelist_enable_disable (vat_main_t * vam)
9447 unformat_input_t * line_input = vam->input;
9448 vl_api_cop_whitelist_enable_disable_t * mp;
9450 u32 sw_if_index = ~0;
9451 u8 ip4=0, ip6=0, default_cop=0;
9454 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
9455 if (unformat (line_input, "ip4"))
9457 else if (unformat (line_input, "ip6"))
9459 else if (unformat (line_input, "default"))
9461 else if (unformat (line_input, "%U", unformat_sw_if_index,
9464 else if (unformat (line_input, "sw_if_index %d", &sw_if_index))
9466 else if (unformat (line_input, "fib-id %d", &fib_id))
9472 if (sw_if_index == ~0) {
9473 errmsg ("missing interface name or sw_if_index\n");
9477 /* Construct the API message */
9478 M(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable);
9479 mp->sw_if_index = ntohl(sw_if_index);
9480 mp->fib_id = ntohl(fib_id);
9483 mp->default_cop = default_cop;
9487 /* Wait for the reply */
9491 static int api_get_node_graph (vat_main_t * vam)
9493 vl_api_get_node_graph_t * mp;
9496 M(GET_NODE_GRAPH, get_node_graph);
9500 /* Wait for the reply */
9505 api_lisp_add_del_locator_set(vat_main_t * vam)
9507 unformat_input_t * input = vam->input;
9508 vl_api_lisp_add_del_locator_set_t *mp;
9511 u8 *locator_set_name = NULL;
9512 u8 locator_set_name_set = 0;
9514 /* Parse args required to build the message */
9515 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9516 if (unformat(input, "del")) {
9518 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9519 locator_set_name_set = 1;
9524 if (locator_set_name_set == 0) {
9525 errmsg ("missing locator-set name");
9529 if (vec_len(locator_set_name) > 64) {
9530 errmsg ("locator-set name too long\n");
9531 vec_free(locator_set_name);
9534 vec_add1(locator_set_name, 0);
9536 /* Construct the API message */
9537 M(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set);
9539 mp->is_add = is_add;
9540 clib_memcpy(mp->locator_set_name, locator_set_name,
9541 vec_len(locator_set_name));
9542 vec_free(locator_set_name);
9547 /* Wait for a reply... */
9555 api_lisp_add_del_locator(vat_main_t * vam)
9557 unformat_input_t * input = vam->input;
9558 vl_api_lisp_add_del_locator_t *mp;
9560 u32 tmp_if_index = ~0;
9561 u32 sw_if_index = ~0;
9562 u8 sw_if_index_set = 0;
9563 u8 sw_if_index_if_name_set = 0;
9565 u8 priority_set = 0;
9569 u8 *locator_set_name = NULL;
9570 u8 locator_set_name_set = 0;
9572 /* Parse args required to build the message */
9573 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9574 if (unformat(input, "del")) {
9576 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9577 locator_set_name_set = 1;
9578 } else if (unformat(input, "iface %U", unformat_sw_if_index, vam,
9580 sw_if_index_if_name_set = 1;
9581 sw_if_index = tmp_if_index;
9582 } else if (unformat(input,"sw_if_index %d", &tmp_if_index)) {
9583 sw_if_index_set = 1;
9584 sw_if_index = tmp_if_index;
9585 } else if (unformat(input, "p %d", &priority)) {
9587 } else if (unformat(input, "w %d", &weight)) {
9593 if (locator_set_name_set == 0) {
9594 errmsg ("missing locator-set name");
9598 if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0) {
9599 errmsg ("missing sw_if_index");
9600 vec_free(locator_set_name);
9604 if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0) {
9605 errmsg ("cannot use both params interface name and sw_if_index");
9606 vec_free(locator_set_name);
9610 if (priority_set == 0) {
9611 errmsg ("missing locator-set priority\n");
9612 vec_free(locator_set_name);
9616 if (weight_set == 0) {
9617 errmsg ("missing locator-set weight\n");
9618 vec_free(locator_set_name);
9622 if (vec_len(locator_set_name) > 64) {
9623 errmsg ("locator-set name too long\n");
9624 vec_free(locator_set_name);
9627 vec_add1(locator_set_name, 0);
9629 /* Construct the API message */
9630 M(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator);
9632 mp->is_add = is_add;
9633 mp->sw_if_index = ntohl(sw_if_index);
9634 mp->priority = priority;
9635 mp->weight = weight;
9636 clib_memcpy(mp->locator_set_name, locator_set_name,
9637 vec_len(locator_set_name));
9638 vec_free(locator_set_name);
9643 /* Wait for a reply... */
9651 api_lisp_add_del_local_eid(vat_main_t * vam)
9653 unformat_input_t * input = vam->input;
9654 vl_api_lisp_add_del_local_eid_t *mp;
9659 ip4_address_t eidv4;
9660 ip6_address_t eidv6;
9661 u8 tmp_eid_lenght = ~0;
9663 u8 *locator_set_name = NULL;
9664 u8 locator_set_name_set = 0;
9666 /* Parse args required to build the message */
9667 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9668 if (unformat(input, "del")) {
9670 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
9671 &eidv4, &tmp_eid_lenght)) {
9672 eid_lenght = tmp_eid_lenght;
9674 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
9675 &eidv6, &tmp_eid_lenght)) {
9676 eid_lenght = tmp_eid_lenght;
9678 } else if (unformat(input, "locator-set %s", &locator_set_name)) {
9679 locator_set_name_set = 1;
9684 if (locator_set_name_set == 0) {
9685 errmsg ("missing locator-set name\n");
9689 if (vec_len(locator_set_name) > 64) {
9690 errmsg ("locator-set name too long\n");
9691 vec_free(locator_set_name);
9694 vec_add1(locator_set_name, 0);
9696 if (eidv4_set && eidv6_set) {
9697 errmsg ("both eid v4 and v6 addresses set\n");
9698 vec_free(locator_set_name);
9702 if (!eidv4_set && !eidv6_set) {
9703 errmsg ("eid addresses not set\n");
9704 vec_free(locator_set_name);
9708 if (eidv4_set && eid_lenght > 32) {
9709 errmsg ("eid prefix to big\n");
9710 vec_free(locator_set_name);
9714 if (eidv6_set && eid_lenght > 128) {
9715 errmsg ("eid prefix to big\n");
9716 vec_free(locator_set_name);
9720 /* Construct the API message */
9721 M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid);
9723 mp->is_add = is_add;
9726 clib_memcpy(mp->ip_address, &eidv6, sizeof(eidv6));
9729 clib_memcpy(mp->ip_address, &eidv4, sizeof(eidv4));
9731 mp->prefix_len = eid_lenght;
9732 clib_memcpy(mp->locator_set_name, locator_set_name,
9733 vec_len(locator_set_name));
9734 vec_free(locator_set_name);
9739 /* Wait for a reply... */
9747 api_lisp_gpe_add_del_fwd_entry(vat_main_t * vam)
9749 unformat_input_t * input = vam->input;
9750 vl_api_lisp_gpe_add_del_fwd_entry_t *mp;
9753 u8 eidv4_set = 0, slocv4_set = 0, dlocv4_set = 0;
9754 u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0;
9755 ip4_address_t eidv4, slocv4, dlocv4;
9756 ip6_address_t eidv6, slocv6, dlocv6;
9757 u8 tmp_eid_lenght = ~0;
9760 /* Parse args required to build the message */
9761 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9762 if (unformat(input, "del")) {
9764 } else if (unformat(input, "eid %U/%d", unformat_ip4_address,
9765 &eidv4, &tmp_eid_lenght)) {
9766 eid_lenght = tmp_eid_lenght;
9768 } else if (unformat(input, "eid %U/%d", unformat_ip6_address,
9769 &eidv6, &tmp_eid_lenght)) {
9770 eid_lenght = tmp_eid_lenght;
9772 } else if (unformat(input, "sloc %U", unformat_ip4_address, &slocv4)) {
9774 } else if (unformat(input, "sloc %U", unformat_ip6_address, &slocv6)) {
9776 } else if (unformat(input, "dloc %U", unformat_ip4_address, &dlocv4)) {
9778 } else if (unformat(input, "dloc %U", unformat_ip6_address, &dlocv6)) {
9784 if (eidv4_set && eidv6_set) {
9785 errmsg ("both eid v4 and v6 addresses set\n");
9789 if (!eidv4_set && !eidv6_set) {
9790 errmsg ("eid addresses not set\n");
9794 if (slocv4_set && slocv6_set) {
9795 errmsg ("both source v4 and v6 addresses set\n");
9799 if (!slocv4_set && !slocv6_set) {
9800 errmsg ("source addresses not set\n");
9804 if (dlocv4_set && dlocv6_set) {
9805 errmsg ("both destination v4 and v6 addresses set\n");
9809 if (dlocv4_set && dlocv6_set) {
9810 errmsg ("destination addresses not set\n");
9814 if (!(slocv4_set == dlocv4_set && slocv6_set == dlocv6_set)) {
9815 errmsg ("mixing type of source and destination address\n");
9819 /* Construct the API message */
9820 M(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry);
9822 mp->is_add = is_add;
9824 mp->eid_is_ipv6 = 1;
9825 clib_memcpy(mp->eid_ip_address, &eidv6, sizeof(eidv6));
9827 mp->eid_is_ipv6 = 0;
9828 clib_memcpy(mp->eid_ip_address, &eidv4, sizeof(eidv4));
9830 mp->eid_prefix_len = eid_lenght;
9832 mp->address_is_ipv6 = 1;
9833 clib_memcpy(mp->source_ip_address, &slocv6, sizeof(slocv6));
9834 clib_memcpy(mp->destination_ip_address, &dlocv6, sizeof(dlocv6));
9836 mp->address_is_ipv6 = 0;
9837 clib_memcpy(mp->source_ip_address, &slocv4, sizeof(slocv4));
9838 clib_memcpy(mp->destination_ip_address, &dlocv4, sizeof(dlocv4));
9844 /* Wait for a reply... */
9852 api_lisp_add_del_map_resolver(vat_main_t * vam)
9854 unformat_input_t * input = vam->input;
9855 vl_api_lisp_add_del_map_resolver_t *mp;
9863 /* Parse args required to build the message */
9864 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9865 if (unformat(input, "del")) {
9867 } else if (unformat(input, "%U", unformat_ip4_address, &ipv4)) {
9869 } else if (unformat(input, "%U", unformat_ip6_address, &ipv6)) {
9875 if (ipv4_set && ipv6_set) {
9876 errmsg ("both eid v4 and v6 addresses set\n");
9880 if (!ipv4_set && !ipv6_set) {
9881 errmsg ("eid addresses not set\n");
9885 /* Construct the API message */
9886 M(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver);
9888 mp->is_add = is_add;
9891 clib_memcpy(mp->ip_address, &ipv6, sizeof(ipv6));
9894 clib_memcpy(mp->ip_address, &ipv4, sizeof(ipv4));
9900 /* Wait for a reply... */
9908 api_lisp_gpe_enable_disable (vat_main_t * vam)
9910 unformat_input_t * input = vam->input;
9911 vl_api_lisp_gpe_enable_disable_t *mp;
9916 /* Parse args required to build the message */
9917 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
9918 if (unformat(input, "enable")) {
9921 } else if (unformat(input, "disable")) {
9929 errmsg("Value not set\n");
9933 /* Construct the API message */
9934 M(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable);
9941 /* Wait for a reply... */
9949 api_lisp_enable_disable (vat_main_t * vam)
9951 unformat_input_t * input = vam->input;
9952 vl_api_lisp_enable_disable_t *mp;
9957 /* Parse args required to build the message */
9958 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
9960 if (unformat (input, "enable"))
9965 else if (unformat (input, "disable"))
9975 errmsg ("Value not set\n");
9979 /* Construct the API message */
9980 M(LISP_ENABLE_DISABLE, lisp_enable_disable);
9987 /* Wait for a reply... */
9994 /** Used for transferring locators via VPP API */
9995 typedef CLIB_PACKED(struct
9997 u8 is_ip4; /**< is locator an IPv4 address? */
9998 u8 addr[16]; /**< IPv4/IPv6 address */
10002 * Add/del remote mapping from LISP control plane and updates
10003 * forwarding entries in data-plane accordingly.
10005 * @param vam vpp API test context
10006 * @return return code
10009 api_lisp_add_del_remote_mapping (vat_main_t * vam)
10011 unformat_input_t * input = vam->input;
10012 vl_api_lisp_add_del_remote_mapping_t *mp;
10015 u8 seid_set = 0, deid_set = 0;
10016 ip4_address_t seid4, deid4, rloc4;
10017 ip6_address_t seid6, deid6, rloc6;
10018 u32 seid_len = 0, deid_len = 0, len;
10019 u8 deid_is_ip4 = 0, seid_is_ip4 = 0;
10022 rloc_t * rlocs = 0, rloc;
10024 /* Parse args required to build the message */
10025 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10026 if (unformat(input, "del")) {
10028 } else if (unformat(input, "add")) {
10030 } else if (unformat(input, "deid %U/%d", unformat_ip4_address,
10035 } else if (unformat(input, "deid %U/%d", unformat_ip6_address,
10040 } else if (unformat(input, "seid %U/%d", unformat_ip4_address,
10045 } else if (unformat(input, "seid %U/%d", unformat_ip6_address,
10050 } else if (unformat(input, "vni %d", &vni)) {
10052 } else if (unformat(input, "rloc %U", unformat_ip4_address, &rloc4)) {
10054 clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
10055 vec_add1 (rlocs, rloc);
10056 } else if (unformat(input, "rloc %U", unformat_ip6_address, &rloc6)) {
10058 clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
10059 vec_add1 (rlocs, rloc);
10060 } else if (unformat(input, "action %d", &action)) {
10063 clib_warning ("parse error '%U'", format_unformat_error, input);
10068 if (!seid_set || !deid_set) {
10069 errmsg ("missing params!");
10073 if (seid_is_ip4 != deid_is_ip4) {
10074 errmsg ("source and destination EIDs are not in " "same IP family!");
10078 if (is_add && (~0 == action)
10079 && 0 == vec_len (rlocs)) {
10080 errmsg ("no action set for negative map-reply!");
10084 M(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping);
10085 mp->is_add = is_add;
10086 mp->vni = htonl (vni);
10087 mp->seid_len = seid_len;
10088 mp->action = (u8) action;
10089 mp->deid_len = deid_len;
10091 mp->eid_is_ip4 = 1;
10092 clib_memcpy (mp->seid, &seid4, sizeof (seid4));
10094 mp->eid_is_ip4 = 0;
10095 clib_memcpy (mp->seid, &seid6, sizeof (seid6));
10099 mp->eid_is_ip4 = 1;
10100 clib_memcpy (mp->deid, &deid4, sizeof (deid4));
10102 mp->eid_is_ip4 = 0;
10103 clib_memcpy (mp->deid, &deid6, sizeof (deid6));
10106 mp->rloc_num = vec_len (rlocs);
10107 clib_memcpy (mp->rlocs, rlocs, (sizeof (rloc_t) * vec_len (rlocs)));
10113 /* Wait for a reply... */
10121 api_lisp_gpe_add_del_iface(vat_main_t * vam)
10123 unformat_input_t * input = vam->input;
10124 vl_api_lisp_gpe_add_del_iface_t *mp;
10130 /* Parse args required to build the message */
10131 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
10132 if (unformat(input, "up")) {
10135 } else if (unformat(input, "down")) {
10138 } else if (unformat(input, "table_id %d", &table_id)) {
10140 } else if (unformat(input, "vni %d", &vni)) {
10147 errmsg("Value not set\n");
10151 /* Construct the API message */
10152 M(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface);
10154 mp->is_add = is_add;
10155 mp->table_id = table_id;
10161 /* Wait for a reply... */
10169 api_lisp_locator_set_dump(vat_main_t *vam)
10171 vl_api_lisp_locator_set_dump_t *mp;
10174 if (!vam->json_output) {
10175 fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n",
10176 "Locator-set", "Locator", "Priority", "Weight");
10179 M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump);
10183 /* Use a control ping for synchronization */
10185 vl_api_control_ping_t * mp;
10186 M(CONTROL_PING, control_ping);
10189 /* Wait for a reply... */
10197 api_lisp_local_eid_table_dump(vat_main_t *vam)
10199 vl_api_lisp_local_eid_table_dump_t *mp;
10202 if (!vam->json_output) {
10203 fformat(vam->ofp, "%=20s%=30s\n",
10204 "Locator-set", "Eid");
10207 M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump);
10211 /* Use a control ping for synchronization */
10213 vl_api_control_ping_t * mp;
10214 M(CONTROL_PING, control_ping);
10217 /* Wait for a reply... */
10225 api_lisp_gpe_tunnel_dump(vat_main_t *vam)
10227 vl_api_lisp_gpe_tunnel_dump_t *mp;
10230 if (!vam->json_output) {
10231 fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s"
10232 "%=16s%=16s%=16s%=16s%=16s\n",
10233 "Tunel", "Source", "Destination", "Fib encap", "Fib decap",
10234 "Decap next", "Lisp version", "Flags", "Next protocol",
10235 "ver_res", "res", "iid");
10238 M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump);
10242 /* Use a control ping for synchronization */
10244 vl_api_control_ping_t * mp;
10245 M(CONTROL_PING, control_ping);
10248 /* Wait for a reply... */
10256 api_lisp_map_resolver_dump(vat_main_t *vam)
10258 vl_api_lisp_map_resolver_dump_t *mp;
10261 if (!vam->json_output) {
10262 fformat(vam->ofp, "%=20s\n",
10266 M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump);
10270 /* Use a control ping for synchronization */
10272 vl_api_control_ping_t * mp;
10273 M(CONTROL_PING, control_ping);
10276 /* Wait for a reply... */
10284 api_lisp_enable_disable_status_dump(vat_main_t *vam)
10286 vl_api_lisp_enable_disable_status_dump_t *mp;
10289 if (!vam->json_output) {
10290 fformat(vam->ofp, "%=20s\n",
10294 M(LISP_ENABLE_DISABLE_STATUS_DUMP,
10295 lisp_enable_disable_status_dump);
10299 /* Use a control ping for synchronization */
10301 vl_api_control_ping_t * mp;
10302 M(CONTROL_PING, control_ping);
10305 /* Wait for a reply... */
10313 api_af_packet_create (vat_main_t * vam)
10315 unformat_input_t * i = vam->input;
10316 vl_api_af_packet_create_t * mp;
10318 u8 * host_if_name = 0;
10320 u8 random_hw_addr = 1;
10322 memset (hw_addr, 0, sizeof (hw_addr));
10324 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10325 if (unformat (i, "name %s", &host_if_name))
10326 vec_add1 (host_if_name, 0);
10327 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
10328 random_hw_addr = 0;
10333 if (!vec_len (host_if_name)) {
10334 errmsg ("host-interface name must be specified");
10338 if (vec_len (host_if_name) > 64) {
10339 errmsg ("host-interface name too long");
10343 M(AF_PACKET_CREATE, af_packet_create);
10345 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
10346 clib_memcpy (mp->hw_addr, hw_addr, 6);
10347 mp->use_random_hw_addr = random_hw_addr;
10348 vec_free (host_if_name);
10356 api_af_packet_delete (vat_main_t * vam)
10358 unformat_input_t * i = vam->input;
10359 vl_api_af_packet_delete_t * mp;
10361 u8 * host_if_name = 0;
10363 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10364 if (unformat (i, "name %s", &host_if_name))
10365 vec_add1 (host_if_name, 0);
10370 if (!vec_len (host_if_name)) {
10371 errmsg ("host-interface name must be specified");
10375 if (vec_len (host_if_name) > 64) {
10376 errmsg ("host-interface name too long");
10380 M(AF_PACKET_DELETE, af_packet_delete);
10382 clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
10383 vec_free (host_if_name);
10391 api_policer_add_del (vat_main_t * vam)
10393 unformat_input_t * i = vam->input;
10394 vl_api_policer_add_del_t * mp;
10406 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10407 if (unformat (i, "del"))
10409 else if (unformat (i, "name %s", &name))
10410 vec_add1 (name, 0);
10411 else if (unformat (i, "cir %u", &cir))
10413 else if (unformat (i, "eir %u", &eir))
10415 else if (unformat (i, "cb %u", &cb))
10417 else if (unformat (i, "eb %u", &eb))
10419 else if (unformat (i, "rate_type %U", unformat_policer_rate_type,
10422 else if (unformat (i, "round_type %U", unformat_policer_round_type,
10425 else if (unformat (i, "type %U", unformat_policer_type, &type))
10431 if (!vec_len (name)) {
10432 errmsg ("policer name must be specified");
10436 if (vec_len (name) > 64) {
10437 errmsg ("policer name too long");
10441 M(POLICER_ADD_DEL, policer_add_del);
10443 clib_memcpy (mp->name, name, vec_len (name));
10445 mp->is_add = is_add;
10450 mp->rate_type = rate_type;
10451 mp->round_type = round_type;
10460 api_policer_dump(vat_main_t *vam)
10462 unformat_input_t * i = vam->input;
10463 vl_api_policer_dump_t *mp;
10465 u8 *match_name = 0;
10466 u8 match_name_valid = 0;
10468 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10469 if (unformat (i, "name %s", &match_name)) {
10470 vec_add1 (match_name, 0);
10471 match_name_valid = 1;
10476 M(POLICER_DUMP, policer_dump);
10477 mp->match_name_valid = match_name_valid;
10478 clib_memcpy (mp->match_name, match_name, vec_len (match_name));
10479 vec_free (match_name);
10483 /* Use a control ping for synchronization */
10485 vl_api_control_ping_t * mp;
10486 M(CONTROL_PING, control_ping);
10489 /* Wait for a reply... */
10497 api_netmap_create (vat_main_t * vam)
10499 unformat_input_t * i = vam->input;
10500 vl_api_netmap_create_t * mp;
10504 u8 random_hw_addr = 1;
10508 memset (hw_addr, 0, sizeof (hw_addr));
10510 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10511 if (unformat (i, "name %s", &if_name))
10512 vec_add1 (if_name, 0);
10513 else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
10514 random_hw_addr = 0;
10515 else if (unformat (i, "pipe"))
10517 else if (unformat (i, "master"))
10519 else if (unformat (i, "slave"))
10525 if (!vec_len (if_name)) {
10526 errmsg ("interface name must be specified");
10530 if (vec_len (if_name) > 64) {
10531 errmsg ("interface name too long");
10535 M(NETMAP_CREATE, netmap_create);
10537 clib_memcpy (mp->if_name, if_name, vec_len (if_name));
10538 clib_memcpy (mp->hw_addr, hw_addr, 6);
10539 mp->use_random_hw_addr = random_hw_addr;
10540 mp->is_pipe = is_pipe;
10541 mp->is_master = is_master;
10542 vec_free (if_name);
10550 api_netmap_delete (vat_main_t * vam)
10552 unformat_input_t * i = vam->input;
10553 vl_api_netmap_delete_t * mp;
10557 while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) {
10558 if (unformat (i, "name %s", &if_name))
10559 vec_add1 (if_name, 0);
10564 if (!vec_len (if_name)) {
10565 errmsg ("interface name must be specified");
10569 if (vec_len (if_name) > 64) {
10570 errmsg ("interface name too long");
10574 M(NETMAP_DELETE, netmap_delete);
10576 clib_memcpy (mp->if_name, if_name, vec_len (if_name));
10577 vec_free (if_name);
10584 static int q_or_quit (vat_main_t * vam)
10586 longjmp (vam->jump_buf, 1);
10587 return 0; /* not so much */
10589 static int q (vat_main_t * vam) {return q_or_quit (vam);}
10590 static int quit (vat_main_t * vam) {return q_or_quit (vam);}
10592 static int comment (vat_main_t * vam)
10597 static int cmd_cmp (void * a1, void * a2)
10602 return strcmp ((char *)(c1[0]), (char *)(c2[0]));
10605 static int help (vat_main_t * vam)
10610 unformat_input_t * i = vam->input;
10613 if (unformat (i, "%s", &name)) {
10618 hs = hash_get_mem (vam->help_by_name, name);
10620 fformat (vam->ofp, "usage: %s %s\n", name, hs[0]);
10622 fformat (vam->ofp, "No such msg / command '%s'\n", name);
10627 fformat(vam->ofp, "Help is available for the following:\n");
10629 hash_foreach_pair (p, vam->function_by_name,
10631 vec_add1 (cmds, (u8 *)(p->key));
10634 vec_sort_with_function (cmds, cmd_cmp);
10636 for (j = 0; j < vec_len(cmds); j++)
10637 fformat (vam->ofp, "%s\n", cmds[j]);
10643 static int set (vat_main_t * vam)
10645 u8 * name = 0, * value = 0;
10646 unformat_input_t * i = vam->input;
10648 if (unformat (i, "%s", &name)) {
10649 /* The input buffer is a vector, not a string. */
10650 value = vec_dup (i->buffer);
10651 vec_delete (value, i->index, 0);
10652 /* Almost certainly has a trailing newline */
10653 if (value[vec_len(value)-1] == '\n')
10654 value[vec_len(value)-1] = 0;
10655 /* Make sure it's a proper string, one way or the other */
10656 vec_add1 (value, 0);
10657 (void) clib_macro_set_value (&vam->macro_main,
10658 (char *)name, (char *)value);
10661 errmsg ("usage: set <name> <value>\n");
10668 static int unset (vat_main_t * vam)
10672 if (unformat (vam->input, "%s", &name))
10673 if (clib_macro_unset (&vam->macro_main, (char *)name) == 1)
10674 errmsg ("unset: %s wasn't set\n", name);
10685 static int macro_sort_cmp (void * a1, void * a2)
10687 macro_sort_t * s1 = a1;
10688 macro_sort_t * s2 = a2;
10690 return strcmp ((char *)(s1->name), (char *)(s2->name));
10693 static int dump_macro_table (vat_main_t * vam)
10695 macro_sort_t * sort_me = 0, * sm;
10699 hash_foreach_pair (p, vam->macro_main.the_value_table_hash,
10701 vec_add2 (sort_me, sm, 1);
10702 sm->name = (u8 *)(p->key);
10703 sm->value = (u8 *) (p->value[0]);
10706 vec_sort_with_function (sort_me, macro_sort_cmp);
10708 if (vec_len(sort_me))
10709 fformat (vam->ofp, "%-15s%s\n", "Name", "Value");
10711 fformat (vam->ofp, "The macro table is empty...\n");
10713 for (i = 0; i < vec_len (sort_me); i++)
10714 fformat (vam->ofp, "%-15s%s\n", sort_me[i].name,
10719 static int dump_node_table (vat_main_t * vam)
10722 vlib_node_t * node, * next_node;
10724 if (vec_len (vam->graph_nodes) == 0) {
10725 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
10729 for (i = 0; i < vec_len (vam->graph_nodes); i++) {
10730 node = vam->graph_nodes[i];
10731 fformat (vam->ofp, "[%d] %s\n", i, node->name);
10732 for (j = 0; j < vec_len (node->next_nodes); j++) {
10733 if (node->next_nodes[j] != ~0) {
10734 next_node = vam->graph_nodes[node->next_nodes[j]];
10735 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
10742 static int search_node_table (vat_main_t * vam)
10744 unformat_input_t * line_input = vam->input;
10747 vlib_node_t * node, * next_node;
10750 if (vam->graph_node_index_by_name == 0) {
10751 fformat (vam->ofp, "Node table empty, issue get_node_graph...\n");
10755 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
10756 if (unformat (line_input, "%s", &node_to_find)) {
10757 vec_add1 (node_to_find, 0);
10758 p = hash_get_mem (vam->graph_node_index_by_name, node_to_find);
10760 fformat (vam->ofp, "%s not found...\n", node_to_find);
10763 node = vam->graph_nodes[p[0]];
10764 fformat (vam->ofp, "[%d] %s\n", p[0], node->name);
10765 for (j = 0; j < vec_len (node->next_nodes); j++) {
10766 if (node->next_nodes[j] != ~0) {
10767 next_node = vam->graph_nodes[node->next_nodes[j]];
10768 fformat (vam->ofp, " [%d] %s\n", j, next_node->name);
10774 clib_warning ("parse error '%U'", format_unformat_error,
10780 vec_free(node_to_find);
10788 static int script (vat_main_t * vam)
10791 char * save_current_file;
10792 unformat_input_t save_input;
10793 jmp_buf save_jump_buf;
10794 u32 save_line_number;
10796 FILE * new_fp, * save_ifp;
10798 if (unformat (vam->input, "%s", &s)) {
10799 new_fp = fopen ((char *)s, "r");
10801 errmsg ("Couldn't open script file %s\n", s);
10806 errmsg ("Missing script name\n");
10810 clib_memcpy (&save_input, &vam->input, sizeof (save_input));
10811 clib_memcpy (&save_jump_buf, &vam->jump_buf, sizeof (save_jump_buf));
10812 save_ifp = vam->ifp;
10813 save_line_number = vam->input_line_number;
10814 save_current_file = (char *) vam->current_file;
10816 vam->input_line_number = 0;
10818 vam->current_file = s;
10821 clib_memcpy (&vam->input, &save_input, sizeof (vam->input));
10822 clib_memcpy (&vam->jump_buf, &save_jump_buf, sizeof (save_jump_buf));
10823 vam->ifp = save_ifp;
10824 vam->input_line_number = save_line_number;
10825 vam->current_file = (u8 *) save_current_file;
10831 static int echo (vat_main_t * vam)
10833 fformat (vam->ofp, "%v", vam->input->buffer);
10837 /* List of API message constructors, CLI names map to api_xxx */
10838 #define foreach_vpe_api_msg \
10839 _(create_loopback,"[mac <mac-addr>]") \
10840 _(sw_interface_dump,"") \
10841 _(sw_interface_set_flags, \
10842 "<intfc> | sw_if_index <id> admin-up | admin-down link-up | link down") \
10843 _(sw_interface_add_del_address, \
10844 "<intfc> | sw_if_index <id> <ip4-address> | <ip6-address> [del] [del-all] ") \
10845 _(sw_interface_set_table, \
10846 "<intfc> | sw_if_index <id> vrf <table-id> [ipv6]") \
10847 _(sw_interface_set_vpath, \
10848 "<intfc> | sw_if_index <id> enable | disable") \
10849 _(sw_interface_set_l2_xconnect, \
10850 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
10851 "enable | disable") \
10852 _(sw_interface_set_l2_bridge, \
10853 "rx <intfc> | rx_sw_if_index <id> bd_id <bridge-domain-id>\n" \
10854 "[shg <split-horizon-group>] [bvi]\n" \
10855 "enable | disable") \
10856 _(bridge_domain_add_del, \
10857 "bd_id <bridge-domain-id> [flood 1|0] [uu-flood 1|0] [forward 1|0] [learn 1|0] [arp-term 1|0] [del]\n")\
10858 _(bridge_domain_dump, "[bd_id <bridge-domain-id>]\n") \
10860 "mac <mac-addr> bd_id <bridge-domain-id> [del] | sw_if <intfc> | sw_if_index <id> [static] [filter] [bvi]\n") \
10862 "sw_if <intfc> | sw_if_index <id> [learn] [forward] [uu-flood] [flood]\n") \
10864 "bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
10866 "tapname <name> mac <mac-addr> | random-mac") \
10868 "<vpp-if-name> | sw_if_index <id> tapname <name> mac <mac-addr> | random-mac") \
10870 "<vpp-if-name> | sw_if_index <id>") \
10871 _(sw_interface_tap_dump, "") \
10872 _(ip_add_del_route, \
10873 "<addr>/<mask> via <addr> [vrf <n>]\n" \
10874 "[<intfc> | sw_if_index <id>] [resolve-attempts <n>]\n" \
10875 "[weight <n>] [drop] [local] [classify <n>] [del]\n" \
10876 "[multipath] [count <n>]") \
10877 _(proxy_arp_add_del, \
10878 "<lo-ip4-addr> - <hi-ip4-addr> [vrf <n>] [del]") \
10879 _(proxy_arp_intfc_enable_disable, \
10880 "<intfc> | sw_if_index <id> enable | disable") \
10881 _(mpls_add_del_encap, \
10882 "label <n> dst <ip4-addr> [vrf <n>] [del]") \
10883 _(mpls_add_del_decap, \
10884 "label <n> [rx_vrf_id <n>] [tx_vrf_id] [s-bit-clear][del]") \
10885 _(mpls_gre_add_del_tunnel, \
10886 "inner_vrf_id <n> outer_vrf_id <n> src <ip4-address> dst <ip4-address>\n" \
10887 "adj <ip4-address>/<mask-width> [del]") \
10888 _(sw_interface_set_unnumbered, \
10889 "<intfc> | sw_if_index <id> unnum_if_index <id> [del]") \
10890 _(ip_neighbor_add_del, \
10891 "<intfc> | sw_if_index <id> dst <ip46-address> mac <mac-addr>") \
10892 _(reset_vrf, "vrf <id> [ipv6]") \
10893 _(create_vlan_subif, "<intfc> | sw_if_index <id> vlan <n>") \
10894 _(create_subif, "<intfc> | sw_if_index <id> sub_id <n>\n" \
10895 "[outer_vlan_id <n>][inner_vlan_id <n>]\n" \
10896 "[no_tags][one_tag][two_tags][dot1ad][exact_match][default_sub]\n" \
10897 "[outer_vlan_id_any][inner_vlan_id_any]") \
10898 _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]") \
10899 _(reset_fib, "vrf <n> [ipv6]") \
10900 _(dhcp_proxy_config, \
10901 "svr <v46-address> src <v46-address>\n" \
10902 "insert-cid <n> [del]") \
10903 _(dhcp_proxy_config_2, \
10904 "svr <v46-address> src <v46-address>\n" \
10905 "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]") \
10906 _(dhcp_proxy_set_vss, \
10907 "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]") \
10908 _(dhcp_client_config, \
10909 "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
10910 _(set_ip_flow_hash, \
10911 "vrf <n> [src] [dst] [sport] [dport] [proto] [reverse] [ipv6]") \
10912 _(sw_interface_ip6_enable_disable, \
10913 "<intfc> | sw_if_index <id> enable | disable") \
10914 _(sw_interface_ip6_set_link_local_address, \
10915 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>") \
10916 _(sw_interface_ip6nd_ra_prefix, \
10917 "<intfc> | sw_if_index <id> <ip6-address>/<mask-width>\n" \
10918 "val_life <n> pref_life <n> [def] [noadv] [offl] [noauto]\n" \
10919 "[nolink] [isno]") \
10920 _(sw_interface_ip6nd_ra_config, \
10921 "<intfc> | sw_if_index <id> [maxint <n>] [minint <n>]\n" \
10922 "[life <n>] [count <n>] [interval <n>] [surpress]\n" \
10923 "[managed] [other] [ll] [send] [cease] [isno] [def]") \
10924 _(set_arp_neighbor_limit, "arp_nbr_limit <n> [ipv6]") \
10925 _(l2_patch_add_del, \
10926 "rx <intfc> | rx_sw_if_index <id> tx <intfc> | tx_sw_if_index <id>\n" \
10927 "enable | disable") \
10928 _(mpls_ethernet_add_del_tunnel, \
10929 "tx <intfc> | tx_sw_if_index <n> dst <mac-addr>\n" \
10930 "adj <ip4-addr>/<mw> dst <mac-addr> [del]") \
10931 _(mpls_ethernet_add_del_tunnel_2, \
10932 "inner_vrf_id <n> outer_vrf_id <n> next-hop <ip4-addr>\n" \
10933 "resolve-attempts <n> resolve-if-needed 0 | 1 [del]") \
10934 _(sr_tunnel_add_del, \
10935 "[name <name>] src <ip6-addr> dst <ip6-addr>/<mw> \n" \
10936 "(next <ip6-addr>)+ [tag <ip6-addr>]* [clean] [reroute] \n" \
10937 "[policy <policy_name>]") \
10938 _(sr_policy_add_del, \
10939 "name <name> tunnel <tunnel-name> [tunnel <tunnel-name>]* [del]") \
10940 _(sr_multicast_map_add_del, \
10941 "address [ip6 multicast address] sr-policy [policy name] [del]") \
10942 _(classify_add_del_table, \
10943 "buckets <nn> [skip <n>] [match <n>] [memory_size <nn-bytes>]\n" \
10944 "[del] mask <mask-value>\n" \
10945 " [l2-miss-next | miss-next | acl-miss-next] <name|nn>") \
10946 _(classify_add_del_session, \
10947 "[hit-next|l2-hit-next|acl-hit-next] <name|nn> table-index <nn>\n" \
10948 "skip_n <nn> match_n <nn> match [hex] [l2] [l3 [ip4|ip6]]") \
10949 _(classify_set_interface_ip_table, \
10950 "<intfc> | sw_if_index <nn> table <nn>") \
10951 _(classify_set_interface_l2_tables, \
10952 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
10953 " [other-table <nn>]") \
10954 _(get_node_index, "node <node-name") \
10955 _(add_node_next, "node <node-name> next <next-node-name>") \
10956 _(l2tpv3_create_tunnel, \
10957 "client_address <ip6-addr> our_address <ip6-addr>\n" \
10958 "[local_session_id <nn>][remote_session_id <nn>][local_cookie <nn>]\n"\
10959 "[remote_cookie <nn>]\n[l2-sublayer-preset]\n") \
10960 _(l2tpv3_set_tunnel_cookies, \
10961 "<intfc> | sw_if_index <nn> [new_local_cookie <nn>]\n" \
10962 "[new_remote_cookie <nn>]\n") \
10963 _(l2tpv3_interface_enable_disable, \
10964 "<intfc> | sw_if_index <nn> enable | disable") \
10965 _(l2tpv3_set_lookup_key, \
10966 "lookup_v6_src | lookup_v6_dst | lookup_session_id") \
10967 _(sw_if_l2tpv3_tunnel_dump, "") \
10968 _(vxlan_add_del_tunnel, \
10969 "src <ip4-addr> dst <ip4-addr> vni <vni> [encap-vrf-id <nn>]\n" \
10970 " [decap-next l2|ip4|ip6] [del]") \
10971 _(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
10972 _(gre_add_del_tunnel, \
10973 "src <ip4-addr> dst <ip4-addr> [outer-fib-id <nn>] [del]\n") \
10974 _(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
10975 _(l2_fib_clear_table, "") \
10976 _(l2_interface_efp_filter, "sw_if_index <nn> enable | disable") \
10977 _(l2_interface_vlan_tag_rewrite, \
10978 "<intfc> | sw_if_index <nn> \n" \
10979 "[disable][push-[1|2]][pop-[1|2]][translate-1-[1|2]] \n" \
10980 "[translate-2-[1|2]] [push_dot1q 0] tag1 <nn> tag2 <nn>") \
10981 _(create_vhost_user_if, \
10982 "socket <filename> [server] [renumber <dev_instance>] " \
10983 "[mac <mac_address>]") \
10984 _(modify_vhost_user_if, \
10985 "<intfc> | sw_if_index <nn> socket <filename>\n" \
10986 "[server] [renumber <dev_instance>]") \
10987 _(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
10988 _(sw_interface_vhost_user_dump, "") \
10989 _(show_version, "") \
10990 _(vxlan_gpe_add_del_tunnel, \
10991 "local <ip4-addr> remote <ip4-addr> vni <nn>\n" \
10992 "[encap-vrf-id <nn>] [decap-vrf-id <nn>] [next-ip4][next-ip6]" \
10993 "[next-ethernet] [next-nsh]\n") \
10994 _(l2_fib_table_dump, "bd_id <bridge-domain-id>") \
10995 _(interface_name_renumber, \
10996 "<intfc> | sw_if_index <nn> new_show_dev_instance <nn>") \
10997 _(input_acl_set_interface, \
10998 "<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
10999 " [l2-table <nn>] [del]") \
11000 _(want_ip4_arp_events, "address <ip4-address> [del]") \
11001 _(ip_address_dump, "(ipv4 | ipv6) (<intfc> | sw_if_index <id>)") \
11002 _(ip_dump, "ipv4 | ipv6") \
11003 _(ipsec_spd_add_del, "spd_id <n> [del]") \
11004 _(ipsec_interface_add_del_spd, "(<intfc> | sw_if_index <id>)\n" \
11006 _(ipsec_sad_add_del_entry, "sad_id <n> spi <n> crypto_alg <alg>\n" \
11007 " crypto_key <hex> tunnel_src <ip4|ip6> tunnel_dst <ip4|ip6>\n" \
11008 " integ_alg <alg> integ_key <hex>") \
11009 _(ipsec_spd_add_del_entry, "spd_id <n> priority <n> action <action>\n" \
11010 " (inbound|outbound) [sa_id <n>] laddr_start <ip4|ip6>\n" \
11011 " laddr_stop <ip4|ip6> raddr_start <ip4|ip6> raddr_stop <ip4|ip6>\n" \
11012 " [lport_start <n> lport_stop <n>] [rport_start <n> rport_stop <n>]" )\
11013 _(ipsec_sa_set_key, "sa_id <n> crypto_key <hex> integ_key <hex>") \
11014 _(ikev2_profile_add_del, "name <profile_name> [del]") \
11015 _(ikev2_profile_set_auth, "name <profile_name> auth_method <method>\n" \
11016 "(auth_data 0x<data> | auth_data <data>)") \
11017 _(ikev2_profile_set_id, "name <profile_name> id_type <type>\n" \
11018 "(id_data 0x<data> | id_data <data>) (local|remote)") \
11019 _(ikev2_profile_set_ts, "name <profile_name> protocol <proto>\n" \
11020 "start_port <port> end_port <port> start_addr <ip4> end_addr <ip4>\n" \
11021 "(local|remote)") \
11022 _(ikev2_set_local_key, "file <absolute_file_path>") \
11023 _(delete_loopback,"sw_if_index <nn>") \
11024 _(bd_ip_mac_add_del, "bd_id <bridge-domain-id> <ip4/6-addr> <mac-addr> [del]") \
11025 _(map_add_domain, \
11026 "ip4-pfx <ip4pfx> ip6-pfx <ip6pfx> " \
11027 "ip6-src <ip6addr> " \
11028 "ea-bits-len <n> psid-offset <n> psid-len <n>") \
11029 _(map_del_domain, "index <n>") \
11030 _(map_add_del_rule, \
11031 "index <n> psid <n> dst <ip6addr> [del]") \
11032 _(map_domain_dump, "") \
11033 _(map_rule_dump, "index <map-domain>") \
11034 _(want_interface_events, "enable|disable") \
11035 _(want_stats,"enable|disable") \
11036 _(get_first_msg_id, "client <name>") \
11037 _(cop_interface_enable_disable, "<intfc> | sw_if_index <nn> [disable]") \
11038 _(cop_whitelist_enable_disable, "<intfc> | sw_if_index <nn>\n" \
11039 "fib-id <nn> [ip4][ip6][default]") \
11040 _(get_node_graph, " ") \
11041 _(sw_interface_clear_stats,"<intfc> | sw_if_index <nn>") \
11042 _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \
11043 "trace-elts <nn> trace-tsp <0|1|2|3> node-id <node id in hex> " \
11044 "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \
11045 _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \
11046 " vrf_id <nn> add | pop | none") \
11047 _(trace_profile_del, "") \
11048 _(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \
11049 _(lisp_add_del_locator, "locator-set <locator_name> " \
11050 "iface <intf> | sw_if_index <sw_if_index> " \
11051 "p <priority> w <weight> [del]") \
11052 _(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \
11053 "locator-set <locator_name> [del]") \
11054 _(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \
11055 "sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \
11056 _(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \
11057 _(lisp_gpe_enable_disable, "enable|disable") \
11058 _(lisp_enable_disable, "enable|disable") \
11059 _(lisp_gpe_add_del_iface, "up|down") \
11060 _(lisp_add_del_remote_mapping, "add|del vni <vni> deid <dest-eid> seid" \
11061 " <src-eid> rloc <locator> " \
11062 "[rloc <loc> ... ]") \
11063 _(lisp_locator_set_dump, "") \
11064 _(lisp_local_eid_table_dump, "") \
11065 _(lisp_gpe_tunnel_dump, "") \
11066 _(lisp_map_resolver_dump, "") \
11067 _(lisp_enable_disable_status_dump, "") \
11068 _(af_packet_create, "name <host interface name> [hw_addr <mac>]") \
11069 _(af_packet_delete, "name <host interface name>") \
11070 _(policer_add_del, "name <policer name> <params> [del]") \
11071 _(policer_dump, "[name <policer name>]") \
11072 _(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
11073 "[master|slave]") \
11074 _(netmap_delete, "name <interface name>")
11076 /* List of command functions, CLI names map directly to functions */
11077 #define foreach_cli_function \
11078 _(comment, "usage: comment <ignore-rest-of-line>") \
11079 _(dump_interface_table, "usage: dump_interface_table") \
11080 _(dump_sub_interface_table, "usage: dump_sub_interface_table") \
11081 _(dump_ipv4_table, "usage: dump_ipv4_table") \
11082 _(dump_ipv6_table, "usage: dump_ipv6_table") \
11083 _(dump_stats_table, "usage: dump_stats_table") \
11084 _(dump_macro_table, "usage: dump_macro_table ") \
11085 _(dump_node_table, "usage: dump_node_table") \
11086 _(echo, "usage: echo <message>") \
11087 _(exec, "usage: exec <vpe-debug-CLI-command>") \
11088 _(help, "usage: help") \
11089 _(q, "usage: quit") \
11090 _(quit, "usage: quit") \
11091 _(search_node_table, "usage: search_node_table <name>...") \
11092 _(set, "usage: set <variable-name> <value>") \
11093 _(script, "usage: script <file-name>") \
11094 _(unset, "usage: unset <variable-name>")
11097 static void vl_api_##n##_t_handler_uni \
11098 (vl_api_##n##_t * mp) \
11100 vat_main_t * vam = &vat_main; \
11101 if (vam->json_output) { \
11102 vl_api_##n##_t_handler_json(mp); \
11104 vl_api_##n##_t_handler(mp); \
11107 foreach_vpe_api_reply_msg;
11110 void vat_api_hookup (vat_main_t *vam)
11113 vl_msg_api_set_handlers(VL_API_##N, #n, \
11114 vl_api_##n##_t_handler_uni, \
11116 vl_api_##n##_t_endian, \
11117 vl_api_##n##_t_print, \
11118 sizeof(vl_api_##n##_t), 1);
11119 foreach_vpe_api_reply_msg;
11122 vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE);
11124 vam->sw_if_index_by_interface_name =
11125 hash_create_string (0, sizeof (uword));
11127 vam->function_by_name =
11128 hash_create_string (0, sizeof(uword));
11130 vam->help_by_name =
11131 hash_create_string (0, sizeof(uword));
11133 /* API messages we can send */
11134 #define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n);
11135 foreach_vpe_api_msg;
11139 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
11140 foreach_vpe_api_msg;
11143 /* CLI functions */
11144 #define _(n,h) hash_set_mem (vam->function_by_name, #n, n);
11145 foreach_cli_function;
11149 #define _(n,h) hash_set_mem (vam->help_by_name, #n, h);
11150 foreach_cli_function;
11154 #undef vl_api_version
11155 #define vl_api_version(n,v) static u32 vpe_api_version = v;
11156 #include <api/vpe.api.h>
11157 #undef vl_api_version
11159 void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
11162 * Send the main API signature in slot 0. This bit of code must
11163 * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
11165 mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);