*------------------------------------------------------------------
* api_format.c
*
- * Copyright (c) 2014-2016 Cisco and/or its affiliates.
+ * Copyright (c) 2014-2020 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
#include <vnet/mpls/mpls.h>
#include <vnet/ipsec/ipsec.h>
#include <inttypes.h>
-#include <vnet/cop/cop.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/ip/ip_source_and_port_range_check.h>
#include <vnet/policer/xlate.h>
vat_socket_connect (vat_main_t * vam)
{
int rv;
+ api_main_t *am = vlibapi_get_main ();
vam->socket_client_main = &socket_client_main;
if ((rv = vl_socket_client_connect ((char *) vam->socket_name,
"vpp_api_test",
0 /* default socket rx, tx buffer */ )))
return rv;
+
/* vpp expects the client index in network order */
vam->my_client_index = htonl (socket_client_main.client_index);
+ am->my_client_index = vam->my_client_index;
return 0;
}
#else /* vpp built-in case, we don't do sockets... */
return 0;
}
+/* Parse an IP46 address. */
+uword
+unformat_ip46_address (unformat_input_t * input, va_list * args)
+{
+ ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
+ ip46_type_t type = va_arg (*args, ip46_type_t);
+ if ((type != IP46_TYPE_IP6) &&
+ unformat (input, "%U", unformat_ip4_address, &ip46->ip4))
+ {
+ ip46_address_mask_ip4 (ip46);
+ return 1;
+ }
+ else if ((type != IP46_TYPE_IP4) &&
+ unformat (input, "%U", unformat_ip6_address, &ip46->ip6))
+ {
+ return 1;
+ }
+ return 0;
+}
+
/* Parse an IP6 address. */
uword
unformat_ip6_address (unformat_input_t * input, va_list * args)
static void
increment_address (vl_api_address_t * a)
{
- if (clib_net_to_host_u32 (a->af) == ADDRESS_IP4)
+ if (a->af == ADDRESS_IP4)
increment_v4_address (&a->un.ip4);
- else if (clib_net_to_host_u32 (a->af) == ADDRESS_IP6)
+ else if (a->af == ADDRESS_IP6)
increment_v6_address (&a->un.ip6);
}
}
}
+void
+ip_set (ip46_address_t * dst, void *src, u8 is_ip4)
+{
+ if (is_ip4)
+ dst->ip4.as_u32 = ((ip4_address_t *) src)->as_u32;
+ else
+ clib_memcpy_fast (&dst->ip6, (ip6_address_t *) src,
+ sizeof (ip6_address_t));
+}
+
static void
increment_mac_address (u8 * mac)
{
{
vat_main_t *vam = &vat_main;
i32 retval = ntohl (mp->retval);
- u32 length = vl_api_string_len (&mp->reply);
vec_reset_length (vam->cmd_reply);
vam->retval = retval;
if (retval == 0)
- {
- vec_validate (vam->cmd_reply, length);
- clib_memcpy ((char *) (vam->cmd_reply),
- vl_api_from_api_string (&mp->reply), length);
- vam->cmd_reply[length] = 0;
- }
+ vam->cmd_reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
vam->result_ready = 1;
}
{
vat_main_t *vam = &vat_main;
vat_json_node_t node;
+ u8 *reply = 0; /* reply vector */
+ reply = vl_api_from_api_to_new_vec (mp, &mp->reply);
vec_reset_length (vam->cmd_reply);
vat_json_init_object (&node);
vat_json_object_add_int (&node, "retval", ntohl (mp->retval));
- vat_json_object_add_string_copy (&node, "reply",
- vl_api_from_api_string (&mp->reply));
+ vat_json_object_add_string_copy (&node, "reply", reply);
vat_json_print (vam->ofp, &node);
vat_json_free (&node);
+ vec_free (reply);
vam->retval = ntohl (mp->retval);
vam->result_ready = 1;
}
static void
-vl_api_bond_enslave_reply_t_handler (vl_api_bond_enslave_reply_t * mp)
+vl_api_bond_add_member_reply_t_handler (vl_api_bond_add_member_reply_t * mp)
{
vat_main_t *vam = &vat_main;
i32 retval = ntohl (mp->retval);
}
}
-static void vl_api_bond_enslave_reply_t_handler_json
- (vl_api_bond_enslave_reply_t * mp)
+static void vl_api_bond_add_member_reply_t_handler_json
+ (vl_api_bond_add_member_reply_t * mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t node;
}
static void
-vl_api_bond_detach_slave_reply_t_handler (vl_api_bond_detach_slave_reply_t *
- mp)
+vl_api_bond_detach_member_reply_t_handler (vl_api_bond_detach_member_reply_t *
+ mp)
{
vat_main_t *vam = &vat_main;
i32 retval = ntohl (mp->retval);
}
}
-static void vl_api_bond_detach_slave_reply_t_handler_json
- (vl_api_bond_detach_slave_reply_t * mp)
+static void vl_api_bond_detach_member_reply_t_handler_json
+ (vl_api_bond_detach_member_reply_t * mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t node;
return ret;
}
-static void vl_api_sw_interface_bond_details_t_handler
- (vl_api_sw_interface_bond_details_t * mp)
+static void vl_api_sw_bond_interface_details_t_handler
+ (vl_api_sw_bond_interface_details_t * mp)
{
vat_main_t *vam = &vat_main;
"%-16s %-12d %-12U %-13U %-14u %-14u",
mp->interface_name, ntohl (mp->sw_if_index),
format_bond_mode, ntohl (mp->mode), format_bond_load_balance,
- ntohl (mp->lb), ntohl (mp->active_slaves), ntohl (mp->slaves));
+ ntohl (mp->lb), ntohl (mp->active_members), ntohl (mp->members));
}
-static void vl_api_sw_interface_bond_details_t_handler_json
- (vl_api_sw_interface_bond_details_t * mp)
+static void vl_api_sw_bond_interface_details_t_handler_json
+ (vl_api_sw_bond_interface_details_t * mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t *node = NULL;
mp->interface_name);
vat_json_object_add_uint (node, "mode", ntohl (mp->mode));
vat_json_object_add_uint (node, "load_balance", ntohl (mp->lb));
- vat_json_object_add_uint (node, "active_slaves", ntohl (mp->active_slaves));
- vat_json_object_add_uint (node, "slaves", ntohl (mp->slaves));
+ vat_json_object_add_uint (node, "active_members",
+ ntohl (mp->active_members));
+ vat_json_object_add_uint (node, "members", ntohl (mp->members));
}
static int
-api_sw_interface_bond_dump (vat_main_t * vam)
+api_sw_bond_interface_dump (vat_main_t * vam)
{
- vl_api_sw_interface_bond_dump_t *mp;
+ unformat_input_t *i = vam->input;
+ vl_api_sw_bond_interface_dump_t *mp;
vl_api_control_ping_t *mp_ping;
int ret;
+ u32 sw_if_index = ~0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
+ ;
+ else if (unformat (i, "sw_if_index %d", &sw_if_index))
+ ;
+ else
+ break;
+ }
print (vam->ofp,
"\n%-16s %-12s %-12s %-13s %-14s %-14s",
"interface name", "sw_if_index", "mode", "load balance",
- "active slaves", "slaves");
+ "active members", "members");
/* Get list of bond interfaces */
- M (SW_INTERFACE_BOND_DUMP, mp);
+ M (SW_BOND_INTERFACE_DUMP, mp);
+ mp->sw_if_index = ntohl (sw_if_index);
S (mp);
/* Use a control ping for synchronization */
return ret;
}
-static void vl_api_sw_interface_slave_details_t_handler
- (vl_api_sw_interface_slave_details_t * mp)
+static void vl_api_sw_member_interface_details_t_handler
+ (vl_api_sw_member_interface_details_t * mp)
{
vat_main_t *vam = &vat_main;
ntohl (mp->weight), mp->is_local_numa);
}
-static void vl_api_sw_interface_slave_details_t_handler_json
- (vl_api_sw_interface_slave_details_t * mp)
+static void vl_api_sw_member_interface_details_t_handler_json
+ (vl_api_sw_member_interface_details_t * mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t *node = NULL;
}
static int
-api_sw_interface_slave_dump (vat_main_t * vam)
+api_sw_member_interface_dump (vat_main_t * vam)
{
unformat_input_t *i = vam->input;
- vl_api_sw_interface_slave_dump_t *mp;
+ vl_api_sw_member_interface_dump_t *mp;
vl_api_control_ping_t *mp_ping;
u32 sw_if_index = ~0;
u8 sw_if_index_set = 0;
print (vam->ofp,
"\n%-25s %-12s %-7s %-12s %-10s %-10s",
- "slave interface name", "sw_if_index", "passive", "long_timeout",
+ "member interface name", "sw_if_index", "passive", "long_timeout",
"weight", "local numa");
/* Get list of bond interfaces */
- M (SW_INTERFACE_SLAVE_DUMP, mp);
+ M (SW_MEMBER_INTERFACE_DUMP, mp);
mp->sw_if_index = ntohl (sw_if_index);
S (mp);
else
{
s = format (s, "%=16U%=16d%=16d",
- mp->is_ipv6 ? format_ip6_address :
- format_ip4_address,
+ format_ip46_address,
mp->ip_address, mp->priority, mp->weight);
}
clib_net_to_host_u32 (mp->sw_if_index));
else
{
- if (mp->is_ipv6)
+ if (mp->ip_address.af)
{
- clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "address", ip6);
}
else
{
- clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "address", ip4);
}
}
return unformat (input, "SPI:%d SI:%d", &nsh->spi, &nsh->si);
}
-u8 *
+static u8 *
format_nsh_address_vat (u8 * s, va_list * args)
{
nsh_t *a = va_arg (*args, nsh_t *);
static u8 *
format_lisp_flat_eid (u8 * s, va_list * args)
{
- u32 type = va_arg (*args, u32);
- u8 *eid = va_arg (*args, u8 *);
- u32 eid_len = va_arg (*args, u32);
+ vl_api_eid_t *eid = va_arg (*args, vl_api_eid_t *);
- switch (type)
+ switch (eid->type)
{
- case 0:
- return format (s, "%U/%d", format_ip4_address, eid, eid_len);
- case 1:
- return format (s, "%U/%d", format_ip6_address, eid, eid_len);
- case 2:
- return format (s, "%U", format_ethernet_address, eid);
- case 3:
- return format (s, "%U", format_nsh_address_vat, eid);
+ case EID_TYPE_API_PREFIX:
+ if (eid->address.prefix.address.af)
+ return format (s, "%U/%d", format_ip6_address,
+ eid->address.prefix.address.un.ip6,
+ eid->address.prefix.len);
+ return format (s, "%U/%d", format_ip4_address,
+ eid->address.prefix.address.un.ip4,
+ eid->address.prefix.len);
+ case EID_TYPE_API_MAC:
+ return format (s, "%U", format_ethernet_address, eid->address.mac);
+ case EID_TYPE_API_NSH:
+ return format (s, "%U", format_nsh_address_vat, eid->address.nsh);
}
return 0;
}
static u8 *
format_lisp_eid_vat (u8 * s, va_list * args)
{
- u32 type = va_arg (*args, u32);
- u8 *eid = va_arg (*args, u8 *);
- u32 eid_len = va_arg (*args, u32);
- u8 *seid = va_arg (*args, u8 *);
- u32 seid_len = va_arg (*args, u32);
- u32 is_src_dst = va_arg (*args, u32);
+ vl_api_eid_t *deid = va_arg (*args, vl_api_eid_t *);
+ vl_api_eid_t *seid = va_arg (*args, vl_api_eid_t *);
+ u8 is_src_dst = (u8) va_arg (*args, int);
if (is_src_dst)
- s = format (s, "%U|", format_lisp_flat_eid, type, seid, seid_len);
+ s = format (s, "%U|", format_lisp_flat_eid, seid);
- s = format (s, "%U", format_lisp_flat_eid, type, eid, eid_len);
+ s = format (s, "%U", format_lisp_flat_eid, deid);
return s;
}
s = format (0, "%d", clib_net_to_host_u32 (mp->locator_set_index));
eid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type,
- mp->eid,
- mp->eid_prefix_len,
- mp->seid, mp->seid_prefix_len, mp->is_src_dst);
+ &mp->deid, &mp->seid, mp->is_src_dst);
vec_add1 (eid, 0);
print (vam->ofp, "[%d] %-35s%-20s%-30s%-20d%-20d%-10d%-20s",
eid,
mp->is_local ? "local" : "remote",
s, clib_net_to_host_u32 (mp->ttl), mp->authoritative,
- clib_net_to_host_u16 (mp->key_id), mp->key);
+ clib_net_to_host_u16 (mp->key.id), mp->key.key);
vec_free (s);
vec_free (eid);
clib_net_to_host_u32 (mp->locator_set_index));
vat_json_object_add_uint (node, "is_local", mp->is_local ? 1 : 0);
- if (mp->eid_type == 3)
+ if (mp->deid.type == 3)
{
vat_json_node_t *nsh_json = vat_json_object_add (node, "eid");
vat_json_init_object (nsh_json);
- lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) mp->eid;
+ lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) & mp->deid.address.nsh;
vat_json_object_add_uint (nsh_json, "spi",
clib_net_to_host_u32 (nsh->spi));
vat_json_object_add_uint (nsh_json, "si", nsh->si);
else
{
eid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type,
- mp->eid,
- mp->eid_prefix_len,
- mp->seid, mp->seid_prefix_len, mp->is_src_dst);
+ &mp->deid, &mp->seid, mp->is_src_dst);
vec_add1 (eid, 0);
vat_json_object_add_string_copy (node, "eid", eid);
vec_free (eid);
vat_json_object_add_uint (node, "ttl", clib_net_to_host_u32 (mp->ttl));
vat_json_object_add_uint (node, "authoritative", (mp->authoritative));
- if (mp->key_id)
+ if (mp->key.id)
{
vat_json_object_add_uint (node, "key_id",
- clib_net_to_host_u16 (mp->key_id));
- vat_json_object_add_string_copy (node, "key", mp->key);
+ clib_net_to_host_u16 (mp->key.id));
+ vat_json_object_add_string_copy (node, "key", mp->key.key);
}
}
{
vat_main_t *vam = &vat_main;
u8 *seid = 0, *deid = 0;
- u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
+ ip46_address_t lloc, rloc;
- deid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
+ deid = format (0, "%U", format_lisp_eid_vat, &mp->deid, 0, 0);
- seid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
+ seid = format (0, "%U", format_lisp_eid_vat, &mp->seid, 0, 0);
vec_add1 (deid, 0);
vec_add1 (seid, 0);
- if (mp->is_ip4)
- format_ip_address_fcn = format_ip4_address;
+ if (mp->lloc.af)
+ {
+ clib_memcpy (&lloc.ip6, mp->lloc.un.ip6, 16);
+ clib_memcpy (&rloc.ip6, mp->rloc.un.ip6, 16);
+ }
else
- format_ip_address_fcn = format_ip6_address;
+ {
+ clib_memcpy (&lloc.ip4, mp->lloc.un.ip4, 4);
+ clib_memcpy (&rloc.ip4, mp->rloc.un.ip4, 4);
+ }
print (vam->ofp, "([%d] %s %s) (%U %U) %u %u",
clib_net_to_host_u32 (mp->vni),
seid, deid,
- format_ip_address_fcn, mp->lloc,
- format_ip_address_fcn, mp->rloc,
+ format_ip46_address, lloc,
+ format_ip46_address, rloc,
clib_net_to_host_u32 (mp->pkt_count),
clib_net_to_host_u32 (mp->bytes));
node = vat_json_array_add (&vam->json_tree);
vat_json_init_object (node);
- deid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type, mp->deid, mp->deid_pref_len, 0, 0, 0);
+ deid = format (0, "%U", format_lisp_eid_vat, &mp->deid, 0, 0);
- seid = format (0, "%U", format_lisp_eid_vat,
- mp->eid_type, mp->seid, mp->seid_pref_len, 0, 0, 0);
+ seid = format (0, "%U", format_lisp_eid_vat, &mp->seid, 0, 0);
vec_add1 (deid, 0);
vec_add1 (seid, 0);
vat_json_object_add_string_copy (node, "deid", deid);
vat_json_object_add_uint (node, "vni", clib_net_to_host_u32 (mp->vni));
- if (mp->is_ip4)
+ if (mp->lloc.af)
{
- clib_memcpy (&ip4, mp->lloc, sizeof (ip4));
- vat_json_object_add_ip4 (node, "lloc", ip4);
- clib_memcpy (&ip4, mp->rloc, sizeof (ip4));
- vat_json_object_add_ip4 (node, "rloc", ip4);
+ clib_memcpy (&ip6, mp->lloc.un.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (node, "lloc", ip6);
+ clib_memcpy (&ip6, mp->rloc.un.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (node, "rloc", ip6);
+
}
else
{
- clib_memcpy (&ip6, mp->lloc, sizeof (ip6));
- vat_json_object_add_ip6 (node, "lloc", ip6);
- clib_memcpy (&ip6, mp->rloc, sizeof (ip6));
- vat_json_object_add_ip6 (node, "rloc", ip6);
+ clib_memcpy (&ip4, mp->lloc.un.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (node, "lloc", ip4);
+ clib_memcpy (&ip4, mp->rloc.un.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (node, "rloc", ip4);
}
vat_json_object_add_uint (node, "pkt_count",
clib_net_to_host_u32 (mp->pkt_count));
vat_main_t *vam = &vat_main;
int retval = clib_net_to_host_u32 (mp->retval);
- print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
+ print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
vam->retval = retval;
vam->result_ready = 1;
vat_json_node_t _node, *node = &_node;
int retval = clib_net_to_host_u32 (mp->retval);
- u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
+ u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vat_json_init_object (node);
vat_json_object_add_string_copy (node, "state", s);
if (retval)
goto end;
- print (vam->ofp, "%s", mp->is_enabled ? "enabled" : "disabled");
+ print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
end:
vam->retval = retval;
vam->result_ready = 1;
vat_json_node_t _node, *node = &_node;
int retval = clib_net_to_host_u32 (mp->retval);
- u8 *s = format (0, "%s", mp->is_enabled ? "enabled" : "disabled");
+ u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vat_json_init_object (node);
vat_json_object_add_string_copy (node, "state", s);
if (retval)
goto end;
- print (vam->ofp, "%s", mp->is_en ? "enabled" : "disabled");
+ print (vam->ofp, "%s", mp->is_enable ? "enabled" : "disabled");
end:
vam->retval = retval;
vam->result_ready = 1;
vat_json_node_t _node, *node = &_node;
int retval = clib_net_to_host_u32 (mp->retval);
- u8 *s = format (0, "%s", mp->is_en ? "enabled" : "disabled");
+ u8 *s = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vat_json_init_object (node);
vat_json_object_add_string_copy (node, "state", s);
vat_main_t *vam = &vat_main;
u8 *(*format_ip_address_fcn) (u8 *, va_list *) = 0;
- if (mp->lcl_loc.is_ip4)
- format_ip_address_fcn = format_ip4_address;
- else
+ if (mp->lcl_loc.addr.af)
format_ip_address_fcn = format_ip6_address;
+ else
+ format_ip_address_fcn = format_ip4_address;
print (vam->ofp, "w:%d %30U %30U", mp->rmt_loc.weight,
- format_ip_address_fcn, &mp->lcl_loc,
- format_ip_address_fcn, &mp->rmt_loc);
+ format_ip_address_fcn, &mp->lcl_loc.addr.un,
+ format_ip_address_fcn, &mp->rmt_loc.addr.un);
}
static void
struct in6_addr ip6;
struct in_addr ip4;
- if (loc->is_ip4)
+ if (loc->addr.af)
{
- clib_memcpy (&ip4, loc->addr, sizeof (ip4));
- vat_json_object_add_ip4 (n, "address", ip4);
+ clib_memcpy (&ip6, loc->addr.un.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (n, "address", ip6);
}
else
{
- clib_memcpy (&ip6, loc->addr, sizeof (ip6));
- vat_json_object_add_ip6 (n, "address", ip6);
+ clib_memcpy (&ip4, loc->addr.un.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (n, "address", ip4);
}
vat_json_object_add_uint (n, "weight", loc->weight);
}
{
e = &mp->entries[i];
print (vam->ofp, "%10d %10d %U %40U", e->fwd_entry_index, e->dp_table,
- format_lisp_flat_eid, e->eid_type, e->leid, e->leid_prefix_len,
- format_lisp_flat_eid, e->eid_type, e->reid, e->reid_prefix_len);
+ format_lisp_flat_eid, e->leid, format_lisp_flat_eid, e->reid);
}
end:
vat_json_object_add_int (e, "vni", fwd->vni);
vat_json_object_add_int (e, "action", fwd->action);
- s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->leid,
- fwd->leid_prefix_len);
+ s = format (0, "%U", format_lisp_flat_eid, fwd->leid);
vec_add1 (s, 0);
vat_json_object_add_string_copy (e, "leid", s);
vec_free (s);
- s = format (0, "%U", format_lisp_flat_eid, fwd->eid_type, fwd->reid,
- fwd->reid_prefix_len);
+ s = format (0, "%U", format_lisp_flat_eid, fwd->reid);
vec_add1 (s, 0);
vat_json_object_add_string_copy (e, "reid", s);
vec_free (s);
print (vam->ofp, "fib_index: %d sw_if_index %d nh %U",
clib_net_to_host_u32 (r->fib_index),
clib_net_to_host_u32 (r->nh_sw_if_index),
- r->is_ip4 ? format_ip4_address : format_ip6_address, r->nh_addr);
+ r->nh_addr.af ? format_ip6_address : format_ip4_address,
+ r->nh_addr.un);
}
end:
vat_json_init_object (e);
r = &mp->entries[i];
s =
- format (0, "%U", r->is_ip4 ? format_ip4_address : format_ip6_address,
- r->nh_addr);
+ format (0, "%U",
+ r->nh_addr.af ? format_ip6_address : format_ip4_address,
+ r->nh_addr.un);
vec_add1 (s, 0);
vat_json_object_add_string_copy (e, "ip4", s);
vec_free (s);
{
a = &mp->adjacencies[i];
print (vam->ofp, "%U %40U",
- format_lisp_flat_eid, a->eid_type, a->leid, a->leid_prefix_len,
- format_lisp_flat_eid, a->eid_type, a->reid, a->reid_prefix_len);
+ format_lisp_flat_eid, a->leid, format_lisp_flat_eid, a->reid);
}
end:
a = &mp->adjacencies[i];
vat_json_init_object (e);
- s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->leid,
- a->leid_prefix_len);
+ s = format (0, "%U", format_lisp_flat_eid, a->leid);
vec_add1 (s, 0);
vat_json_object_add_string_copy (e, "leid", s);
vec_free (s);
- s = format (0, "%U", format_lisp_flat_eid, a->eid_type, a->reid,
- a->reid_prefix_len);
+ s = format (0, "%U", format_lisp_flat_eid, a->reid);
vec_add1 (s, 0);
vat_json_object_add_string_copy (e, "reid", s);
vec_free (s);
vat_main_t *vam = &vat_main;
print (vam->ofp, "%=20U",
- mp->is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->ip_address);
+ mp->ip_address.af ? format_ip6_address : format_ip4_address,
+ mp->ip_address.un);
}
static void
node = vat_json_array_add (&vam->json_tree);
vat_json_init_object (node);
- if (mp->is_ipv6)
+ if (mp->ip_address.af)
{
- clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "map-server", ip6);
}
else
{
- clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "map-server", ip4);
}
}
vat_main_t *vam = &vat_main;
print (vam->ofp, "%=20U",
- mp->is_ipv6 ? format_ip6_address : format_ip4_address,
- mp->ip_address);
+ mp->ip_address.af ? format_ip6_address : format_ip4_address,
+ mp->ip_address.un);
}
static void
node = vat_json_array_add (&vam->json_tree);
vat_json_init_object (node);
- if (mp->is_ipv6)
+ if (mp->ip_address.af)
{
- clib_memcpy (&ip6, mp->ip_address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "map resolver", ip6);
}
else
{
- clib_memcpy (&ip4, mp->ip_address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "map resolver", ip4);
}
}
if (0 <= retval)
{
- print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
+ print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
}
vam->retval = retval;
vat_json_node_t node;
u8 *status = 0;
- status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
+ status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vec_add1 (status, 0);
vat_json_init_object (&node);
if (0 <= retval)
{
- print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
+ print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
}
vam->retval = retval;
vat_json_node_t node;
u8 *status = 0;
- status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
+ status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vec_add1 (status, 0);
vat_json_init_object (&node);
if (0 <= retval)
{
- print (vam->ofp, "%s\n", mp->is_en ? "enabled" : "disabled");
+ print (vam->ofp, "%s\n", mp->is_enable ? "enabled" : "disabled");
}
vam->retval = retval;
vat_json_node_t node;
u8 *status = 0;
- status = format (0, "%s", mp->is_en ? "enabled" : "disabled");
+ status = format (0, "%s", mp->is_enable ? "enabled" : "disabled");
vec_add1 (status, 0);
vat_json_init_object (&node);
if (mp->status)
{
print (vam->ofp, "Proxy-ETR address; %U",
- mp->is_ip4 ? format_ip4_address : format_ip6_address,
- mp->address);
+ mp->ip_address.af ? format_ip6_address : format_ip4_address,
+ mp->ip_address.un);
}
}
vat_json_object_add_string_copy (&node, "status", status);
if (mp->status)
{
- if (mp->is_ip4)
+ if (mp->ip_address.af)
{
- clib_memcpy (&ip6, mp->address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->ip_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (&node, "address", ip6);
}
else
{
- clib_memcpy (&ip4, mp->address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->ip_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (&node, "address", ip4);
}
}
vat_main_t *vam = &vat_main;
u8 *conform_dscp_str, *exceed_dscp_str, *violate_dscp_str;
- if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
- conform_dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
+ if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
+ conform_dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
else
conform_dscp_str = format (0, "");
- if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
- exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
+ if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
+ exceed_dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
else
exceed_dscp_str = format (0, "");
- if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
- violate_dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
+ if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
+ violate_dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
else
violate_dscp_str = format (0, "");
ntohl (mp->extended_limit),
ntohl (mp->extended_bucket),
clib_net_to_host_u64 (mp->last_update_time),
- format_policer_action_type, mp->conform_action_type,
+ format_policer_action_type, mp->conform_action.type,
conform_dscp_str,
- format_policer_action_type, mp->exceed_action_type,
+ format_policer_action_type, mp->exceed_action.type,
exceed_dscp_str,
- format_policer_action_type, mp->violate_action_type,
+ format_policer_action_type, mp->violate_action.type,
violate_dscp_str);
vec_free (conform_dscp_str);
format (0, "%U", format_policer_round_type, mp->round_type);
type_str = format (0, "%U", format_policer_type, mp->type);
conform_action_str = format (0, "%U", format_policer_action_type,
- mp->conform_action_type);
+ mp->conform_action.type);
exceed_action_str = format (0, "%U", format_policer_action_type,
- mp->exceed_action_type);
+ mp->exceed_action.type);
violate_action_str = format (0, "%U", format_policer_action_type,
- mp->violate_action_type);
+ mp->violate_action.type);
if (VAT_JSON_ARRAY != vam->json_tree.type)
{
ntohl (mp->last_update_time));
vat_json_object_add_string_copy (node, "conform_action",
conform_action_str);
- if (mp->conform_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ if (mp->conform_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
{
- u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_dscp);
+ u8 *dscp_str = format (0, "%U", format_dscp, mp->conform_action.dscp);
vat_json_object_add_string_copy (node, "conform_dscp", dscp_str);
vec_free (dscp_str);
}
vat_json_object_add_string_copy (node, "exceed_action", exceed_action_str);
- if (mp->exceed_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ if (mp->exceed_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
{
- u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_dscp);
+ u8 *dscp_str = format (0, "%U", format_dscp, mp->exceed_action.dscp);
vat_json_object_add_string_copy (node, "exceed_dscp", dscp_str);
vec_free (dscp_str);
}
vat_json_object_add_string_copy (node, "violate_action",
violate_action_str);
- if (mp->violate_action_type == SSE2_QOS_ACTION_MARK_AND_TRANSMIT)
+ if (mp->violate_action.type == SSE2_QOS_ACTION_API_MARK_AND_TRANSMIT)
{
- u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_dscp);
+ u8 *dscp_str = format (0, "%U", format_dscp, mp->violate_action.dscp);
vat_json_object_add_string_copy (node, "violate_dscp", dscp_str);
vec_free (dscp_str);
}
_(gpe_add_del_native_fwd_rpath_reply) \
_(af_packet_delete_reply) \
_(policer_classify_set_interface_reply) \
-_(netmap_create_reply) \
-_(netmap_delete_reply) \
_(set_ipfix_exporter_reply) \
_(set_ipfix_classify_stream_reply) \
_(ipfix_classify_table_add_del_reply) \
_(sw_interface_span_enable_disable_reply) \
_(pg_capture_reply) \
_(pg_enable_disable_reply) \
+_(pg_interface_enable_disable_coalesce_reply) \
_(ip_source_and_port_range_check_add_del_reply) \
_(ip_source_and_port_range_check_interface_add_del_reply)\
_(delete_subif_reply) \
_(session_rule_add_del_reply) \
_(ip_container_proxy_add_del_reply) \
_(output_acl_set_interface_reply) \
-_(qos_record_enable_disable_reply)
+_(qos_record_enable_disable_reply) \
+_(flow_add_reply)
#define _(n) \
static void vl_api_##n##_t_handler \
_(SW_INTERFACE_VIRTIO_PCI_DETAILS, sw_interface_virtio_pci_details) \
_(BOND_CREATE_REPLY, bond_create_reply) \
_(BOND_DELETE_REPLY, bond_delete_reply) \
-_(BOND_ENSLAVE_REPLY, bond_enslave_reply) \
-_(BOND_DETACH_SLAVE_REPLY, bond_detach_slave_reply) \
+_(BOND_ADD_MEMBER_REPLY, bond_add_member_reply) \
+_(BOND_DETACH_MEMBER_REPLY, bond_detach_member_reply) \
_(SW_INTERFACE_SET_BOND_WEIGHT_REPLY, sw_interface_set_bond_weight_reply) \
-_(SW_INTERFACE_BOND_DETAILS, sw_interface_bond_details) \
-_(SW_INTERFACE_SLAVE_DETAILS, sw_interface_slave_details) \
+_(SW_BOND_INTERFACE_DETAILS, sw_bond_interface_details) \
+_(SW_MEMBER_INTERFACE_DETAILS, sw_member_interface_details) \
_(IP_ROUTE_ADD_DEL_REPLY, ip_route_add_del_reply) \
_(IP_TABLE_ADD_DEL_REPLY, ip_table_add_del_reply) \
_(IP_TABLE_REPLACE_BEGIN_REPLY, ip_table_replace_begin_reply) \
_(POLICER_DETAILS, policer_details) \
_(POLICER_CLASSIFY_SET_INTERFACE_REPLY, policer_classify_set_interface_reply) \
_(POLICER_CLASSIFY_DETAILS, policer_classify_details) \
-_(NETMAP_CREATE_REPLY, netmap_create_reply) \
-_(NETMAP_DELETE_REPLY, netmap_delete_reply) \
_(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
_(MPLS_TABLE_DETAILS, mpls_table_details) \
_(MPLS_ROUTE_DETAILS, mpls_route_details) \
_(PG_CREATE_INTERFACE_REPLY, pg_create_interface_reply) \
_(PG_CAPTURE_REPLY, pg_capture_reply) \
_(PG_ENABLE_DISABLE_REPLY, pg_enable_disable_reply) \
+_(PG_INTERFACE_ENABLE_DISABLE_COALESCE_REPLY, pg_interface_enable_disable_coalesce_reply) \
_(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY, \
ip_source_and_port_range_check_add_del_reply) \
_(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY, \
_(SESSION_RULES_DETAILS, session_rules_details) \
_(IP_CONTAINER_PROXY_ADD_DEL_REPLY, ip_container_proxy_add_del_reply) \
_(OUTPUT_ACL_SET_INTERFACE_REPLY, output_acl_set_interface_reply) \
-_(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply)
+_(QOS_RECORD_ENABLE_DISABLE_REPLY, qos_record_enable_disable_reply) \
+_(FLOW_ADD_REPLY, flow_add_reply) \
#define foreach_standalone_reply_msg \
_(SW_INTERFACE_EVENT, sw_interface_event)
* must be a vector ending in \n, not a C-string ending
* in \n\0.
*/
- u32 len = vec_len (vam->input->buffer);
- M2 (CLI_INBAND, mp, len);
- vl_api_to_api_string (len - 1, (const char *) vam->input->buffer, &mp->cmd);
+ M2 (CLI_INBAND, mp, vec_len (vam->input->buffer));
+ vl_api_vec_to_api_string (vam->input->buffer, &mp->cmd);
S (mp);
W (ret);
{
unformat_input_t *i = vam->input;
vl_api_tap_create_v2_t *mp;
-#define TAP_FLAG_GSO (1 << 0)
u8 mac_address[6];
u8 random_mac = 1;
u32 id = ~0;
+ u32 num_rx_queues = 0;
u8 *host_if_name = 0;
+ u8 host_if_name_set = 0;
u8 *host_ns = 0;
+ u8 host_ns_set = 0;
u8 host_mac_addr[6];
u8 host_mac_addr_set = 0;
u8 *host_bridge = 0;
+ u8 host_bridge_set = 0;
+ u8 host_ip4_prefix_set = 0;
+ u8 host_ip6_prefix_set = 0;
ip4_address_t host_ip4_addr;
ip4_address_t host_ip4_gw;
u8 host_ip4_gw_set = 0;
ip6_address_t host_ip6_gw;
u8 host_ip6_gw_set = 0;
u32 host_ip6_prefix_len = 0;
- u8 host_mtu_set = 0;
u32 host_mtu_size = 0;
+ u8 host_mtu_set = 0;
u32 tap_flags = 0;
int ret;
u32 rx_ring_sz = 0, tx_ring_sz = 0;
/* Parse args required to build the message */
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (i, "hw-addr %U", unformat_ethernet_address, mac_address))
- {
- random_mac = 0;
- }
- else if (unformat (i, "id %u", &id))
+ if (unformat (i, "id %u", &id))
;
+ else
+ if (unformat
+ (i, "hw-addr %U", unformat_ethernet_address, mac_address))
+ random_mac = 0;
else if (unformat (i, "host-if-name %s", &host_if_name))
+ host_if_name_set = 1;
+ else if (unformat (i, "num-rx-queues %u", &num_rx_queues))
;
else if (unformat (i, "host-ns %s", &host_ns))
- ;
+ host_ns_set = 1;
else if (unformat (i, "host-mac-addr %U", unformat_ethernet_address,
host_mac_addr))
host_mac_addr_set = 1;
else if (unformat (i, "host-bridge %s", &host_bridge))
- ;
- else if (unformat (i, "host-ip4-addr %U/%d", unformat_ip4_address,
+ host_bridge_set = 1;
+ else if (unformat (i, "host-ip4-addr %U/%u", unformat_ip4_address,
&host_ip4_addr, &host_ip4_prefix_len))
- ;
- else if (unformat (i, "host-ip6-addr %U/%d", unformat_ip6_address,
+ host_ip4_prefix_set = 1;
+ else if (unformat (i, "host-ip6-addr %U/%u", unformat_ip6_address,
&host_ip6_addr, &host_ip6_prefix_len))
- ;
+ host_ip6_prefix_set = 1;
else if (unformat (i, "host-ip4-gw %U", unformat_ip4_address,
&host_ip4_gw))
host_ip4_gw_set = 1;
else if (unformat (i, "host-ip6-gw %U", unformat_ip6_address,
&host_ip6_gw))
host_ip6_gw_set = 1;
- else if (unformat (i, "rx-ring-size %d", &rx_ring_sz))
+ else if (unformat (i, "rx-ring-size %u", &rx_ring_sz))
;
- else if (unformat (i, "tx-ring-size %d", &tx_ring_sz))
+ else if (unformat (i, "tx-ring-size %u", &tx_ring_sz))
;
- else if (unformat (i, "host-mtu-size %d", &host_mtu_size))
+ else if (unformat (i, "host-mtu-size %u", &host_mtu_size))
host_mtu_set = 1;
else if (unformat (i, "no-gso"))
- tap_flags &= ~TAP_FLAG_GSO;
+ tap_flags &= ~TAP_API_FLAG_GSO;
else if (unformat (i, "gso"))
- tap_flags |= TAP_FLAG_GSO;
+ tap_flags |= TAP_API_FLAG_GSO;
+ else if (unformat (i, "csum-offload"))
+ tap_flags |= TAP_API_FLAG_CSUM_OFFLOAD;
+ else if (unformat (i, "persist"))
+ tap_flags |= TAP_API_FLAG_PERSIST;
+ else if (unformat (i, "attach"))
+ tap_flags |= TAP_API_FLAG_ATTACH;
+ else if (unformat (i, "tun"))
+ tap_flags |= TAP_API_FLAG_TUN;
+ else if (unformat (i, "gro-coalesce"))
+ tap_flags |= TAP_API_FLAG_GRO_COALESCE;
else
break;
}
/* Construct the API message */
M (TAP_CREATE_V2, mp);
- mp->use_random_mac = random_mac;
-
mp->id = ntohl (id);
- mp->host_namespace_set = host_ns != 0;
- mp->host_bridge_set = host_bridge != 0;
- mp->host_ip4_prefix_set = host_ip4_prefix_len != 0;
- mp->host_ip6_prefix_set = host_ip6_prefix_len != 0;
- mp->rx_ring_sz = ntohs (rx_ring_sz);
+ mp->use_random_mac = random_mac;
+ mp->num_rx_queues = (u8) num_rx_queues;
mp->tx_ring_sz = ntohs (tx_ring_sz);
+ mp->rx_ring_sz = ntohs (rx_ring_sz);
mp->host_mtu_set = host_mtu_set;
mp->host_mtu_size = ntohl (host_mtu_size);
+ mp->host_mac_addr_set = host_mac_addr_set;
+ mp->host_ip4_prefix_set = host_ip4_prefix_set;
+ mp->host_ip6_prefix_set = host_ip6_prefix_set;
+ mp->host_ip4_gw_set = host_ip4_gw_set;
+ mp->host_ip6_gw_set = host_ip6_gw_set;
mp->tap_flags = ntohl (tap_flags);
+ mp->host_namespace_set = host_ns_set;
+ mp->host_if_name_set = host_if_name_set;
+ mp->host_bridge_set = host_bridge_set;
if (random_mac == 0)
clib_memcpy (mp->mac_address, mac_address, 6);
if (host_mac_addr_set)
clib_memcpy (mp->host_mac_addr, host_mac_addr, 6);
- if (host_if_name)
+ if (host_if_name_set)
clib_memcpy (mp->host_if_name, host_if_name, vec_len (host_if_name));
- if (host_ns)
+ if (host_ns_set)
clib_memcpy (mp->host_namespace, host_ns, vec_len (host_ns));
- if (host_bridge)
+ if (host_bridge_set)
clib_memcpy (mp->host_bridge, host_bridge, vec_len (host_bridge));
- if (host_ip4_prefix_len)
- clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
- if (host_ip6_prefix_len)
- clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
+ if (host_ip4_prefix_set)
+ {
+ clib_memcpy (mp->host_ip4_prefix.address, &host_ip4_addr, 4);
+ mp->host_ip4_prefix.len = (u8) host_ip4_prefix_len;
+ }
+ if (host_ip6_prefix_set)
+ {
+ clib_memcpy (mp->host_ip6_prefix.address, &host_ip6_addr, 16);
+ mp->host_ip6_prefix.len = (u8) host_ip6_prefix_len;
+ }
if (host_ip4_gw_set)
clib_memcpy (mp->host_ip4_gw, &host_ip4_gw, 4);
if (host_ip6_gw_set)
u8 mac_address[6];
u8 random_mac = 1;
u8 gso_enabled = 0;
+ u8 checksum_offload_enabled = 0;
u32 pci_addr = 0;
u64 features = (u64) ~ (0ULL);
int ret;
;
else if (unformat (i, "gso-enabled"))
gso_enabled = 1;
+ else if (unformat (i, "csum-offload-enabled"))
+ checksum_offload_enabled = 1;
else
break;
}
mp->use_random_mac = random_mac;
- mp->pci_addr = htonl (pci_addr);
+ mp->pci_addr.domain = htons (((vlib_pci_addr_t) pci_addr).domain);
+ mp->pci_addr.bus = ((vlib_pci_addr_t) pci_addr).bus;
+ mp->pci_addr.slot = ((vlib_pci_addr_t) pci_addr).slot;
+ mp->pci_addr.function = ((vlib_pci_addr_t) pci_addr).function;
+
mp->features = clib_host_to_net_u64 (features);
mp->gso_enabled = gso_enabled;
+ mp->checksum_offload_enabled = checksum_offload_enabled;
if (random_mac == 0)
clib_memcpy (mp->mac_address, mac_address, 6);
}
static int
-api_bond_enslave (vat_main_t * vam)
+api_bond_add_member (vat_main_t * vam)
{
unformat_input_t *i = vam->input;
- vl_api_bond_enslave_t *mp;
+ vl_api_bond_add_member_t *mp;
u32 bond_sw_if_index;
int ret;
u8 is_passive;
}
if (sw_if_index_is_set == 0)
{
- errmsg ("Missing slave sw_if_index. ");
+ errmsg ("Missing member sw_if_index. ");
return -99;
}
/* Construct the API message */
- M (BOND_ENSLAVE, mp);
+ M (BOND_ADD_MEMBER, mp);
mp->bond_sw_if_index = ntohl (bond_sw_if_index);
mp->sw_if_index = ntohl (sw_if_index);
}
static int
-api_bond_detach_slave (vat_main_t * vam)
+api_bond_detach_member (vat_main_t * vam)
{
unformat_input_t *i = vam->input;
- vl_api_bond_detach_slave_t *mp;
+ vl_api_bond_detach_member_t *mp;
u32 sw_if_index = ~0;
u8 sw_if_index_set = 0;
int ret;
}
/* Construct the API message */
- M (BOND_DETACH_SLAVE, mp);
+ M (BOND_DETACH_MEMBER, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->bsid = htonl (bsid);
mp->weight = htonl (weight);
- mp->type = type;
+ mp->is_spray = type;
mp->n_segments = n_segments;
memcpy (mp->segments, segments, sizeof (u32) * n_segments);
vec_free (segments);
u8 behavior = ~0;
u32 sw_if_index;
u32 fib_table = ~(u32) 0;
- ip6_address_t nh_addr6;
- ip4_address_t nh_addr4;
- clib_memset (&nh_addr6, 0, sizeof (ip6_address_t));
- clib_memset (&nh_addr4, 0, sizeof (ip4_address_t));
+ ip46_address_t nh_addr;
+ clib_memset (&nh_addr, 0, sizeof (ip46_address_t));
bool nexthop_set = 0;
if (unformat (i, "del"))
is_del = 1;
else if (unformat (i, "address %U", unformat_ip6_address, &localsid));
- else if (unformat (i, "next-hop %U", unformat_ip4_address, &nh_addr4))
- nexthop_set = 1;
- else if (unformat (i, "next-hop %U", unformat_ip6_address, &nh_addr6))
+ else if (unformat (i, "next-hop %U", unformat_ip46_address, &nh_addr))
nexthop_set = 1;
else if (unformat (i, "behavior %u", &behavior));
else if (unformat (i, "sw_if_index %u", &sw_if_index));
M (SR_LOCALSID_ADD_DEL, mp);
- clib_memcpy (mp->localsid.addr, &localsid, sizeof (mp->localsid));
+ clib_memcpy (mp->localsid, &localsid, sizeof (mp->localsid));
if (nexthop_set)
{
- clib_memcpy (mp->nh_addr6, &nh_addr6, sizeof (mp->nh_addr6));
- clib_memcpy (mp->nh_addr4, &nh_addr4, sizeof (mp->nh_addr4));
+ clib_memcpy (&mp->nh_addr.un, &nh_addr, sizeof (mp->nh_addr.un));
}
mp->behavior = behavior;
mp->sw_if_index = ntohl (sw_if_index);
u32 as_u32;
} pci_addr_t;
pci_addr_t addr;
- addr.as_u32 = ntohl (mp->pci_addr);
+
+ addr.domain = ntohs (mp->pci_addr.domain);
+ addr.bus = mp->pci_addr.bus;
+ addr.slot = mp->pci_addr.slot;
+ addr.function = mp->pci_addr.function;
+
u8 *pci_addr = format (0, "%04x:%02x:%02x.%x", addr.domain, addr.bus,
addr.slot, addr.function);
{
vat_main_t *vam = &vat_main;
vat_json_node_t *node = NULL;
+ vlib_pci_addr_t pci_addr;
if (VAT_JSON_ARRAY != vam->json_tree.type)
{
}
node = vat_json_array_add (&vam->json_tree);
+ pci_addr.domain = ntohs (mp->pci_addr.domain);
+ pci_addr.bus = mp->pci_addr.bus;
+ pci_addr.slot = mp->pci_addr.slot;
+ pci_addr.function = mp->pci_addr.function;
+
vat_json_init_object (node);
- vat_json_object_add_uint (node, "pci-addr", ntohl (mp->pci_addr));
+ vat_json_object_add_uint (node, "pci-addr", pci_addr.as_u32);
vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
vat_json_object_add_uint (node, "rx_ring_sz", ntohs (mp->rx_ring_sz));
vat_json_object_add_uint (node, "tx_ring_sz", ntohs (mp->tx_ring_sz));
if (ipv6_set)
{
- clib_memcpy (mp->src_address, &src.ip6, sizeof (src.ip6));
- clib_memcpy (mp->dst_address, &dst.ip6, sizeof (dst.ip6));
+ clib_memcpy (mp->src_address.un.ip6, &src.ip6, sizeof (src.ip6));
+ clib_memcpy (mp->dst_address.un.ip6, &dst.ip6, sizeof (dst.ip6));
}
else
{
- clib_memcpy (mp->src_address, &src.ip4, sizeof (src.ip4));
- clib_memcpy (mp->dst_address, &dst.ip4, sizeof (dst.ip4));
+ clib_memcpy (mp->src_address.un.ip4, &src.ip4, sizeof (src.ip4));
+ clib_memcpy (mp->dst_address.un.ip4, &dst.ip4, sizeof (dst.ip4));
}
+ mp->src_address.af = ipv6_set;
+ mp->dst_address.af = ipv6_set;
mp->instance = htonl (instance);
mp->encap_vrf_id = ntohl (encap_vrf_id);
mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
mp->vni = ntohl (vni);
mp->is_add = is_add;
- mp->is_ipv6 = ipv6_set;
S (mp);
W (ret);
(vl_api_vxlan_tunnel_details_t * mp)
{
vat_main_t *vam = &vat_main;
- ip46_address_t src = to_ip46 (mp->is_ipv6, mp->dst_address);
- ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->src_address);
+ ip46_address_t src =
+ to_ip46 (mp->dst_address.af, (u8 *) & mp->dst_address.un);
+ ip46_address_t dst =
+ to_ip46 (mp->dst_address.af, (u8 *) & mp->src_address.un);
print (vam->ofp, "%11d%11d%24U%24U%14d%18d%13d%19d",
ntohl (mp->sw_if_index),
vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
- if (mp->is_ipv6)
+ if (mp->src_address.af)
{
struct in6_addr ip6;
- clib_memcpy (&ip6, mp->src_address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->src_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "src_address", ip6);
- clib_memcpy (&ip6, mp->dst_address, sizeof (ip6));
+ clib_memcpy (&ip6, mp->dst_address.un.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "dst_address", ip6);
}
else
{
struct in_addr ip4;
- clib_memcpy (&ip4, mp->src_address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->src_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "src_address", ip4);
- clib_memcpy (&ip4, mp->dst_address, sizeof (ip4));
+ clib_memcpy (&ip4, mp->dst_address.un.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "dst_address", ip4);
}
vat_json_object_add_uint (node, "encap_vrf_id", ntohl (mp->encap_vrf_id));
vat_json_object_add_uint (node, "decap_next_index",
ntohl (mp->decap_next_index));
vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
- vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6 ? 1 : 0);
vat_json_object_add_uint (node, "mcast_sw_if_index",
ntohl (mp->mcast_sw_if_index));
}
u8 disable_indirect_desc = 0;
u8 *tag = 0;
u8 enable_gso = 0;
+ u8 enable_packed = 0;
int ret;
/* Shut up coverity */
disable_indirect_desc = 1;
else if (unformat (i, "gso"))
enable_gso = 1;
+ else if (unformat (i, "packed"))
+ enable_packed = 1;
else if (unformat (i, "tag %s", &tag))
;
else
mp->disable_mrg_rxbuf = disable_mrg_rxbuf;
mp->disable_indirect_desc = disable_indirect_desc;
mp->enable_gso = enable_gso;
+ mp->enable_packed = enable_packed;
clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
vec_free (file_name);
if (custom_dev_instance != ~0)
u8 sw_if_index_set = 0;
u32 sw_if_index = (u32) ~ 0;
u8 enable_gso = 0;
+ u8 enable_packed = 0;
int ret;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
is_server = 1;
else if (unformat (i, "gso"))
enable_gso = 1;
+ else if (unformat (i, "packed"))
+ enable_packed = 1;
else
break;
}
mp->sw_if_index = ntohl (sw_if_index);
mp->is_server = is_server;
mp->enable_gso = enable_gso;
+ mp->enable_packed = enable_packed;
clib_memcpy (mp->sock_filename, file_name, vec_len (file_name));
vec_free (file_name);
if (custom_dev_instance != ~0)
static int
api_sw_interface_vhost_user_dump (vat_main_t * vam)
{
+ unformat_input_t *i = vam->input;
vl_api_sw_interface_vhost_user_dump_t *mp;
vl_api_control_ping_t *mp_ping;
int ret;
+ u32 sw_if_index = ~0;
+
+ while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (i, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
+ ;
+ else if (unformat (i, "sw_if_index %d", &sw_if_index))
+ ;
+ else
+ break;
+ }
+
print (vam->ofp,
"Interface name idx hdr_sz features server regions filename");
/* Get list of vhost-user interfaces */
M (SW_INTERFACE_VHOST_USER_DUMP, mp);
+ mp->sw_if_index = ntohl (sw_if_index);
S (mp);
/* Use a control ping for synchronization */
{
unformat_input_t *line_input = vam->input;
vl_api_vxlan_gpe_add_del_tunnel_t *mp;
- ip4_address_t local4, remote4;
- ip6_address_t local6, remote6;
+ ip46_address_t local, remote;
u8 is_add = 1;
- u8 ipv4_set = 0, ipv6_set = 0;
u8 local_set = 0;
u8 remote_set = 0;
u8 grp_set = 0;
u8 vni_set = 0;
int ret;
- /* Can't "universally zero init" (={0}) due to GCC bug 53119 */
- clib_memset (&local4, 0, sizeof local4);
- clib_memset (&remote4, 0, sizeof remote4);
- clib_memset (&local6, 0, sizeof local6);
- clib_memset (&remote6, 0, sizeof remote6);
-
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "del"))
is_add = 0;
else if (unformat (line_input, "local %U",
- unformat_ip4_address, &local4))
+ unformat_ip46_address, &local))
{
local_set = 1;
- ipv4_set = 1;
}
else if (unformat (line_input, "remote %U",
- unformat_ip4_address, &remote4))
+ unformat_ip46_address, &remote))
{
remote_set = 1;
- ipv4_set = 1;
- }
- else if (unformat (line_input, "local %U",
- unformat_ip6_address, &local6))
- {
- local_set = 1;
- ipv6_set = 1;
- }
- else if (unformat (line_input, "remote %U",
- unformat_ip6_address, &remote6))
- {
- remote_set = 1;
- ipv6_set = 1;
}
else if (unformat (line_input, "group %U %U",
- unformat_ip4_address, &remote4,
+ unformat_ip46_address, &remote,
api_unformat_sw_if_index, vam, &mcast_sw_if_index))
{
grp_set = remote_set = 1;
- ipv4_set = 1;
}
else if (unformat (line_input, "group %U",
- unformat_ip4_address, &remote4))
+ unformat_ip46_address, &remote))
{
grp_set = remote_set = 1;
- ipv4_set = 1;
- }
- else if (unformat (line_input, "group %U %U",
- unformat_ip6_address, &remote6,
- api_unformat_sw_if_index, vam, &mcast_sw_if_index))
- {
- grp_set = remote_set = 1;
- ipv6_set = 1;
- }
- else if (unformat (line_input, "group %U",
- unformat_ip6_address, &remote6))
- {
- grp_set = remote_set = 1;
- ipv6_set = 1;
}
else
if (unformat (line_input, "mcast_sw_if_index %u", &mcast_sw_if_index))
errmsg ("tunnel nonexistent multicast device");
return -99;
}
- if (ipv4_set && ipv6_set)
+ if (ip46_address_is_ip4 (&local) != ip46_address_is_ip4 (&remote))
{
errmsg ("both IPv4 and IPv6 addresses specified");
return -99;
M (VXLAN_GPE_ADD_DEL_TUNNEL, mp);
-
- if (ipv6_set)
- {
- clib_memcpy (&mp->local, &local6, sizeof (local6));
- clib_memcpy (&mp->remote, &remote6, sizeof (remote6));
- }
- else
- {
- clib_memcpy (&mp->local, &local4, sizeof (local4));
- clib_memcpy (&mp->remote, &remote4, sizeof (remote4));
- }
+ ip_address_encode (&local,
+ ip46_address_is_ip4 (&local) ? IP46_TYPE_IP4 :
+ IP46_TYPE_IP6, &mp->local);
+ ip_address_encode (&remote,
+ ip46_address_is_ip4 (&remote) ? IP46_TYPE_IP4 :
+ IP46_TYPE_IP6, &mp->remote);
mp->mcast_sw_if_index = ntohl (mcast_sw_if_index);
mp->encap_vrf_id = ntohl (encap_vrf_id);
mp->protocol = protocol;
mp->vni = ntohl (vni);
mp->is_add = is_add;
- mp->is_ipv6 = ipv6_set;
S (mp);
W (ret);
(vl_api_vxlan_gpe_tunnel_details_t * mp)
{
vat_main_t *vam = &vat_main;
- ip46_address_t local = to_ip46 (mp->is_ipv6, mp->local);
- ip46_address_t remote = to_ip46 (mp->is_ipv6, mp->remote);
+ ip46_address_t local, remote;
+
+ ip_address_decode (&mp->local, &local);
+ ip_address_decode (&mp->remote, &remote);
print (vam->ofp, "%11d%24U%24U%13d%12d%19d%14d%14d",
ntohl (mp->sw_if_index),
vat_json_node_t *node = NULL;
struct in_addr ip4;
struct in6_addr ip6;
+ ip46_address_t local, remote;
+
+ ip_address_decode (&mp->local, &local);
+ ip_address_decode (&mp->remote, &remote);
if (VAT_JSON_ARRAY != vam->json_tree.type)
{
vat_json_init_object (node);
vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
- if (mp->is_ipv6)
+ if (ip46_address_is_ip4 (&local))
{
- clib_memcpy (&ip6, &(mp->local[0]), sizeof (ip6));
- vat_json_object_add_ip6 (node, "local", ip6);
- clib_memcpy (&ip6, &(mp->remote[0]), sizeof (ip6));
- vat_json_object_add_ip6 (node, "remote", ip6);
+ clib_memcpy (&ip4, &local.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (node, "local", ip4);
+ clib_memcpy (&ip4, &remote.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (node, "remote", ip4);
}
else
{
- clib_memcpy (&ip4, &(mp->local[0]), sizeof (ip4));
- vat_json_object_add_ip4 (node, "local", ip4);
- clib_memcpy (&ip4, &(mp->remote[0]), sizeof (ip4));
- vat_json_object_add_ip4 (node, "remote", ip4);
+ clib_memcpy (&ip6, &local.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (node, "local", ip6);
+ clib_memcpy (&ip6, &remote.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (node, "remote", ip6);
}
vat_json_object_add_uint (node, "vni", ntohl (mp->vni));
vat_json_object_add_uint (node, "protocol", ntohl (mp->protocol));
"crypto_key %U integ_alg %u integ_key %U flags %x "
"tunnel_src_addr %U tunnel_dst_addr %U "
"salt %u seq_outbound %lu last_seq_inbound %lu "
- "replay_window %lu\n",
+ "replay_window %lu stat_index %u\n",
ntohl (mp->entry.sad_id),
ntohl (mp->sw_if_index),
ntohl (mp->entry.spi),
&mp->entry.tunnel_dst, ntohl (mp->salt),
clib_net_to_host_u64 (mp->seq_outbound),
clib_net_to_host_u64 (mp->last_seq_inbound),
- clib_net_to_host_u64 (mp->replay_window));
+ clib_net_to_host_u64 (mp->replay_window), ntohl (mp->stat_index));
}
#define vl_api_ipsec_sa_details_t_endian vl_noop_handler
vat_json_object_add_address (node, "dst", &mp->entry.tunnel_dst);
vat_json_object_add_uint (node, "replay_window",
clib_net_to_host_u64 (mp->replay_window));
+ vat_json_object_add_uint (node, "stat_index", ntohl (mp->stat_index));
}
static int
/* *INDENT-OFF* */
/** Used for parsing LISP eids */
typedef CLIB_PACKED(struct{
- u8 addr[16]; /**< eid address */
+ union {
+ ip46_address_t ip;
+ mac_address_t mac;
+ lisp_nsh_api_t nsh;
+ } addr;
u32 len; /**< prefix length if IP */
u8 type; /**< type of eid */
}) lisp_eid_vat_t;
clib_memset (a, 0, sizeof (a[0]));
- if (unformat (input, "%U/%d", unformat_ip4_address, a->addr, &a->len))
- {
- a->type = 0; /* ipv4 type */
- }
- else if (unformat (input, "%U/%d", unformat_ip6_address, a->addr, &a->len))
+ if (unformat (input, "%U/%d", unformat_ip46_address, a->addr.ip, &a->len))
{
- a->type = 1; /* ipv6 type */
+ a->type = 0; /* ip prefix type */
}
- else if (unformat (input, "%U", unformat_ethernet_address, a->addr))
+ else if (unformat (input, "%U", unformat_ethernet_address, a->addr.mac))
{
- a->type = 2; /* mac type */
+ a->type = 1; /* mac type */
}
- else if (unformat (input, "%U", unformat_nsh_address, a->addr))
+ else if (unformat (input, "%U", unformat_nsh_address, a->addr.nsh))
{
- a->type = 3; /* NSH type */
- lisp_nsh_api_t *nsh = (lisp_nsh_api_t *) a->addr;
- nsh->spi = clib_host_to_net_u32 (nsh->spi);
+ a->type = 2; /* NSH type */
+ a->addr.nsh.spi = clib_host_to_net_u32 (a->addr.nsh.spi);
}
else
{
return 0;
}
- if ((a->type == 0 && a->len > 32) || (a->type == 1 && a->len > 128))
+ if (a->type == 0)
{
- return 0;
+ if (ip46_address_is_ip4 (&a->addr.ip))
+ return a->len > 32 ? 1 : 0;
+ else
+ return a->len > 128 ? 1 : 0;
}
return 1;
}
-static int
-lisp_eid_size_vat (u8 type)
+static void
+lisp_eid_put_vat (vl_api_eid_t * eid, const lisp_eid_vat_t * vat_eid)
{
- switch (type)
+ eid->type = vat_eid->type;
+ switch (eid->type)
{
- case 0:
- return 4;
- case 1:
- return 16;
- case 2:
- return 6;
- case 3:
- return 5;
+ case EID_TYPE_API_PREFIX:
+ if (ip46_address_is_ip4 (&vat_eid->addr.ip))
+ {
+ clib_memcpy (&eid->address.prefix.address.un.ip4,
+ &vat_eid->addr.ip.ip4, 4);
+ eid->address.prefix.address.af = ADDRESS_IP4;
+ eid->address.prefix.len = vat_eid->len;
+ }
+ else
+ {
+ clib_memcpy (&eid->address.prefix.address.un.ip6,
+ &vat_eid->addr.ip.ip6, 16);
+ eid->address.prefix.address.af = ADDRESS_IP6;
+ eid->address.prefix.len = vat_eid->len;
+ }
+ return;
+ case EID_TYPE_API_MAC:
+ clib_memcpy (&eid->address.mac, &vat_eid->addr.mac,
+ sizeof (eid->address.mac));
+ return;
+ case EID_TYPE_API_NSH:
+ clib_memcpy (&eid->address.nsh, &vat_eid->addr.nsh,
+ sizeof (eid->address.nsh));
+ return;
+ default:
+ ASSERT (0);
+ return;
}
- return 0;
-}
-
-static void
-lisp_eid_put_vat (u8 * dst, u8 eid[16], u8 type)
-{
- clib_memcpy (dst, eid, lisp_eid_size_vat (type));
}
static int
M (ONE_ADD_DEL_LOCAL_EID, mp);
mp->is_add = is_add;
- lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
- mp->eid_type = eid->type;
- mp->prefix_len = eid->len;
+ lisp_eid_put_vat (&mp->eid, eid);
mp->vni = clib_host_to_net_u32 (vni);
- mp->key_id = clib_host_to_net_u16 (key_id);
+ mp->key.id = key_id;
clib_memcpy (mp->locator_set_name, locator_set_name,
vec_len (locator_set_name));
- clib_memcpy (mp->key, key, vec_len (key));
+ clib_memcpy (mp->key.key, key, vec_len (key));
vec_free (locator_set_name);
vec_free (key);
else if (unformat (input, "loc-pair %U %U", unformat_ip4_address,
&lcl_rloc4, unformat_ip4_address, &rmt_rloc4))
{
- rloc.is_ip4 = 1;
-
- clib_memcpy (&rloc.addr, &lcl_rloc4, sizeof (lcl_rloc4));
+ rloc.addr.af = 0;
+ clib_memcpy (&rloc.addr.un.ip4, &lcl_rloc4, sizeof (lcl_rloc4));
rloc.weight = 0;
vec_add1 (lcl_locs, rloc);
- clib_memcpy (&rloc.addr, &rmt_rloc4, sizeof (rmt_rloc4));
+ clib_memcpy (&rloc.addr.un.ip4, &rmt_rloc4, sizeof (rmt_rloc4));
vec_add1 (rmt_locs, rloc);
/* weight saved in rmt loc */
curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
else if (unformat (input, "loc-pair %U %U", unformat_ip6_address,
&lcl_rloc6, unformat_ip6_address, &rmt_rloc6))
{
- rloc.is_ip4 = 0;
- clib_memcpy (&rloc.addr, &lcl_rloc6, sizeof (lcl_rloc6));
+ rloc.addr.af = 1;
+ clib_memcpy (&rloc.addr.un.ip6, &lcl_rloc6, sizeof (lcl_rloc6));
rloc.weight = 0;
vec_add1 (lcl_locs, rloc);
- clib_memcpy (&rloc.addr, &rmt_rloc6, sizeof (rmt_rloc6));
+ clib_memcpy (&rloc.addr.un.ip6, &rmt_rloc6, sizeof (rmt_rloc6));
vec_add1 (rmt_locs, rloc);
/* weight saved in rmt loc */
curr_rloc = &rmt_locs[vec_len (rmt_locs) - 1];
sizeof (vl_api_gpe_locator_t) * vec_len (rmt_locs) * 2);
mp->is_add = is_add;
- lisp_eid_put_vat (mp->rmt_eid, rmt_eid->addr, rmt_eid->type);
- lisp_eid_put_vat (mp->lcl_eid, lcl_eid->addr, lcl_eid->type);
- mp->eid_type = rmt_eid->type;
+ lisp_eid_put_vat (&mp->rmt_eid, rmt_eid);
+ lisp_eid_put_vat (&mp->lcl_eid, lcl_eid);
mp->dp_table = clib_host_to_net_u32 (dp_table);
mp->vni = clib_host_to_net_u32 (vni);
- mp->rmt_len = rmt_eid->len;
- mp->lcl_len = lcl_eid->len;
mp->action = action;
if (0 != rmt_locs && 0 != lcl_locs)
mp->is_add = is_add;
if (ipv6_set)
{
- mp->is_ipv6 = 1;
- clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
+ mp->ip_address.af = 1;
+ clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
}
else
{
- mp->is_ipv6 = 0;
- clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
+ mp->ip_address.af = 0;
+ clib_memcpy (mp->ip_address.un.ip4, &ipv4, sizeof (ipv4));
}
/* send it... */
mp->is_add = is_add;
if (ipv6_set)
{
- mp->is_ipv6 = 1;
- clib_memcpy (mp->ip_address, &ipv6, sizeof (ipv6));
+ mp->ip_address.af = 1;
+ clib_memcpy (mp->ip_address.un.ip6, &ipv6, sizeof (ipv6));
}
else
{
- mp->is_ipv6 = 0;
- clib_memcpy (mp->ip_address, &ipv4, sizeof (ipv4));
+ mp->ip_address.af = 0;
+ clib_memcpy (mp->ip_address.un.ip6, &ipv4, sizeof (ipv4));
}
/* send it... */
unformat_input_t *input = vam->input;
vl_api_gpe_enable_disable_t *mp;
u8 is_set = 0;
- u8 is_en = 1;
+ u8 is_enable = 1;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
is_set = 1;
- is_en = 0;
+ is_enable = 0;
}
else
break;
/* Construct the API message */
M (GPE_ENABLE_DISABLE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_rloc_probe_enable_disable_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
is_set = 1;
/* Construct the API message */
M (ONE_RLOC_PROBE_ENABLE_DISABLE, mp);
- mp->is_enabled = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_map_register_enable_disable_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
is_set = 1;
/* Construct the API message */
M (ONE_MAP_REGISTER_ENABLE_DISABLE, mp);
- mp->is_enabled = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_enable_disable_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
/* Construct the API message */
M (ONE_ENABLE_DISABLE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_enable_disable_xtr_mode_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
/* Construct the API message */
M (ONE_ENABLE_DISABLE_XTR_MODE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_enable_disable_pitr_mode_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
/* Construct the API message */
M (ONE_ENABLE_DISABLE_PITR_MODE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
unformat_input_t *input = vam->input;
vl_api_one_enable_disable_petr_mode_t *mp;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
/* Construct the API message */
M (ONE_ENABLE_DISABLE_PETR_MODE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send it... */
S (mp);
M (ONE_ADD_DEL_NDP_ENTRY, mp);
mp->is_add = is_add;
- clib_memcpy (mp->mac, mac, 6);
+ clib_memcpy (&mp->entry.mac, mac, 6);
mp->bd = clib_host_to_net_u32 (bd);
- clib_memcpy (mp->ip6, ip6, sizeof (mp->ip6));
+ clib_memcpy (&mp->entry.ip6, ip6, sizeof (mp->entry.ip6));
/* send */
S (mp);
M (ONE_ADD_DEL_L2_ARP_ENTRY, mp);
mp->is_add = is_add;
- clib_memcpy (mp->mac, mac, 6);
+ clib_memcpy (&mp->entry.mac, mac, 6);
mp->bd = clib_host_to_net_u32 (bd);
- mp->ip4 = ip4;
+ clib_memcpy (mp->entry.ip4, &ip4, sizeof (mp->entry.ip4));
/* send */
S (mp);
vl_api_one_stats_enable_disable_t *mp;
unformat_input_t *input = vam->input;
u8 is_set = 0;
- u8 is_en = 0;
+ u8 is_enable = 0;
int ret;
/* Parse args required to build the message */
if (unformat (input, "enable"))
{
is_set = 1;
- is_en = 1;
+ is_enable = 1;
}
else if (unformat (input, "disable"))
{
}
M (ONE_STATS_ENABLE_DISABLE, mp);
- mp->is_en = is_en;
+ mp->is_enable = is_enable;
/* send */
S (mp);
mp->is_add = is_add;
if (is_add)
{
- mp->is_ip4 = ip_addr_version (&ip) == AF_IP4 ? 1 : 0;
- if (mp->is_ip4)
- clib_memcpy (mp->address, &ip, 4);
+ mp->ip_address.af = ip_addr_version (&ip) == AF_IP4 ? 0 : 1;
+ if (mp->ip_address.af)
+ clib_memcpy (mp->ip_address.un.ip6, &ip, 16);
else
- clib_memcpy (mp->address, &ip, 16);
+ clib_memcpy (mp->ip_address.un.ip4, &ip, 4);
}
/* send */
}
else if (unformat (input, "rloc %U", unformat_ip4_address, &rloc4))
{
- rloc.is_ip4 = 1;
- clib_memcpy (&rloc.addr, &rloc4, sizeof (rloc4));
+ rloc.ip_address.af = 0;
+ clib_memcpy (&rloc.ip_address.un.ip6, &rloc6, sizeof (rloc6));
vec_add1 (rlocs, rloc);
curr_rloc = &rlocs[vec_len (rlocs) - 1];
}
else if (unformat (input, "rloc %U", unformat_ip6_address, &rloc6))
{
- rloc.is_ip4 = 0;
- clib_memcpy (&rloc.addr, &rloc6, sizeof (rloc6));
+ rloc.ip_address.af = 1;
+ clib_memcpy (&rloc.ip_address.un.ip4, &rloc4, sizeof (rloc4));
vec_add1 (rlocs, rloc);
curr_rloc = &rlocs[vec_len (rlocs) - 1];
}
mp->vni = htonl (vni);
mp->action = (u8) action;
mp->is_src_dst = seid_set;
- mp->eid_len = eid->len;
- mp->seid_len = seid->len;
mp->del_all = del_all;
- mp->eid_type = eid->type;
- lisp_eid_put_vat (mp->eid, eid->addr, eid->type);
- lisp_eid_put_vat (mp->seid, seid->addr, seid->type);
+ lisp_eid_put_vat (&mp->deid, eid);
+ lisp_eid_put_vat (&mp->seid, seid);
mp->rloc_num = clib_host_to_net_u32 (vec_len (rlocs));
clib_memcpy (mp->rlocs, rlocs, data_len);
unformat_input_t *input = vam->input;
vl_api_one_add_del_adjacency_t *mp;
u32 vni = 0;
- ip4_address_t leid4, reid4;
- ip6_address_t leid6, reid6;
- u8 reid_mac[6] = { 0 };
- u8 leid_mac[6] = { 0 };
- u8 reid_type, leid_type;
- u32 leid_len = 0, reid_len = 0, len;
u8 is_add = 1;
int ret;
+ lisp_eid_vat_t leid, reid;
- leid_type = reid_type = (u8) ~ 0;
+ leid.type = reid.type = (u8) ~ 0;
/* Parse args required to build the message */
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
is_add = 1;
}
- else if (unformat (input, "reid %U/%d", unformat_ip4_address,
- &reid4, &len))
- {
- reid_type = 0; /* ipv4 */
- reid_len = len;
- }
- else if (unformat (input, "reid %U/%d", unformat_ip6_address,
- &reid6, &len))
+ else if (unformat (input, "reid %U/%d", unformat_ip46_address,
+ &reid.addr.ip, &reid.len))
{
- reid_type = 1; /* ipv6 */
- reid_len = len;
+ reid.type = 0; /* ipv4 */
}
else if (unformat (input, "reid %U", unformat_ethernet_address,
- reid_mac))
+ &reid.addr.mac))
{
- reid_type = 2; /* mac */
+ reid.type = 1; /* mac */
}
- else if (unformat (input, "leid %U/%d", unformat_ip4_address,
- &leid4, &len))
+ else if (unformat (input, "leid %U/%d", unformat_ip46_address,
+ &leid.addr.ip, &leid.len))
{
- leid_type = 0; /* ipv4 */
- leid_len = len;
- }
- else if (unformat (input, "leid %U/%d", unformat_ip6_address,
- &leid6, &len))
- {
- leid_type = 1; /* ipv6 */
- leid_len = len;
+ leid.type = 0; /* ipv4 */
}
else if (unformat (input, "leid %U", unformat_ethernet_address,
- leid_mac))
+ &leid.addr.mac))
{
- leid_type = 2; /* mac */
+ leid.type = 1; /* mac */
}
else if (unformat (input, "vni %d", &vni))
{
}
}
- if ((u8) ~ 0 == reid_type)
+ if ((u8) ~ 0 == reid.type)
{
errmsg ("missing params!");
return -99;
}
- if (leid_type != reid_type)
+ if (leid.type != reid.type)
{
errmsg ("remote and local EIDs are of different types!");
return -99;
M (ONE_ADD_DEL_ADJACENCY, mp);
mp->is_add = is_add;
mp->vni = htonl (vni);
- mp->leid_len = leid_len;
- mp->reid_len = reid_len;
- mp->eid_type = reid_type;
-
- switch (mp->eid_type)
- {
- case 0:
- clib_memcpy (mp->leid, &leid4, sizeof (leid4));
- clib_memcpy (mp->reid, &reid4, sizeof (reid4));
- break;
- case 1:
- clib_memcpy (mp->leid, &leid6, sizeof (leid6));
- clib_memcpy (mp->reid, &reid6, sizeof (reid6));
- break;
- case 2:
- clib_memcpy (mp->leid, leid_mac, 6);
- clib_memcpy (mp->reid, reid_mac, 6);
- break;
- default:
- errmsg ("unknown EID type %d!", mp->eid_type);
- return 0;
- }
+ lisp_eid_put_vat (&mp->leid, &leid);
+ lisp_eid_put_vat (&mp->reid, &reid);
/* send it... */
S (mp);
/* Construct the API message */
M (GPE_SET_ENCAP_MODE, mp);
- mp->mode = mode;
+ mp->is_vxlan = mode;
/* send it... */
S (mp);
unformat_input_t *i = vam->input;
vl_api_one_eid_table_dump_t *mp;
vl_api_control_ping_t *mp_ping;
- struct in_addr ip4;
- struct in6_addr ip6;
- u8 mac[6];
- u8 eid_type = ~0, eid_set = 0;
- u32 prefix_length = ~0, t, vni = 0;
u8 filter = 0;
int ret;
- lisp_nsh_api_t nsh;
+ u32 vni, t = 0;
+ lisp_eid_vat_t eid;
+ u8 eid_set = 0;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (i, "eid %U/%d", unformat_ip4_address, &ip4, &t))
- {
- eid_set = 1;
- eid_type = 0;
- prefix_length = t;
- }
- else if (unformat (i, "eid %U/%d", unformat_ip6_address, &ip6, &t))
+ if (unformat
+ (i, "eid %U/%d", unformat_ip46_address, &eid.addr.ip, &eid.len))
{
eid_set = 1;
- eid_type = 1;
- prefix_length = t;
+ eid.type = 0;
}
- else if (unformat (i, "eid %U", unformat_ethernet_address, mac))
+ else
+ if (unformat (i, "eid %U", unformat_ethernet_address, &eid.addr.mac))
{
eid_set = 1;
- eid_type = 2;
+ eid.type = 1;
}
- else if (unformat (i, "eid %U", unformat_nsh_address, &nsh))
+ else if (unformat (i, "eid %U", unformat_nsh_address, &eid.addr.nsh))
{
eid_set = 1;
- eid_type = 3;
+ eid.type = 2;
}
else if (unformat (i, "vni %d", &t))
{
{
mp->eid_set = 1;
mp->vni = htonl (vni);
- mp->eid_type = eid_type;
- switch (eid_type)
- {
- case 0:
- mp->prefix_length = prefix_length;
- clib_memcpy (mp->eid, &ip4, sizeof (ip4));
- break;
- case 1:
- mp->prefix_length = prefix_length;
- clib_memcpy (mp->eid, &ip6, sizeof (ip6));
- break;
- case 2:
- clib_memcpy (mp->eid, mac, sizeof (mac));
- break;
- case 3:
- clib_memcpy (mp->eid, &nsh, sizeof (nsh));
- break;
- default:
- errmsg ("unknown EID type %d!", eid_type);
- return -99;
- }
+ lisp_eid_put_vat (&mp->eid, &eid);
}
/* send it... */
mp->is_add = is_add;
mp->table_id = clib_host_to_net_u32 (table_id);
mp->nh_sw_if_index = clib_host_to_net_u32 (nh_sw_if_index);
- mp->is_ip4 = is_ip4;
+ mp->nh_addr.af = is_ip4 ? 0 : 1;
if (is_ip4)
- clib_memcpy (mp->nh_addr, &ip4, sizeof (ip4));
+ clib_memcpy (mp->nh_addr.un.ip4, &ip4, sizeof (ip4));
else
- clib_memcpy (mp->nh_addr, &ip6, sizeof (ip6));
+ clib_memcpy (mp->nh_addr.un.ip6, &ip6, sizeof (ip6));
/* send it... */
S (mp);
mp->rate_type = rate_type;
mp->round_type = round_type;
mp->type = type;
- mp->conform_action_type = conform_action.action_type;
- mp->conform_dscp = conform_action.dscp;
- mp->exceed_action_type = exceed_action.action_type;
- mp->exceed_dscp = exceed_action.dscp;
- mp->violate_action_type = violate_action.action_type;
- mp->violate_dscp = violate_action.dscp;
+ mp->conform_action.type = conform_action.action_type;
+ mp->conform_action.dscp = conform_action.dscp;
+ mp->exceed_action.type = exceed_action.action_type;
+ mp->exceed_action.dscp = exceed_action.dscp;
+ mp->violate_action.type = violate_action.action_type;
+ mp->violate_action.dscp = violate_action.dscp;
mp->color_aware = color_aware;
S (mp);
return ret;
}
-static int
-api_netmap_create (vat_main_t * vam)
-{
- unformat_input_t *i = vam->input;
- vl_api_netmap_create_t *mp;
- u8 *if_name = 0;
- u8 hw_addr[6];
- u8 random_hw_addr = 1;
- u8 is_pipe = 0;
- u8 is_master = 0;
- int ret;
-
- clib_memset (hw_addr, 0, sizeof (hw_addr));
-
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (i, "name %s", &if_name))
- vec_add1 (if_name, 0);
- else if (unformat (i, "hw_addr %U", unformat_ethernet_address, hw_addr))
- random_hw_addr = 0;
- else if (unformat (i, "pipe"))
- is_pipe = 1;
- else if (unformat (i, "master"))
- is_master = 1;
- else if (unformat (i, "slave"))
- is_master = 0;
- else
- break;
- }
-
- if (!vec_len (if_name))
- {
- errmsg ("interface name must be specified");
- return -99;
- }
-
- if (vec_len (if_name) > 64)
- {
- errmsg ("interface name too long");
- return -99;
- }
-
- M (NETMAP_CREATE, mp);
-
- clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
- clib_memcpy (mp->hw_addr, hw_addr, 6);
- mp->use_random_hw_addr = random_hw_addr;
- mp->is_pipe = is_pipe;
- mp->is_master = is_master;
- vec_free (if_name);
-
- S (mp);
- W (ret);
- return ret;
-}
-
-static int
-api_netmap_delete (vat_main_t * vam)
-{
- unformat_input_t *i = vam->input;
- vl_api_netmap_delete_t *mp;
- u8 *if_name = 0;
- int ret;
-
- while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (i, "name %s", &if_name))
- vec_add1 (if_name, 0);
- else
- break;
- }
-
- if (!vec_len (if_name))
- {
- errmsg ("interface name must be specified");
- return -99;
- }
-
- if (vec_len (if_name) > 64)
- {
- errmsg ("interface name too long");
- return -99;
- }
-
- M (NETMAP_DELETE, mp);
-
- clib_memcpy (mp->netmap_if_name, if_name, vec_len (if_name));
- vec_free (if_name);
-
- S (mp);
- W (ret);
- return ret;
-}
-
static u8 *
format_fib_api_path_nh_proto (u8 * s, va_list * args)
{
static u8 *
format_vl_api_ip_address_union (u8 * s, va_list * args)
{
- vl_api_address_family_t af = va_arg (*args, vl_api_address_family_t);
+ vl_api_address_family_t af = va_arg (*args, int);
const vl_api_address_union_t *u = va_arg (*args, vl_api_address_union_t *);
switch (af)
clib_memcpy (&ip4, &fp->nh.address.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "next_hop", ip4);
}
- else if (fp->proto == FIB_API_PATH_NH_PROTO_IP4)
+ else if (fp->proto == FIB_API_PATH_NH_PROTO_IP6)
{
clib_memcpy (&ip6, &fp->nh.address.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "next_hop", ip6);
}
}
- u32 name_len = vec_len (pcap_file);
/* Construct the API message */
M (PG_CAPTURE, mp);
mp->context = 0;
mp->interface_id = ntohl (if_id);
mp->is_enabled = enable;
mp->count = ntohl (count);
- mp->pcap_name_length = ntohl (name_len);
if (pcap_file_set != 0)
{
- clib_memcpy (mp->pcap_file_name, pcap_file, name_len);
+ vl_api_vec_to_api_string (pcap_file, &mp->pcap_file_name);
}
vec_free (pcap_file);
}
}
- u32 name_len = vec_len (stream_name);
/* Construct the API message */
M (PG_ENABLE_DISABLE, mp);
mp->context = 0;
mp->is_enabled = enable;
if (stream_name_set != 0)
{
- mp->stream_name_length = ntohl (name_len);
- clib_memcpy (mp->stream_name, stream_name, name_len);
+ vl_api_vec_to_api_string (stream_name, &mp->stream_name);
}
vec_free (stream_name);
return ret;
}
+int
+api_pg_interface_enable_disable_coalesce (vat_main_t * vam)
+{
+ unformat_input_t *input = vam->input;
+ vl_api_pg_interface_enable_disable_coalesce_t *mp;
+
+ u32 sw_if_index = ~0;
+ u8 enable = 1;
+ int ret;
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "%U", api_unformat_sw_if_index, vam, &sw_if_index))
+ ;
+ else if (unformat (input, "sw_if_index %d", &sw_if_index))
+ ;
+ else if (unformat (input, "disable"))
+ enable = 0;
+ else
+ break;
+ }
+
+ if (sw_if_index == ~0)
+ {
+ errmsg ("Interface required but not specified");
+ return -99;
+ }
+
+ /* Construct the API message */
+ M (PG_INTERFACE_ENABLE_DISABLE_COALESCE, mp);
+ mp->context = 0;
+ mp->coalesce_enabled = enable;
+ mp->sw_if_index = htonl (sw_if_index);
+
+ S (mp);
+ W (ret);
+ return ret;
+}
+
int
api_ip_source_and_port_range_check_add_del (vat_main_t * vam)
{
M (LLDP_CONFIG, mp);
mp->tx_hold = htonl (tx_hold);
mp->tx_interval = htonl (tx_interval);
- clib_memcpy (mp->system_name, sys_name, vec_len (sys_name));
+ vl_api_vec_to_api_string (sys_name, &mp->system_name);
vec_free (sys_name);
S (mp);
M (SW_INTERFACE_SET_LLDP, mp);
mp->sw_if_index = ntohl (sw_if_index);
mp->enable = enable;
- clib_memcpy (mp->port_desc, port_desc, vec_len (port_desc));
+ vl_api_vec_to_api_string (port_desc, &mp->port_desc);
clib_memcpy (mp->mgmt_oid, mgmt_oid, vec_len (mgmt_oid));
clib_memcpy (mp->mgmt_ip4, &ip4_addr, sizeof (ip4_addr));
clib_memcpy (mp->mgmt_ip6, &ip6_addr, sizeof (ip6_addr));
}
M (APP_NAMESPACE_ADD_DEL, mp);
- clib_memcpy (mp->namespace_id, ns_id, vec_len (ns_id));
- mp->namespace_id_len = vec_len (ns_id);
+ vl_api_vec_to_api_string (ns_id, &mp->namespace_id);
mp->secret = clib_host_to_net_u64 (secret);
mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
mp->ip4_fib_id = clib_host_to_net_u32 (ip4_fib_id);
vl_api_session_rules_details_t_handler (vl_api_session_rules_details_t * mp)
{
vat_main_t *vam = &vat_main;
+ fib_prefix_t lcl, rmt;
- if (mp->is_ip4)
+ ip_prefix_decode (&mp->lcl, &lcl);
+ ip_prefix_decode (&mp->rmt, &rmt);
+
+ if (lcl.fp_proto == FIB_PROTOCOL_IP4)
{
print (vam->ofp,
"appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
- mp->scope, format_ip4_address, &mp->lcl_ip, mp->lcl_plen,
+ mp->scope, format_ip4_address, &lcl.fp_addr.ip4, lcl.fp_len,
clib_net_to_host_u16 (mp->lcl_port), format_ip4_address,
- &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
+ &rmt.fp_addr.ip4, rmt.fp_len,
+ clib_net_to_host_u16 (mp->rmt_port),
clib_net_to_host_u32 (mp->action_index), mp->tag);
}
else
print (vam->ofp,
"appns %u tp %u scope %d %U/%d %d %U/%d %d action: %d tag: %s",
clib_net_to_host_u32 (mp->appns_index), mp->transport_proto,
- mp->scope, format_ip6_address, &mp->lcl_ip, mp->lcl_plen,
+ mp->scope, format_ip6_address, &lcl.fp_addr.ip6, lcl.fp_len,
clib_net_to_host_u16 (mp->lcl_port), format_ip6_address,
- &mp->rmt_ip, mp->rmt_plen, clib_net_to_host_u16 (mp->rmt_port),
+ &rmt.fp_addr.ip6, rmt.fp_len,
+ clib_net_to_host_u16 (mp->rmt_port),
clib_net_to_host_u32 (mp->action_index), mp->tag);
}
}
struct in6_addr ip6;
struct in_addr ip4;
+ fib_prefix_t lcl, rmt;
+
+ ip_prefix_decode (&mp->lcl, &lcl);
+ ip_prefix_decode (&mp->rmt, &rmt);
+
if (VAT_JSON_ARRAY != vam->json_tree.type)
{
ASSERT (VAT_JSON_NONE == vam->json_tree.type);
node = vat_json_array_add (&vam->json_tree);
vat_json_init_object (node);
- vat_json_object_add_uint (node, "is_ip4", mp->is_ip4 ? 1 : 0);
vat_json_object_add_uint (node, "appns_index",
clib_net_to_host_u32 (mp->appns_index));
vat_json_object_add_uint (node, "transport_proto", mp->transport_proto);
clib_net_to_host_u16 (mp->lcl_port));
vat_json_object_add_uint (node, "rmt_port",
clib_net_to_host_u16 (mp->rmt_port));
- vat_json_object_add_uint (node, "lcl_plen", mp->lcl_plen);
- vat_json_object_add_uint (node, "rmt_plen", mp->rmt_plen);
+ vat_json_object_add_uint (node, "lcl_plen", lcl.fp_len);
+ vat_json_object_add_uint (node, "rmt_plen", rmt.fp_len);
vat_json_object_add_string_copy (node, "tag", mp->tag);
- if (mp->is_ip4)
+ if (lcl.fp_proto == FIB_PROTOCOL_IP4)
{
- clib_memcpy (&ip4, mp->lcl_ip, sizeof (ip4));
+ clib_memcpy (&ip4, &lcl.fp_addr.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "lcl_ip", ip4);
- clib_memcpy (&ip4, mp->rmt_ip, sizeof (ip4));
+ clib_memcpy (&ip4, &rmt.fp_addr.ip4, sizeof (ip4));
vat_json_object_add_ip4 (node, "rmt_ip", ip4);
}
else
{
- clib_memcpy (&ip6, mp->lcl_ip, sizeof (ip6));
+ clib_memcpy (&ip6, &lcl.fp_addr.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "lcl_ip", ip6);
- clib_memcpy (&ip6, mp->rmt_ip, sizeof (ip6));
+ clib_memcpy (&ip6, &rmt.fp_addr.ip6, sizeof (ip6));
vat_json_object_add_ip6 (node, "rmt_ip", ip6);
}
}
u8 is_ip4 = 1, conn_set = 0;
u8 is_add = 1, *tag = 0;
int ret;
+ fib_prefix_t lcl, rmt;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
M (SESSION_RULE_ADD_DEL, mp);
- mp->is_ip4 = is_ip4;
- mp->transport_proto = proto;
- mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
- mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
- mp->lcl_plen = lcl_plen;
- mp->rmt_plen = rmt_plen;
- mp->action_index = clib_host_to_net_u32 (action);
- mp->appns_index = clib_host_to_net_u32 (appns_index);
- mp->scope = scope;
- mp->is_add = is_add;
+ clib_memset (&lcl, 0, sizeof (lcl));
+ clib_memset (&rmt, 0, sizeof (rmt));
if (is_ip4)
{
- clib_memcpy (mp->lcl_ip, &lcl_ip4, sizeof (lcl_ip4));
- clib_memcpy (mp->rmt_ip, &rmt_ip4, sizeof (rmt_ip4));
+ ip_set (&lcl.fp_addr, &lcl_ip4, 1);
+ ip_set (&rmt.fp_addr, &rmt_ip4, 1);
+ lcl.fp_len = lcl_plen;
+ rmt.fp_len = rmt_plen;
}
else
{
- clib_memcpy (mp->lcl_ip, &lcl_ip6, sizeof (lcl_ip6));
- clib_memcpy (mp->rmt_ip, &rmt_ip6, sizeof (rmt_ip6));
+ ip_set (&lcl.fp_addr, &lcl_ip6, 0);
+ ip_set (&rmt.fp_addr, &rmt_ip6, 0);
+ lcl.fp_len = lcl_plen;
+ rmt.fp_len = rmt_plen;
}
+
+
+ ip_prefix_encode (&lcl, &mp->lcl);
+ ip_prefix_encode (&rmt, &mp->rmt);
+ mp->lcl_port = clib_host_to_net_u16 ((u16) lcl_port);
+ mp->rmt_port = clib_host_to_net_u16 ((u16) rmt_port);
+ mp->transport_proto =
+ proto ? TRANSPORT_PROTO_API_UDP : TRANSPORT_PROTO_API_TCP;
+ mp->action_index = clib_host_to_net_u32 (action);
+ mp->appns_index = clib_host_to_net_u32 (appns_index);
+ mp->scope = scope;
+ mp->is_add = is_add;
if (tag)
{
clib_memcpy (mp->tag, tag, vec_len (tag));
_(bridge_flags, \
"bd_id <bridge-domain-id> [learn] [forward] [uu-flood] [flood] [arp-term] [disable]\n") \
_(tap_create_v2, \
- "id <num> [hw-addr <mac-addr>] [host-ns <name>] [rx-ring-size <num> [tx-ring-size <num>] [host-mtu-size <mtu>] [gso | no-gso]") \
+ "id <num> [hw-addr <mac-addr>] [host-if-name <name>] [host-ns <name>] [num-rx-queues <num>] [rx-ring-size <num>] [tx-ring-size <num>] [host-bridge <name>] [host-mac-addr <mac-addr>] [host-ip4-addr <ip4addr/mask>] [host-ip6-addr <ip6addr/mask>] [host-mtu-size <mtu>] [gso | no-gso | csum-offload | gro-coalesce] [persist] [attach] [tun]") \
_(tap_delete_v2, \
"<vpp-if-name> | sw_if_index <id>") \
_(sw_interface_tap_v2_dump, "") \
_(virtio_pci_create, \
- "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled]") \
+ "pci-addr <pci-address> [use_random_mac | hw-addr <mac-addr>] [features <hex-value>] [gso-enabled | csum-offload-enabled]") \
_(virtio_pci_delete, \
"<vpp-if-name> | sw_if_index <id>") \
_(sw_interface_virtio_pci_dump, "") \
"[id <if-id>]") \
_(bond_delete, \
"<vpp-if-name> | sw_if_index <id>") \
-_(bond_enslave, \
+_(bond_add_member, \
"sw_if_index <n> bond <sw_if_index> [is_passive] [is_long_timeout]") \
-_(bond_detach_slave, \
+_(bond_detach_member, \
"sw_if_index <n>") \
_(sw_interface_set_bond_weight, "<intfc> | sw_if_index <nn> weight <value>") \
-_(sw_interface_bond_dump, "") \
-_(sw_interface_slave_dump, \
+ _(sw_bond_interface_dump, "<intfc> | sw_if_index <nn>") \
+ _(sw_member_interface_dump, \
"<vpp-if-name> | sw_if_index <id>") \
_(ip_table_add_del, \
"table <n> [ipv6] [add | del]\n") \
_(create_vhost_user_if, \
"socket <filename> [server] [renumber <dev_instance>] " \
"[disable_mrg_rxbuf] [disable_indirect_desc] [gso] " \
- "[mac <mac_address>]") \
+ "[mac <mac_address>] [packed]") \
_(modify_vhost_user_if, \
"<intfc> | sw_if_index <nn> socket <filename>\n" \
- "[server] [renumber <dev_instance>] [gso]") \
+ "[server] [renumber <dev_instance>] [gso] [packed]") \
_(delete_vhost_user_if, "<intfc> | sw_if_index <nn>") \
-_(sw_interface_vhost_user_dump, "") \
+_(sw_interface_vhost_user_dump, "<intfc> | sw_if_index <nn>") \
_(show_version, "") \
_(show_threads, "") \
_(vxlan_gpe_add_del_tunnel, \
"<intfc> | sw_if_index <nn> [ip4-table <nn>] [ip6-table <nn>]\n" \
" [l2-table <nn>] [del]") \
_(policer_classify_dump, "type [ip4|ip6|l2]") \
-_(netmap_create, "name <interface name> [hw-addr <mac>] [pipe] " \
- "[master|slave]") \
-_(netmap_delete, "name <interface name>") \
_(mpls_tunnel_dump, "tunnel_index <tunnel-id>") \
_(mpls_table_dump, "") \
_(mpls_route_dump, "table-id <ID>") \
_(pg_create_interface, "if_id <nn> [gso-enabled gso-size <size>]") \
_(pg_capture, "if_id <nnn> pcap <file_name> count <nnn> [disable]") \
_(pg_enable_disable, "[stream <id>] disable") \
+_(pg_interface_enable_disable_coalesce, "<intf> | sw_if_index <nn> enable | disable") \
_(ip_source_and_port_range_check_add_del, \
"<ip-addr>/<mask> range <nn>-<nn> vrf <id>") \
_(ip_source_and_port_range_check_interface_add_del, \
Code Review / vpp.git / blobdiff