vam->result_ready = 1;
}
-static void vl_api_gre_add_del_tunnel_reply_t_handler
- (vl_api_gre_add_del_tunnel_reply_t * mp)
+static void vl_api_gre_tunnel_add_del_reply_t_handler
+ (vl_api_gre_tunnel_add_del_reply_t * mp)
{
vat_main_t *vam = &vat_main;
i32 retval = ntohl (mp->retval);
}
}
-static void vl_api_gre_add_del_tunnel_reply_t_handler_json
- (vl_api_gre_add_del_tunnel_reply_t * mp)
+static void vl_api_gre_tunnel_add_del_reply_t_handler_json
+ (vl_api_gre_tunnel_add_del_reply_t * mp)
{
vat_main_t *vam = &vat_main;
vat_json_node_t node;
_(GENEVE_ADD_DEL_TUNNEL_REPLY, geneve_add_del_tunnel_reply) \
_(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) \
_(GENEVE_TUNNEL_DETAILS, geneve_tunnel_details) \
-_(GRE_ADD_DEL_TUNNEL_REPLY, gre_add_del_tunnel_reply) \
+_(GRE_TUNNEL_ADD_DEL_REPLY, gre_tunnel_add_del_reply) \
_(GRE_TUNNEL_DETAILS, gre_tunnel_details) \
_(L2_FIB_CLEAR_TABLE_REPLY, l2_fib_clear_table_reply) \
_(L2_INTERFACE_EFP_FILTER_REPLY, l2_interface_efp_filter_reply) \
}
static int
-api_gre_add_del_tunnel (vat_main_t * vam)
+api_gre_tunnel_add_del (vat_main_t * vam)
{
unformat_input_t *line_input = vam->input;
- vl_api_gre_add_del_tunnel_t *mp;
- ip4_address_t src4, dst4;
- ip6_address_t src6, dst6;
+ vl_api_address_t src = { }, dst =
+ {
+ };
+ vl_api_gre_tunnel_add_del_t *mp;
+ vl_api_gre_tunnel_type_t t_type;
u8 is_add = 1;
u8 ipv4_set = 0;
u8 ipv6_set = 0;
- u8 t_type = GRE_TUNNEL_TYPE_L3;
u8 src_set = 0;
u8 dst_set = 0;
u32 outer_fib_id = 0;
u32 instance = ~0;
int ret;
- clib_memset (&src4, 0, sizeof src4);
- clib_memset (&dst4, 0, sizeof dst4);
- clib_memset (&src6, 0, sizeof src6);
- clib_memset (&dst6, 0, sizeof dst6);
+ t_type = GRE_API_TUNNEL_TYPE_L3;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
is_add = 0;
else if (unformat (line_input, "instance %d", &instance))
;
- else if (unformat (line_input, "src %U", unformat_ip4_address, &src4))
- {
- src_set = 1;
- ipv4_set = 1;
- }
- else if (unformat (line_input, "dst %U", unformat_ip4_address, &dst4))
- {
- dst_set = 1;
- ipv4_set = 1;
- }
- else if (unformat (line_input, "src %U", unformat_ip6_address, &src6))
+ else if (unformat (line_input, "src %U", unformat_vl_api_address, &src))
{
src_set = 1;
- ipv6_set = 1;
}
- else if (unformat (line_input, "dst %U", unformat_ip6_address, &dst6))
+ else if (unformat (line_input, "dst %U", unformat_vl_api_address, &dst))
{
dst_set = 1;
- ipv6_set = 1;
}
else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id))
;
else if (unformat (line_input, "teb"))
- t_type = GRE_TUNNEL_TYPE_TEB;
+ t_type = GRE_API_TUNNEL_TYPE_TEB;
else if (unformat (line_input, "erspan %d", &session_id))
- t_type = GRE_TUNNEL_TYPE_ERSPAN;
+ t_type = GRE_API_TUNNEL_TYPE_ERSPAN;
else
{
errmsg ("parse error '%U'", format_unformat_error, line_input);
errmsg ("tunnel dst address not specified");
return -99;
}
- if (ipv4_set && ipv6_set)
- {
- errmsg ("both IPv4 and IPv6 addresses specified");
- return -99;
- }
+ M (GRE_TUNNEL_ADD_DEL, mp);
- M (GRE_ADD_DEL_TUNNEL, mp);
+ clib_memcpy (&mp->tunnel.src, &src, sizeof (mp->tunnel.src));
+ clib_memcpy (&mp->tunnel.dst, &dst, sizeof (mp->tunnel.dst));
- if (ipv4_set)
- {
- clib_memcpy (&mp->src_address, &src4, 4);
- clib_memcpy (&mp->dst_address, &dst4, 4);
- }
- else
- {
- clib_memcpy (&mp->src_address, &src6, 16);
- clib_memcpy (&mp->dst_address, &dst6, 16);
- }
- mp->instance = htonl (instance);
- mp->outer_fib_id = htonl (outer_fib_id);
+ mp->tunnel.instance = htonl (instance);
+ mp->tunnel.outer_fib_id = htonl (outer_fib_id);
mp->is_add = is_add;
- mp->session_id = htons ((u16) session_id);
- mp->tunnel_type = t_type;
- mp->is_ipv6 = ipv6_set;
+ mp->tunnel.session_id = htons ((u16) session_id);
+ mp->tunnel.type = htonl (t_type);
S (mp);
W (ret);
(vl_api_gre_tunnel_details_t * mp)
{
vat_main_t *vam = &vat_main;
- ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
- ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
print (vam->ofp, "%11d%11d%24U%24U%13d%14d%12d",
- ntohl (mp->sw_if_index),
- ntohl (mp->instance),
- format_ip46_address, &src, IP46_TYPE_ANY,
- format_ip46_address, &dst, IP46_TYPE_ANY,
- mp->tunnel_type, ntohl (mp->outer_fib_id), ntohl (mp->session_id));
+ ntohl (mp->tunnel.sw_if_index),
+ ntohl (mp->tunnel.instance),
+ format_vl_api_address, &mp->tunnel.src,
+ format_vl_api_address, &mp->tunnel.dst,
+ mp->tunnel.type, ntohl (mp->tunnel.outer_fib_id),
+ ntohl (mp->tunnel.session_id));
+}
+
+static void
+vat_json_object_add_address (vat_json_node_t * node,
+ const char *str, const vl_api_address_t * addr)
+{
+ if (ADDRESS_IP6 == addr->af)
+ {
+ struct in6_addr ip6;
+
+ clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
+ vat_json_object_add_ip6 (node, str, ip6);
+ }
+ else
+ {
+ struct in_addr ip4;
+
+ clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
+ vat_json_object_add_ip4 (node, str, ip4);
+ }
}
static void vl_api_gre_tunnel_details_t_handler_json
node = vat_json_array_add (&vam->json_tree);
vat_json_init_object (node);
- vat_json_object_add_uint (node, "sw_if_index", ntohl (mp->sw_if_index));
- vat_json_object_add_uint (node, "instance", ntohl (mp->instance));
- if (!mp->is_ipv6)
- {
- clib_memcpy (&ip4, &mp->src_address, sizeof (ip4));
- vat_json_object_add_ip4 (node, "src_address", ip4);
- clib_memcpy (&ip4, &mp->dst_address, sizeof (ip4));
- vat_json_object_add_ip4 (node, "dst_address", ip4);
- }
- else
- {
- clib_memcpy (&ip6, &mp->src_address, sizeof (ip6));
- vat_json_object_add_ip6 (node, "src_address", ip6);
- clib_memcpy (&ip6, &mp->dst_address, sizeof (ip6));
- vat_json_object_add_ip6 (node, "dst_address", ip6);
- }
- vat_json_object_add_uint (node, "tunnel_type", mp->tunnel_type);
- vat_json_object_add_uint (node, "outer_fib_id", ntohl (mp->outer_fib_id));
- vat_json_object_add_uint (node, "is_ipv6", mp->is_ipv6);
- vat_json_object_add_uint (node, "session_id", mp->session_id);
+ vat_json_object_add_uint (node, "sw_if_index",
+ ntohl (mp->tunnel.sw_if_index));
+ vat_json_object_add_uint (node, "instance", ntohl (mp->tunnel.instance));
+
+ vat_json_object_add_address (node, "src", &mp->tunnel.src);
+ vat_json_object_add_address (node, "dst", &mp->tunnel.dst);
+ vat_json_object_add_uint (node, "tunnel_type", mp->tunnel.type);
+ vat_json_object_add_uint (node, "outer_fib_id",
+ ntohl (mp->tunnel.outer_fib_id));
+ vat_json_object_add_uint (node, "session_id", mp->tunnel.session_id);
}
static int
#define vl_api_ipsec_sa_details_t_endian vl_noop_handler
#define vl_api_ipsec_sa_details_t_print vl_noop_handler
-static void
-vat_json_object_add_address (vat_json_node_t * node,
- const vl_api_address_t * addr)
-{
- if (ADDRESS_IP6 == addr->af)
- {
- struct in6_addr ip6;
-
- clib_memcpy (&ip6, &addr->un.ip6, sizeof (ip6));
- vat_json_object_add_ip6 (node, "ip_address", ip6);
- }
- else
- {
- struct in_addr ip4;
-
- clib_memcpy (&ip4, &addr->un.ip4, sizeof (ip4));
- vat_json_object_add_ip4 (node, "ip_address", ip4);
- }
-}
-
static void vl_api_ipsec_sa_details_t_handler_json
(vl_api_ipsec_sa_details_t * mp)
{
mp->entry.crypto_key.length);
vat_json_object_add_bytes (node, "integ_key", mp->entry.integrity_key.data,
mp->entry.integrity_key.length);
- vat_json_object_add_address (node, &mp->entry.tunnel_src);
- vat_json_object_add_address (node, &mp->entry.tunnel_dst);
+ vat_json_object_add_address (node, "src", &mp->entry.tunnel_src);
+ 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_string_copy (node, "link_layer",
format (0, "%U", format_vl_api_mac_address,
&mp->neighbor.mac_address));
- vat_json_object_add_address (node, &mp->neighbor.ip_address);
+ vat_json_object_add_address (node, "ip", &mp->neighbor.ip_address);
}
static int
"vni <vni> [encap-vrf-id <nn>] [decap-next <l2|nn>] [del]") \
_(vxlan_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
_(geneve_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
-_(gre_add_del_tunnel, \
+_(gre_tunnel_add_del, \
"src <ip-addr> dst <ip-addr> [outer-fib-id <nn>] [instance <n>]\n" \
"[teb | erspan <session-id>] [del]") \
_(gre_tunnel_dump, "[<intfc> | sw_if_index <nn>]") \
+/* Hey Emacs use -*- mode: C -*- */
/*
- * Copyright (c) 2015-2016 Cisco and/or its affiliates.
+ * Copyright (c) 2015-2019 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:
* limitations under the License.
*/
-option version = "1.0.1";
+option version = "2.0.0";
-/** \brief Create or delete a GRE tunnel
+import "vnet/ip/ip_types.api";
+
+/** \brief A GRE tunnel type
+*/
+enum gre_tunnel_type
+{
+ GRE_API_TUNNEL_TYPE_L3,
+ GRE_API_TUNNEL_TYPE_TEB,
+ GRE_API_TUNNEL_TYPE_ERSPAN,
+};
+
+/** \brief A GRE tunnel
@param client_index - opaque cookie to identify the sender
@param context - sender context, to match reply w/ request
- @param is_add - Use 1 to create the tunnel, 0 to remove it
- @param is_ipv6 - Use 0 for IPv4, 1 for IPv6
@param tunnel_type - 0: L3, 1: TEB, 2: ERSPAN
@param instance - optional unique custom device instance, else ~0.
- @param src_address - Source IP address
- @param dst_address - Destination IP address, can be multicast
+ @param src - Source IP address
+ @param dst - Destination IP address, can be multicast
@param outer_fib_id - Encap FIB table ID
@param session_id - session for ERSPAN tunnel, range 0-1023
+ @param sw_if_index - ignored on create/delete, present in details.
*/
-define gre_add_del_tunnel
+typedef gre_tunnel
{
u32 client_index;
u32 context;
u8 is_add;
u8 is_ipv6;
- u8 tunnel_type;
- u32 instance; /* If non-~0, specifies a custom dev instance */
- u8 src_address[16];
- u8 dst_address[16];
- u32 outer_fib_id;
u16 session_id;
+ vl_api_gre_tunnel_type_t type;
+ u32 instance;
+ u32 outer_fib_id;
+ u32 sw_if_index;
+ vl_api_address_t src;
+ vl_api_address_t dst;
+};
+
+define gre_tunnel_add_del
+{
+ u32 client_index;
+ u32 context;
+ u8 is_add;
+ vl_api_gre_tunnel_t tunnel;
};
-define gre_add_del_tunnel_reply
+define gre_tunnel_add_del_reply
{
u32 context;
i32 retval;
define gre_tunnel_details
{
u32 context;
- u32 sw_if_index;
- u32 instance;
- u8 is_ipv6;
- u8 tunnel_type;
- u8 src_address[16];
- u8 dst_address[16];
- u32 outer_fib_id;
- u16 session_id;
+ vl_api_gre_tunnel_t tunnel;
};
/*
* receiving ERSPAN packets from a GRE ERSPAN tunnel in VPP.
*/
GRE_TUNNEL_TYPE_ERSPAN = 2,
-
- GRE_TUNNEL_TYPE_N
} gre_tunnel_type_t;
+#define GRE_TUNNEL_TYPE_N (GRE_TUNNEL_TYPE_ERSPAN + 1)
+
#define GRE_TUNNEL_TYPE_NAMES { \
[GRE_TUNNEL_TYPE_L3] = "L3", \
[GRE_TUNNEL_TYPE_TEB] = "TEB", \
typedef struct
{
u8 is_add;
- u8 tunnel_type;
+ gre_tunnel_type_t type;
u8 is_ipv6;
u32 instance;
ip46_address_t src, dst;
u32 outer_fib_id;
u16 session_id;
-} vnet_gre_add_del_tunnel_args_t;
+} vnet_gre_tunnel_add_del_args_t;
-int vnet_gre_add_del_tunnel
- (vnet_gre_add_del_tunnel_args_t * a, u32 * sw_if_indexp);
+extern int vnet_gre_tunnel_add_del (vnet_gre_tunnel_add_del_args_t * a,
+ u32 * sw_if_indexp);
static inline void
gre_mk_key4 (ip4_address_t src,
#include <vnet/gre/gre.h>
#include <vnet/fib/fib_table.h>
+#include <vnet/ip/ip_types_api.h>
#include <vnet/vnet_msg_enum.h>
#include <vlibapi/api_helper_macros.h>
#define foreach_vpe_api_msg \
-_(GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel) \
+_(GRE_TUNNEL_ADD_DEL, gre_tunnel_add_del) \
_(GRE_TUNNEL_DUMP, gre_tunnel_dump)
-static void vl_api_gre_add_del_tunnel_t_handler
- (vl_api_gre_add_del_tunnel_t * mp)
+static int
+gre_tunnel_type_decode (vl_api_gre_tunnel_type_t in, gre_tunnel_type_t * out)
{
- vl_api_gre_add_del_tunnel_reply_t *rmp;
- int rv = 0;
- vnet_gre_add_del_tunnel_args_t _a, *a = &_a;
- u32 sw_if_index = ~0;
+ in = clib_net_to_host_u32 (in);
- /* Check src & dst are different */
- if ((mp->is_ipv6 && memcmp (mp->src_address, mp->dst_address, 16) == 0) ||
- (!mp->is_ipv6 && memcmp (mp->src_address, mp->dst_address, 4) == 0))
+ switch (in)
{
- rv = VNET_API_ERROR_SAME_SRC_DST;
- goto out;
+ case GRE_API_TUNNEL_TYPE_L3:
+ *out = GRE_TUNNEL_TYPE_L3;
+ return (0);
+ case GRE_API_TUNNEL_TYPE_TEB:
+ *out = GRE_TUNNEL_TYPE_TEB;
+ return (0);
+ case GRE_API_TUNNEL_TYPE_ERSPAN:
+ *out = GRE_TUNNEL_TYPE_ERSPAN;
+ return (0);
}
- clib_memset (a, 0, sizeof (*a));
- a->is_add = mp->is_add;
- a->tunnel_type = mp->tunnel_type;
- a->is_ipv6 = mp->is_ipv6;
- a->instance = ntohl (mp->instance);
- a->session_id = ntohs (mp->session_id);
+ return (VNET_API_ERROR_INVALID_VALUE);
+}
+
+static vl_api_gre_tunnel_type_t
+gre_tunnel_type_encode (gre_tunnel_type_t in)
+{
+ vl_api_gre_tunnel_type_t out = GRE_API_TUNNEL_TYPE_L3;
- /* ip addresses sent in network byte order */
- if (!mp->is_ipv6)
+ switch (in)
{
- clib_memcpy (&(a->src.ip4), mp->src_address, 4);
- clib_memcpy (&(a->dst.ip4), mp->dst_address, 4);
+ case GRE_TUNNEL_TYPE_L3:
+ out = GRE_API_TUNNEL_TYPE_L3;
+ break;
+ case GRE_TUNNEL_TYPE_TEB:
+ out = GRE_API_TUNNEL_TYPE_TEB;
+ break;
+ case GRE_TUNNEL_TYPE_ERSPAN:
+ out = GRE_API_TUNNEL_TYPE_ERSPAN;
+ break;
}
- else
+
+ out = clib_net_to_host_u32 (out);
+
+ return (out);
+}
+
+static void vl_api_gre_tunnel_add_del_t_handler
+ (vl_api_gre_tunnel_add_del_t * mp)
+{
+ vnet_gre_tunnel_add_del_args_t _a = { }, *a = &_a;
+ vl_api_gre_tunnel_add_del_reply_t *rmp;
+ u32 sw_if_index = ~0;
+ ip46_type_t itype[2];
+ int rv = 0;
+
+ itype[0] = ip_address_decode (&mp->tunnel.src, &a->src);
+ itype[1] = ip_address_decode (&mp->tunnel.dst, &a->dst);
+
+ if (itype[0] != itype[1])
{
- clib_memcpy (&(a->src.ip6), mp->src_address, 16);
- clib_memcpy (&(a->dst.ip6), mp->dst_address, 16);
+ rv = VNET_API_ERROR_INVALID_PROTOCOL;
+ goto out;
}
- a->outer_fib_id = ntohl (mp->outer_fib_id);
- rv = vnet_gre_add_del_tunnel (a, &sw_if_index);
+ if (ip46_address_is_equal (&a->src, &a->dst))
+ {
+ rv = VNET_API_ERROR_SAME_SRC_DST;
+ goto out;
+ }
+
+ rv = gre_tunnel_type_decode (mp->tunnel.type, &a->type);
+
+ if (rv)
+ goto out;
+
+ a->is_add = mp->is_add;
+ a->is_ipv6 = (itype[0] == IP46_TYPE_IP6);
+ a->instance = ntohl (mp->tunnel.instance);
+ a->session_id = ntohs (mp->tunnel.session_id);
+ a->outer_fib_id = ntohl (mp->tunnel.outer_fib_id);
+
+ rv = vnet_gre_tunnel_add_del (a, &sw_if_index);
out:
/* *INDENT-OFF* */
- REPLY_MACRO2(VL_API_GRE_ADD_DEL_TUNNEL_REPLY,
+ REPLY_MACRO2(VL_API_GRE_TUNNEL_ADD_DEL_REPLY,
({
rmp->sw_if_index = ntohl (sw_if_index);
}));
(gre_tunnel_t * t, vl_api_registration_t * reg, u32 context)
{
vl_api_gre_tunnel_details_t *rmp;
- u8 is_ipv6 = t->tunnel_dst.fp_proto == FIB_PROTOCOL_IP6 ? 1 : 0;
- fib_table_t *ft;
rmp = vl_msg_api_alloc (sizeof (*rmp));
clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = htons (VL_API_GRE_TUNNEL_DETAILS);
- if (!is_ipv6)
- {
- clib_memcpy (rmp->src_address, &(t->tunnel_src.ip4.as_u8), 4);
- clib_memcpy (rmp->dst_address, &(t->tunnel_dst.fp_addr.ip4.as_u8), 4);
- ft = fib_table_get (t->outer_fib_index, FIB_PROTOCOL_IP4);
- rmp->outer_fib_id = htonl (ft->ft_table_id);
- }
- else
- {
- clib_memcpy (rmp->src_address, &(t->tunnel_src.ip6.as_u8), 16);
- clib_memcpy (rmp->dst_address, &(t->tunnel_dst.fp_addr.ip6.as_u8), 16);
- ft = fib_table_get (t->outer_fib_index, FIB_PROTOCOL_IP6);
- rmp->outer_fib_id = htonl (ft->ft_table_id);
- }
- rmp->tunnel_type = t->type;
- rmp->instance = htonl (t->user_instance);
- rmp->sw_if_index = htonl (t->sw_if_index);
- rmp->session_id = htons (t->session_id);
+
+ ip_address_encode (&t->tunnel_src, IP46_TYPE_ANY, &rmp->tunnel.src);
+ ip_address_encode (&t->tunnel_dst.fp_addr, IP46_TYPE_ANY, &rmp->tunnel.dst);
+
+ rmp->tunnel.outer_fib_id =
+ htonl (fib_table_get_table_id
+ (t->outer_fib_index, t->tunnel_dst.fp_proto));
+
+ rmp->tunnel.type = gre_tunnel_type_encode (t->type);
+ rmp->tunnel.instance = htonl (t->user_instance);
+ rmp->tunnel.sw_if_index = htonl (t->sw_if_index);
+ rmp->tunnel.session_id = htons (t->session_id);
rmp->context = context;
- rmp->is_ipv6 = is_ipv6;
vl_api_send_msg (reg, (u8 *) rmp);
}
}
static gre_tunnel_t *
-gre_tunnel_db_find (const vnet_gre_add_del_tunnel_args_t * a,
+gre_tunnel_db_find (const vnet_gre_tunnel_add_del_args_t * a,
u32 outer_fib_index, gre_tunnel_key_t * key)
{
gre_main_t *gm = &gre_main;
if (!a->is_ipv6)
{
gre_mk_key4 (a->src.ip4, a->dst.ip4, outer_fib_index,
- a->tunnel_type, a->session_id, &key->gtk_v4);
+ a->type, a->session_id, &key->gtk_v4);
p = hash_get_mem (gm->tunnel_by_key4, &key->gtk_v4);
}
else
{
gre_mk_key6 (&a->src.ip6, &a->dst.ip6, outer_fib_index,
- a->tunnel_type, a->session_id, &key->gtk_v6);
+ a->type, a->session_id, &key->gtk_v6);
p = hash_get_mem (gm->tunnel_by_key6, &key->gtk_v6);
}
}
static int
-vnet_gre_tunnel_add (vnet_gre_add_del_tunnel_args_t * a,
+vnet_gre_tunnel_add (vnet_gre_tunnel_add_del_args_t * a,
u32 outer_fib_index, u32 * sw_if_indexp)
{
gre_main_t *gm = &gre_main;
t->dev_instance = t_idx; /* actual */
t->user_instance = u_idx; /* name */
- t->type = a->tunnel_type;
+ t->type = a->type;
if (t->type == GRE_TUNNEL_TYPE_ERSPAN)
t->session_id = a->session_id;
}
static int
-vnet_gre_tunnel_delete (vnet_gre_add_del_tunnel_args_t * a,
+vnet_gre_tunnel_delete (vnet_gre_tunnel_add_del_args_t * a,
u32 outer_fib_index, u32 * sw_if_indexp)
{
gre_main_t *gm = &gre_main;
}
int
-vnet_gre_add_del_tunnel (vnet_gre_add_del_tunnel_args_t * a,
+vnet_gre_tunnel_add_del (vnet_gre_tunnel_add_del_args_t * a,
u32 * sw_if_indexp)
{
u32 outer_fib_index;
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- vnet_gre_add_del_tunnel_args_t _a, *a = &_a;
+ vnet_gre_tunnel_add_del_args_t _a, *a = &_a;
ip46_address_t src, dst;
u32 instance = ~0;
u32 outer_fib_id = 0;
clib_memset (a, 0, sizeof (*a));
a->is_add = is_add;
a->outer_fib_id = outer_fib_id;
- a->tunnel_type = t_type;
+ a->type = t_type;
a->session_id = session_id;
a->is_ipv6 = ipv6_set;
a->instance = instance;
clib_memcpy (&a->dst.ip6, &dst.ip6, sizeof (dst.ip6));
}
- rv = vnet_gre_add_del_tunnel (a, &sw_if_index);
+ rv = vnet_gre_tunnel_add_del (a, &sw_if_index);
switch (rv)
{
goto done;
default:
error =
- clib_error_return (0, "vnet_gre_add_del_tunnel returned %d", rv);
+ clib_error_return (0, "vnet_gre_tunnel_add_del returned %d", rv);
goto done;
}
FINISH;
}
-static void *vl_api_gre_add_del_tunnel_t_print
- (vl_api_gre_add_del_tunnel_t * mp, void *handle)
+static void *vl_api_gre_tunnel_add_del_t_print
+ (vl_api_gre_tunnel_add_del_t * mp, void *handle)
{
u8 *s;
- ip46_address_t src = to_ip46 (mp->is_ipv6, mp->src_address);
- ip46_address_t dst = to_ip46 (mp->is_ipv6, mp->dst_address);
- s = format (0, "SCRIPT: gre_add_del_tunnel ");
+ s = format (0, "SCRIPT: gre_tunnel_add_del ");
- s = format (s, "dst %U ", format_ip46_address, &dst, IP46_TYPE_ANY);
- s = format (s, "src %U ", format_ip46_address, &src, IP46_TYPE_ANY);
+ s = format (s, "dst %U ", format_vl_api_address, &mp->tunnel.dst);
+ s = format (s, "src %U ", format_vl_api_address, &mp->tunnel.src);
- s = format (s, "instance %d ", ntohl (mp->instance));
+ s = format (s, "instance %d ", ntohl (mp->tunnel.instance));
- if (mp->tunnel_type == GRE_TUNNEL_TYPE_TEB)
+ if (mp->tunnel.type == GRE_TUNNEL_TYPE_TEB)
s = format (s, "teb ");
- if (mp->tunnel_type == GRE_TUNNEL_TYPE_ERSPAN)
- s = format (s, "erspan %d ", ntohs (mp->session_id));
+ if (mp->tunnel.type == GRE_TUNNEL_TYPE_ERSPAN)
+ s = format (s, "erspan %d ", ntohs (mp->tunnel.session_id));
- if (mp->outer_fib_id)
- s = format (s, "outer-fib-id %d ", ntohl (mp->outer_fib_id));
+ if (mp->tunnel.outer_fib_id)
+ s = format (s, "outer-fib-id %d ", ntohl (mp->tunnel.outer_fib_id));
if (mp->is_add == 0)
s = format (s, "del ");
_(VXLAN_OFFLOAD_RX, vxlan_offload_rx) \
_(GENEVE_ADD_DEL_TUNNEL, geneve_add_del_tunnel) \
_(GENEVE_TUNNEL_DUMP, geneve_tunnel_dump) \
-_(GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel) \
+_(GRE_TUNNEL_ADD_DEL, gre_tunnel_add_del) \
_(GRE_TUNNEL_DUMP, gre_tunnel_dump) \
_(L2_FIB_CLEAR_TABLE, l2_fib_clear_table) \
_(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \
from framework import VppTestCase, VppTestRunner
from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint
-from vpp_gre_interface import VppGreInterface, VppGre6Interface
+from vpp_gre_interface import VppGreInterface
from vpp_ip import DpoProto
from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
from util import ppp, ppc
-
-
-class GreTunnelTypes:
- TT_L3 = 0
- TT_TEB = 1
- TT_ERSPAN = 2
+from vpp_papi import VppEnum
class TestGRE(VppTestCase):
# - assign an IP Address
# - Add a route via the tunnel
#
- gre_if = VppGre6Interface(self,
- self.pg2.local_ip6,
- "1002::1")
+ gre_if = VppGreInterface(self,
+ self.pg2.local_ip6,
+ "1002::1")
gre_if.add_vpp_config()
gre_if.admin_up()
gre_if.config_ip6()
#
gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
"2.2.2.2",
- type=GreTunnelTypes.TT_TEB)
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_TEB))
gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
"2.2.2.3",
- type=GreTunnelTypes.TT_TEB)
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_TEB))
gre_if1.add_vpp_config()
gre_if2.add_vpp_config()
from framework import VppTestCase, VppTestRunner
from util import ppp, fragment_rfc791, fragment_rfc8200
-from vpp_gre_interface import VppGreInterface, VppGre6Interface
+from vpp_gre_interface import VppGreInterface
from vpp_ip import DpoProto
from vpp_ip_route import VppIpRoute, VppRoutePath
# it shared for multiple test cases
self.tun_ip6 = "1002::1"
- self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6)
+ self.gre6 = VppGreInterface(self, self.src_if.local_ip6, self.tun_ip6)
self.gre6.add_vpp_config()
self.gre6.admin_up()
self.gre6.config_ip6()
from framework import VppTestCase, VppTestRunner
from util import Host, ppp
from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint, VppDot1ADSubint
-from vpp_gre_interface import VppGreInterface, VppGre6Interface
+from vpp_gre_interface import VppGreInterface
from collections import namedtuple
+from vpp_papi import VppEnum
+
Tag = namedtuple('Tag', ['dot1', 'vlan'])
DOT1AD = 0x88A8
gre_if = VppGreInterface(self, self.pg2.local_ip4,
self.pg2.remote_ip4,
- type=2,
- session=543)
+ session=543,
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_ERSPAN))
gre_if.add_vpp_config()
gre_if.admin_up()
gre_if = VppGreInterface(self, self.pg2.local_ip4,
self.pg2.remote_ip4,
- type=1)
+ type=(VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_TEB))
gre_if.add_vpp_config()
gre_if.admin_up()
from vpp_interface import VppInterface
import socket
+from vpp_papi import VppEnum
class VppGreInterface(VppInterface):
VPP GRE interface
"""
- def __init__(self, test, src_ip, dst_ip, outer_fib_id=0, type=0,
+ def __init__(self, test, src_ip, dst_ip, outer_fib_id=0, type=None,
session=0):
""" Create VPP GRE interface """
super(VppGreInterface, self).__init__(test)
self.t_src = src_ip
self.t_dst = dst_ip
self.t_outer_fib = outer_fib_id
- self.t_type = type
self.t_session = session
+ self.t_type = type
+ if not self.t_type:
+ self.t_type = (VppEnum.vl_api_gre_tunnel_type_t.
+ GRE_API_TUNNEL_TYPE_L3)
def add_vpp_config(self):
- s = socket.inet_pton(socket.AF_INET, self.t_src)
- d = socket.inet_pton(socket.AF_INET, self.t_dst)
- r = self.test.vapi.gre_add_del_tunnel(s, d,
+ r = self.test.vapi.gre_tunnel_add_del(self.t_src,
+ self.t_dst,
outer_fib_id=self.t_outer_fib,
tunnel_type=self.t_type,
session_id=self.t_session)
self.test.registry.register(self, self.test.logger)
def remove_vpp_config(self):
- s = socket.inet_pton(socket.AF_INET, self.t_src)
- d = socket.inet_pton(socket.AF_INET, self.t_dst)
self.unconfig()
- self.test.vapi.gre_add_del_tunnel(s, d,
+ self.test.vapi.gre_tunnel_add_del(self.t_src,
+ self.t_dst,
outer_fib_id=self.t_outer_fib,
tunnel_type=self.t_type,
session_id=self.t_session,
def object_id(self):
return "gre-%d" % self.sw_if_index
-
-class VppGre6Interface(VppInterface):
- """
- VPP GRE IPv6 interface
- """
-
- def __init__(self, test, src_ip, dst_ip, outer_fib_id=0, type=0,
- session=0):
- """ Create VPP GRE interface """
- super(VppGre6Interface, self).__init__(test)
- self.t_src = src_ip
- self.t_dst = dst_ip
- self.t_outer_fib = outer_fib_id
- self.t_type = type
- self.t_session = session
-
- def add_vpp_config(self):
- s = socket.inet_pton(socket.AF_INET6, self.t_src)
- d = socket.inet_pton(socket.AF_INET6, self.t_dst)
- r = self.test.vapi.gre_add_del_tunnel(s, d,
- outer_fib_id=self.t_outer_fib,
- tunnel_type=self.t_type,
- session_id=self.t_session,
- is_ip6=1)
- self.set_sw_if_index(r.sw_if_index)
- self.generate_remote_hosts()
- self.test.registry.register(self, self.test.logger)
-
- def remove_vpp_config(self):
- s = socket.inet_pton(socket.AF_INET6, self.t_src)
- d = socket.inet_pton(socket.AF_INET6, self.t_dst)
- self.unconfig()
- self.test.vapi.gre_add_del_tunnel(s, d,
- outer_fib_id=self.t_outer_fib,
- tunnel_type=self.t_type,
- session_id=self.t_session,
- is_add=0,
- is_ip6=1)
-
- def object_id(self):
- return "gre-%d" % self._sw_if_index
+ def query_vpp_config(self):
+ return (self.test.vapi.gre_tunnel_dump(
+ sw_if_index=self._sw_if_index))
'gbp_subnet_add_del': {'sw_if_index': 4294967295, 'epg_id': 65535, },
'geneve_add_del_tunnel': {'mcast_sw_if_index': 4294967295, 'is_add': 1,
'decap_next_index': 4294967295, },
- 'gre_add_del_tunnel': {'instance': 4294967295, 'is_add': 1, },
+ 'gre_tunnel_add_del': {'instance': 4294967295, 'is_add': 1, },
'gtpu_add_del_tunnel': {'is_add': 1, 'mcast_sw_if_index': 4294967295,
'decap_next_index': 4294967295, },
'input_acl_set_interface': {'ip4_table_index': 4294967295,
}
)
- def gre_add_del_tunnel(self,
- src_address,
- dst_address,
+ def gre_tunnel_add_del(self,
+ src,
+ dst,
outer_fib_id=0,
tunnel_type=0,
instance=0xFFFFFFFF,
session_id=0,
- is_add=1,
- is_ip6=0):
+ is_add=1):
""" Add a GRE tunnel
:param src_address:
"""
return self.api(
- self.papi.gre_add_del_tunnel,
+ self.papi.gre_tunnel_add_del,
{'is_add': is_add,
- 'is_ipv6': is_ip6,
- 'tunnel_type': tunnel_type,
- 'instance': instance,
- 'src_address': src_address,
- 'dst_address': dst_address,
- 'outer_fib_id': outer_fib_id,
- 'session_id': session_id}
+ 'tunnel':
+ {
+ 'type': tunnel_type,
+ 'instance': instance,
+ 'src': src,
+ 'dst': dst,
+ 'outer_fib_id': outer_fib_id,
+ 'session_id': session_id}
+ }
)
def udp_encap_add(self,
Code Review / vpp.git / commitdiff