*/
#include <vnet/fib/fib_table.h>
+#include <vnet/fib/fib_entry_track.h>
#include <vnet/fib/ip6_fib.h>
#include <vnet/adj/adj.h>
-#include <map/map_dpo.h>
#include <vppinfra/crc32.h>
#include <vnet/plugin/plugin.h>
#include <vpp/app/version.h>
/*
* This code supports MAP-T:
*
- * With DMR prefix length equal to 96.
+ * With a DMR prefix length of 64 or 96 (RFC6052).
*
*/
+/*
+ * Save user-assigned MAP domain names ("tags") in a vector of
+ * extra domain information.
+ */
+static void
+map_save_extras (u32 map_domain_index, u8 * tag)
+{
+ map_main_t *mm = &map_main;
+ map_domain_extra_t *de;
+
+ if (map_domain_index == ~0)
+ return;
+
+ vec_validate (mm->domain_extras, map_domain_index);
+ de = vec_elt_at_index (mm->domain_extras, map_domain_index);
+ clib_memset (de, 0, sizeof (*de));
+
+ if (!tag)
+ return;
+
+ de->tag = vec_dup (tag);
+}
+
+
+static void
+map_free_extras (u32 map_domain_index)
+{
+ map_main_t *mm = &map_main;
+ map_domain_extra_t *de;
+ u8 *tag;
+
+ if (map_domain_index == ~0)
+ return;
+
+ de = vec_elt_at_index (mm->domain_extras, map_domain_index);
+ tag = de->tag;
+ if (!tag)
+ return;
+
+ vec_free (tag);
+ de->tag = 0;
+}
+
int
map_create_domain (ip4_address_t * ip4_prefix,
u8 ip6_src_len,
u8 ea_bits_len,
u8 psid_offset,
- u8 psid_length, u32 * map_domain_index, u16 mtu, u8 flags)
+ u8 psid_length,
+ u32 * map_domain_index, u16 mtu, u8 flags, u8 * tag)
{
u8 suffix_len, suffix_shift;
map_main_t *mm = &map_main;
- dpo_id_t dpo_v4 = DPO_INVALID;
- dpo_id_t dpo_v6 = DPO_INVALID;
map_domain_t *d;
- /* Sanity check on the src prefix length */
- if (flags & MAP_DOMAIN_TRANSLATION)
- {
- if (ip6_src_len != 96)
- {
- clib_warning ("MAP-T only supports ip6_src_len = 96 for now.");
- return -1;
- }
- if ((flags & MAP_DOMAIN_RFC6052) && ip6_prefix_len != 96)
- {
- clib_warning ("RFC6052 translation only supports ip6_prefix_len = "
- "96 for now");
- return -1;
- }
- }
- else
- {
- if (ip6_src_len != 128)
- {
- clib_warning
- ("MAP-E requires a BR address, not a prefix (ip6_src_len should "
- "be 128).");
- return -1;
- }
- }
-
/* How many, and which bits to grab from the IPv4 DA */
if (ip4_prefix_len + ea_bits_len < 32)
{
- if (!(flags & MAP_DOMAIN_TRANSLATION))
- flags |= MAP_DOMAIN_PREFIX;
+ flags |= MAP_DOMAIN_PREFIX;
suffix_shift = 32 - ip4_prefix_len - ea_bits_len;
suffix_len = ea_bits_len;
}
return -1;
}
- if (mm->is_ce && !(flags & MAP_DOMAIN_TRANSLATION))
- {
- clib_warning ("MAP-E CE is not supported yet");
- return -1;
- }
-
/* Get domain index */
pool_get_aligned (mm->domains, d, CLIB_CACHE_LINE_BYTES);
- memset (d, 0, sizeof (*d));
+ clib_memset (d, 0, sizeof (*d));
*map_domain_index = d - mm->domains;
/* Init domain struct */
d->psid_mask = (1 << d->psid_length) - 1;
d->ea_shift = 64 - ip6_prefix_len - suffix_len - d->psid_length;
- /* MAP data-plane object */
- if (d->flags & MAP_DOMAIN_TRANSLATION)
- map_t_dpo_create (DPO_PROTO_IP4, *map_domain_index, &dpo_v4);
- else
- map_dpo_create (DPO_PROTO_IP4, *map_domain_index, &dpo_v4);
-
- /* Create ip4 route */
- u8 ip4_pfx_len;
- ip4_address_t ip4_pfx;
- if (mm->is_ce)
- {
- ip4_pfx_len = 0;
- ip4_pfx.as_u32 = 0;
- }
- else
- {
- ip4_pfx_len = d->ip4_prefix_len;
- ip4_pfx = d->ip4_prefix;
- }
- fib_prefix_t pfx = {
- .fp_proto = FIB_PROTOCOL_IP4,
- .fp_len = ip4_pfx_len,
- .fp_addr = {
- .ip4 = ip4_pfx,
- }
- ,
- };
- fib_table_entry_special_dpo_add (0, &pfx,
- FIB_SOURCE_MAP,
- FIB_ENTRY_FLAG_EXCLUSIVE, &dpo_v4);
- dpo_reset (&dpo_v4);
-
- /*
- * construct a DPO to use the v6 domain
- */
- if (d->flags & MAP_DOMAIN_TRANSLATION)
- map_t_dpo_create (DPO_PROTO_IP6, *map_domain_index, &dpo_v6);
- else
- map_dpo_create (DPO_PROTO_IP6, *map_domain_index, &dpo_v6);
+ /* Save a user-assigned MAP domain name if provided. */
+ if (tag)
+ map_save_extras (*map_domain_index, tag);
- /*
- * Multiple MAP domains may share same source IPv6 TEP. Which is just dandy.
- * We are not tracking the sharing. So a v4 lookup to find the correct
- * domain post decap/trnaslate is always done
- *
- * Create ip6 route. This is a reference counted add. If the prefix
- * already exists and is MAP sourced, it is now MAP source n+1 times
- * and will need to be removed n+1 times.
- */
- u8 ip6_pfx_len;
- ip6_address_t ip6_pfx;
- if (mm->is_ce)
- {
- ip6_pfx_len = d->ip6_prefix_len;
- ip6_pfx = d->ip6_prefix;
- }
- else
- {
- ip6_pfx_len = d->ip6_src_len;
- ip6_pfx = d->ip6_src;
- }
- fib_prefix_t pfx6 = {
- .fp_proto = FIB_PROTOCOL_IP6,
- .fp_len = ip6_pfx_len,
- .fp_addr.ip6 = ip6_pfx,
- };
+ /* MAP longest match lookup table (input feature / FIB) */
+ mm->ip4_prefix_tbl->add (mm->ip4_prefix_tbl, &d->ip4_prefix,
+ d->ip4_prefix_len, *map_domain_index);
- fib_table_entry_special_dpo_add (0, &pfx6,
- FIB_SOURCE_MAP,
- FIB_ENTRY_FLAG_EXCLUSIVE, &dpo_v6);
- dpo_reset (&dpo_v6);
+ /* Really needed? Or always use FIB? */
+ mm->ip6_src_prefix_tbl->add (mm->ip6_src_prefix_tbl, &d->ip6_src,
+ d->ip6_src_len, *map_domain_index);
/* Validate packet/byte counters */
map_domain_counter_lock (mm);
}
d = pool_elt_at_index (mm->domains, map_domain_index);
+ mm->ip4_prefix_tbl->delete (mm->ip4_prefix_tbl, &d->ip4_prefix,
+ d->ip4_prefix_len);
+ mm->ip6_src_prefix_tbl->delete (mm->ip6_src_prefix_tbl, &d->ip6_src,
+ d->ip6_src_len);
- fib_prefix_t pfx = {
- .fp_proto = FIB_PROTOCOL_IP4,
- .fp_len = d->ip4_prefix_len,
- .fp_addr = {
- .ip4 = d->ip4_prefix,
- }
- ,
- };
- fib_table_entry_special_remove (0, &pfx, FIB_SOURCE_MAP);
-
- fib_prefix_t pfx6 = {
- .fp_proto = FIB_PROTOCOL_IP6,
- .fp_len = d->ip6_src_len,
- .fp_addr = {
- .ip6 = d->ip6_src,
- }
- ,
- };
- fib_table_entry_special_remove (0, &pfx6, FIB_SOURCE_MAP);
+ /* Release user-assigned MAP domain name. */
+ map_free_extras (map_domain_index);
/* Deleting rules */
if (d->rules)
int
map_add_del_psid (u32 map_domain_index, u16 psid, ip6_address_t * tep,
- u8 is_add)
+ bool is_add)
{
map_domain_t *d;
map_main_t *mm = &map_main;
d->rules = clib_mem_alloc_aligned (l, CLIB_CACHE_LINE_BYTES);
if (!d->rules)
return -1;
- memset (d->rules, 0, l);
+ clib_memset (d->rules, 0, l);
}
if (psid >= (0x1 << d->psid_length))
}
else
{
- memset (&d->rules[psid], 0, sizeof (ip6_address_t));
+ clib_memset (&d->rules[psid], 0, sizeof (ip6_address_t));
}
return 0;
}
#ifdef MAP_SKIP_IP6_LOOKUP
/**
- * Pre-resolvd per-protocol global next-hops
+ * Pre-resolved per-protocol global next-hops
*/
map_main_pre_resolved_t pre_resolved[FIB_PROTOCOL_MAX];
if (FIB_NODE_INDEX_INVALID != pr->fei)
{
- fib_prefix_t pfx;
+ const fib_prefix_t *pfx;
- fib_entry_get_prefix (pr->fei, &pfx);
+ pfx = fib_entry_get_prefix (pr->fei);
return (format (s, "%U (%u)",
- format_ip46_address, &pfx.fp_addr, IP46_TYPE_ANY,
+ format_ip46_address, &pfx->fp_addr, IP46_TYPE_ANY,
pr->dpo.dpoi_index));
}
else
.fp_addr = *addr,
};
- pr->fei = fib_table_entry_special_add (0, // default fib
- &pfx,
- FIB_SOURCE_RR, FIB_ENTRY_FLAG_NONE);
- pr->sibling = fib_entry_child_add (pr->fei, FIB_NODE_TYPE_MAP_E, proto);
+ pr->fei = fib_entry_track (0, // default fib
+ &pfx, FIB_NODE_TYPE_MAP_E, proto, &pr->sibling);
map_stack (pr);
}
map_fib_unresolve (map_main_pre_resolved_t * pr,
fib_protocol_t proto, u8 len, const ip46_address_t * addr)
{
- fib_prefix_t pfx = {
- .fp_proto = proto,
- .fp_len = len,
- .fp_addr = *addr,
- };
-
- fib_entry_child_remove (pr->fei, pr->sibling);
+ if (pr->fei != FIB_NODE_INDEX_INVALID)
+ {
+ fib_entry_untrack (pr->fei, pr->sibling);
- fib_table_entry_special_remove (0, // default fib
- &pfx, FIB_SOURCE_RR);
- dpo_reset (&pr->dpo);
+ dpo_reset (&pr->dpo);
- pr->fei = FIB_NODE_INDEX_INVALID;
- pr->sibling = FIB_NODE_INDEX_INVALID;
+ pr->fei = FIB_NODE_INDEX_INVALID;
+ pr->sibling = FIB_NODE_INDEX_INVALID;
+ }
}
-static void
-map_pre_resolve (ip4_address_t * ip4, ip6_address_t * ip6, int is_del)
+void
+map_pre_resolve (ip4_address_t * ip4, ip6_address_t * ip6, bool is_del)
{
if (ip6 && (ip6->as_u64[0] != 0 || ip6->as_u64[1] != 0))
{
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
clib_error_t *error = NULL;
+ bool enable = false;
+ bool check_frag = false;
+ bool saw_enable = false;
+ bool saw_frag = false;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (line_input, "off"))
- mm->sec_check = false;
- else if (unformat (line_input, "on"))
- mm->sec_check = true;
+ if (unformat (line_input, "enable"))
+ {
+ enable = false;
+ saw_enable = true;
+ }
+ else if (unformat (line_input, "disable"))
+ {
+ enable = true;
+ saw_enable = true;
+ }
+ else if (unformat (line_input, "fragments on"))
+ {
+ check_frag = true;
+ saw_frag = true;
+ }
+ else if (unformat (line_input, "fragments off"))
+ {
+ check_frag = false;
+ saw_frag = true;
+ }
else
{
error = clib_error_return (0, "unknown input `%U'",
}
}
-done:
- unformat_free (line_input);
-
- return error;
-}
-
-static clib_error_t *
-map_security_check_frag_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
-{
- unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
- clib_error_t *error = NULL;
-
- /* Get a line of input. */
- if (!unformat_user (input, unformat_line_input, line_input))
- return 0;
+ if (!saw_enable)
+ {
+ error = clib_error_return (0,
+ "Must specify enable 'enable' or 'disable'");
+ goto done;
+ }
- while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+ if (!saw_frag)
{
- if (unformat (line_input, "off"))
- mm->sec_check_frag = false;
- else if (unformat (line_input, "on"))
- mm->sec_check_frag = true;
- else
- {
- error = clib_error_return (0, "unknown input `%U'",
- format_unformat_error, line_input);
- goto done;
- }
+ error = clib_error_return (0, "Must specify fragments 'on' or 'off'");
+ goto done;
}
+ map_param_set_security_check (enable, check_frag);
+
done:
unformat_free (line_input);
return error;
}
+
static clib_error_t *
map_add_domain_command_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
u32 ea_bits_len = 0, psid_offset = 0, psid_length = 0;
u32 mtu = 0;
u8 flags = 0;
+ u8 *tag = 0;
ip6_src_len = 128;
clib_error_t *error = NULL;
num_m_args++;
else if (unformat (line_input, "mtu %d", &mtu))
num_m_args++;
- else if (unformat (line_input, "map-t"))
- flags |= MAP_DOMAIN_TRANSLATION;
- else if (unformat (line_input, "rfc6052"))
- flags |= (MAP_DOMAIN_TRANSLATION | MAP_DOMAIN_RFC6052);
+ else if (unformat (line_input, "tag %v", &tag))
+ ;
else
{
error = clib_error_return (0, "unknown input `%U'",
map_create_domain (&ip4_prefix, ip4_prefix_len,
&ip6_prefix, ip6_prefix_len, &ip6_src, ip6_src_len,
ea_bits_len, psid_offset, psid_length, &map_domain_index,
- mtu, flags);
+ mtu, flags, tag);
done:
unformat_free (line_input);
ip4_address_t ip4nh, *p_v4 = NULL;
ip6_address_t ip6nh, *p_v6 = NULL;
clib_error_t *error = NULL;
- int is_del = 0;
+ bool is_del = false;
- memset (&ip4nh, 0, sizeof (ip4nh));
- memset (&ip6nh, 0, sizeof (ip6nh));
+ clib_memset (&ip4nh, 0, sizeof (ip4nh));
+ clib_memset (&ip6nh, 0, sizeof (ip6nh));
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
if (unformat (line_input, "ip6-nh %U", unformat_ip6_address, &ip6nh))
p_v6 = &ip6nh;
else if (unformat (line_input, "del"))
- is_del = 1;
+ is_del = true;
else
{
error = clib_error_return (0, "unknown input `%U'",
{
unformat_input_t _line_input, *line_input = &_line_input;
ip4_address_t icmp_src_address;
+ ip4_address_t *p_icmp_addr = 0;
map_main_t *mm = &map_main;
clib_error_t *error = NULL;
{
if (unformat
(line_input, "%U", unformat_ip4_address, &icmp_src_address))
- mm->icmp4_src_address = icmp_src_address;
+ {
+ mm->icmp4_src_address = icmp_src_address;
+ p_icmp_addr = &icmp_src_address;
+ }
else
{
error = clib_error_return (0, "unknown input `%U'",
}
}
+ map_param_set_icmp (p_icmp_addr);
+
done:
unformat_free (line_input);
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
int num_m_args = 0;
clib_error_t *error = NULL;
+ bool enabled = false;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
{
num_m_args++;
if (unformat (line_input, "on"))
- mm->icmp6_enabled = true;
+ enabled = true;
else if (unformat (line_input, "off"))
- mm->icmp6_enabled = false;
+ enabled = false;
else
{
error = clib_error_return (0, "unknown input `%U'",
if (num_m_args != 1)
error = clib_error_return (0, "mandatory argument(s) missing");
+
+ map_param_set_icmp6 (enabled);
+
done:
unformat_free (line_input);
return error;
}
+
static clib_error_t *
map_fragment_command_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
clib_error_t *error = NULL;
+ bool frag_inner = false;
+ bool frag_ignore_df = false;
+ bool saw_in_out = false;
+ bool saw_df = false;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "inner"))
- mm->frag_inner = true;
+ {
+ frag_inner = true;
+ saw_in_out = true;
+ }
else if (unformat (line_input, "outer"))
- mm->frag_inner = false;
+ {
+ frag_inner = false;
+ saw_in_out = true;
+ }
+ else if (unformat (line_input, "ignore-df"))
+ {
+ frag_ignore_df = true;
+ saw_df = true;
+ }
+ else if (unformat (line_input, "honor-df"))
+ {
+ frag_ignore_df = false;
+ saw_df = true;
+ }
else
{
error = clib_error_return (0, "unknown input `%U'",
}
}
-done:
- unformat_free (line_input);
-
- return error;
-}
-
-static clib_error_t *
-map_fragment_df_command_fn (vlib_main_t * vm,
- unformat_input_t * input,
- vlib_cli_command_t * cmd)
-{
- unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
- clib_error_t *error = NULL;
-
- /* Get a line of input. */
- if (!unformat_user (input, unformat_line_input, line_input))
- return 0;
+ if (!saw_in_out)
+ {
+ error = clib_error_return (0, "Must specify 'inner' or 'outer'");
+ goto done;
+ }
- while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
+ if (!saw_df)
{
- if (unformat (line_input, "on"))
- mm->frag_ignore_df = true;
- else if (unformat (line_input, "off"))
- mm->frag_ignore_df = false;
- else
- {
- error = clib_error_return (0, "unknown input `%U'",
- format_unformat_error, line_input);
- goto done;
- }
+ error = clib_error_return (0, "Must specify 'ignore-df' or 'honor-df'");
+ goto done;
}
+ map_param_set_fragmentation (frag_inner, frag_ignore_df);
+
done:
unformat_free (line_input);
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- map_main_t *mm = &map_main;
u32 tc = 0;
clib_error_t *error = NULL;
+ bool tc_copy = false;
- mm->tc_copy = false;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "copy"))
- mm->tc_copy = true;
+ tc_copy = true;
else if (unformat (line_input, "%x", &tc))
- mm->tc = tc & 0xff;
+ tc = tc & 0xff;
else
{
error = clib_error_return (0, "unknown input `%U'",
}
}
+ map_param_set_traffic_class (tc_copy, tc);
+
done:
unformat_free (line_input);
static char *
map_flags_to_string (u32 flags)
{
- if (flags & MAP_DOMAIN_RFC6052)
- return "rfc6052";
if (flags & MAP_DOMAIN_PREFIX)
return "prefix";
- if (flags & MAP_DOMAIN_TRANSLATION)
- return "map-t";
return "";
}
bool counters = va_arg (*args, int);
map_main_t *mm = &map_main;
ip6_address_t ip6_prefix;
+ u32 map_domain_index = d - mm->domains;
+ map_domain_extra_t *de;
if (d->rules)
- memset (&ip6_prefix, 0, sizeof (ip6_prefix));
+ clib_memset (&ip6_prefix, 0, sizeof (ip6_prefix));
else
ip6_prefix = d->ip6_prefix;
+ de = vec_elt_at_index (mm->domain_extras, map_domain_index);
+
s = format (s,
- "[%d] ip4-pfx %U/%d ip6-pfx %U/%d ip6-src %U/%d ea_bits_len %d "
- "psid-offset %d psid-len %d mtu %d %s",
- d - mm->domains,
+ "[%d] tag {%v} ip4-pfx %U/%d ip6-pfx %U/%d ip6-src %U/%d "
+ "ea-bits-len %d psid-offset %d psid-len %d mtu %d %s",
+ map_domain_index, de->tag,
format_ip4_address, &d->ip4_prefix, d->ip4_prefix_len,
format_ip6_address, &ip6_prefix, d->ip6_prefix_len,
format_ip6_address, &d->ip6_src, d->ip6_src_len,
map_domain_counter_lock (mm);
vlib_counter_t v;
vlib_get_combined_counter (&mm->domain_counters[MAP_DOMAIN_COUNTER_TX],
- d - mm->domains, &v);
+ map_domain_index, &v);
s = format (s, " TX: %lld/%lld", v.packets, v.bytes);
vlib_get_combined_counter (&mm->domain_counters[MAP_DOMAIN_COUNTER_RX],
- d - mm->domains, &v);
+ map_domain_index, &v);
s = format (s, " RX: %lld/%lld", v.packets, v.bytes);
map_domain_counter_unlock (mm);
}
return s;
}
-static u8 *
-format_map_ip4_reass (u8 * s, va_list * args)
-{
- map_main_t *mm = &map_main;
- map_ip4_reass_t *r = va_arg (*args, map_ip4_reass_t *);
- map_ip4_reass_key_t *k = &r->key;
- f64 now = vlib_time_now (mm->vlib_main);
- f64 lifetime = (((f64) mm->ip4_reass_conf_lifetime_ms) / 1000);
- f64 dt = (r->ts + lifetime > now) ? (r->ts + lifetime - now) : -1;
- s = format (s,
- "ip4-reass src=%U dst=%U protocol=%d identifier=%d port=%d lifetime=%.3lf\n",
- format_ip4_address, &k->src.as_u8, format_ip4_address,
- &k->dst.as_u8, k->protocol,
- clib_net_to_host_u16 (k->fragment_id),
- (r->port >= 0) ? clib_net_to_host_u16 (r->port) : -1, dt);
- return s;
-}
-
-static u8 *
-format_map_ip6_reass (u8 * s, va_list * args)
-{
- map_main_t *mm = &map_main;
- map_ip6_reass_t *r = va_arg (*args, map_ip6_reass_t *);
- map_ip6_reass_key_t *k = &r->key;
- f64 now = vlib_time_now (mm->vlib_main);
- f64 lifetime = (((f64) mm->ip6_reass_conf_lifetime_ms) / 1000);
- f64 dt = (r->ts + lifetime > now) ? (r->ts + lifetime - now) : -1;
- s = format (s,
- "ip6-reass src=%U dst=%U protocol=%d identifier=%d lifetime=%.3lf\n",
- format_ip6_address, &k->src.as_u8, format_ip6_address,
- &k->dst.as_u8, k->protocol,
- clib_net_to_host_u32 (k->fragment_id), dt);
- return s;
-}
-
static clib_error_t *
show_map_domain_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
if (map_domain_index == ~0)
{
- /* *INDENT-OFF* */
- pool_foreach(d, mm->domains, ({vlib_cli_output(vm, "%U", format_map_domain, d, counters);}));
- /* *INDENT-ON* */
+ /* *INDENT-OFF* */
+ pool_foreach(d, mm->domains,
+ ({vlib_cli_output(vm, "%U", format_map_domain, d, counters);}));
+ /* *INDENT-ON* */
}
else
{
return error;
}
-static clib_error_t *
-show_map_fragments_command_fn (vlib_main_t * vm, unformat_input_t * input,
- vlib_cli_command_t * cmd)
-{
- map_main_t *mm = &map_main;
- map_ip4_reass_t *f4;
- map_ip6_reass_t *f6;
-
- /* *INDENT-OFF* */
- pool_foreach(f4, mm->ip4_reass_pool, ({vlib_cli_output (vm, "%U", format_map_ip4_reass, f4);}));
- /* *INDENT-ON* */
- /* *INDENT-OFF* */
- pool_foreach(f6, mm->ip6_reass_pool, ({vlib_cli_output (vm, "%U", format_map_ip6_reass, f6);}));
- /* *INDENT-ON* */
- return (0);
-}
-
u64
map_error_counter_get (u32 node_index, map_error_t map_error)
{
vlib_node_t *n = vlib_get_node (vm, node_index);
u32 ci;
- ci = vlib_error_get_code (e);
+ ci = vlib_error_get_code (&vm->node_main, e);
ASSERT (ci < n->n_errors);
ci += n->error_heap_index;
else
vlib_cli_output (vm, "MAP traffic-class: %x", mm->tc);
+ if (mm->tcp_mss)
+ vlib_cli_output (vm, "MAP TCP MSS clamping: %u", mm->tcp_mss);
+
vlib_cli_output (vm,
"MAP IPv6 inbound security check: %s, fragmented packet security check: %s",
mm->sec_check ? "enabled" : "disabled",
int which, i;
vlib_counter_t v;
- memset (total_pkts, 0, sizeof (total_pkts));
- memset (total_bytes, 0, sizeof (total_bytes));
+ clib_memset (total_pkts, 0, sizeof (total_pkts));
+ clib_memset (total_bytes, 0, sizeof (total_bytes));
map_domain_counter_lock (mm);
vec_foreach (cm, mm->domain_counters)
}
static clib_error_t *
-map_params_reass_command_fn (vlib_main_t * vm, unformat_input_t * input,
- vlib_cli_command_t * cmd)
+map_if_command_fn (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- u32 lifetime = ~0;
- f64 ht_ratio = (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1);
- u32 pool_size = ~0;
- u64 buffers = ~(0ull);
- u8 ip4 = 0, ip6 = 0;
+ clib_error_t *error = NULL;
+ bool is_enable = true, is_translation = false;
+ vnet_main_t *vnm = vnet_get_main ();
+ u32 sw_if_index = ~0;
+ /* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat (line_input, "lifetime %u", &lifetime))
- ;
- else if (unformat (line_input, "ht-ratio %lf", &ht_ratio))
- ;
- else if (unformat (line_input, "pool-size %u", &pool_size))
- ;
- else if (unformat (line_input, "buffers %llu", &buffers))
+ if (unformat
+ (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
;
- else if (unformat (line_input, "ip4"))
- ip4 = 1;
- else if (unformat (line_input, "ip6"))
- ip6 = 1;
+ else if (unformat (line_input, "del"))
+ is_enable = false;
+ else if (unformat (line_input, "map-t"))
+ is_translation = true;
else
{
- unformat_free (line_input);
- return clib_error_return (0, "invalid input");
+ error = clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, line_input);
+ goto done;
}
}
- unformat_free (line_input);
-
- if (!ip4 && !ip6)
- return clib_error_return (0, "must specify ip4 and/or ip6");
-
- if (ip4)
- {
- if (pool_size != ~0 && pool_size > MAP_IP4_REASS_CONF_POOL_SIZE_MAX)
- return clib_error_return (0, "invalid ip4-reass pool-size ( > %d)",
- MAP_IP4_REASS_CONF_POOL_SIZE_MAX);
- if (ht_ratio != (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1)
- && ht_ratio > MAP_IP4_REASS_CONF_HT_RATIO_MAX)
- return clib_error_return (0, "invalid ip4-reass ht-ratio ( > %d)",
- MAP_IP4_REASS_CONF_HT_RATIO_MAX);
- if (lifetime != ~0 && lifetime > MAP_IP4_REASS_CONF_LIFETIME_MAX)
- return clib_error_return (0, "invalid ip4-reass lifetime ( > %d)",
- MAP_IP4_REASS_CONF_LIFETIME_MAX);
- if (buffers != ~(0ull) && buffers > MAP_IP4_REASS_CONF_BUFFERS_MAX)
- return clib_error_return (0, "invalid ip4-reass buffers ( > %ld)",
- MAP_IP4_REASS_CONF_BUFFERS_MAX);
- }
- if (ip6)
- {
- if (pool_size != ~0 && pool_size > MAP_IP6_REASS_CONF_POOL_SIZE_MAX)
- return clib_error_return (0, "invalid ip6-reass pool-size ( > %d)",
- MAP_IP6_REASS_CONF_POOL_SIZE_MAX);
- if (ht_ratio != (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1)
- && ht_ratio > MAP_IP6_REASS_CONF_HT_RATIO_MAX)
- return clib_error_return (0, "invalid ip6-reass ht-log2len ( > %d)",
- MAP_IP6_REASS_CONF_HT_RATIO_MAX);
- if (lifetime != ~0 && lifetime > MAP_IP6_REASS_CONF_LIFETIME_MAX)
- return clib_error_return (0, "invalid ip6-reass lifetime ( > %d)",
- MAP_IP6_REASS_CONF_LIFETIME_MAX);
- if (buffers != ~(0ull) && buffers > MAP_IP6_REASS_CONF_BUFFERS_MAX)
- return clib_error_return (0, "invalid ip6-reass buffers ( > %ld)",
- MAP_IP6_REASS_CONF_BUFFERS_MAX);
- }
+done:
+ unformat_free (line_input);
- if (ip4)
+ if (sw_if_index == ~0)
{
- u32 reass = 0, packets = 0;
- if (pool_size != ~0)
- {
- if (map_ip4_reass_conf_pool_size (pool_size, &reass, &packets))
- {
- vlib_cli_output (vm, "Could not set ip4-reass pool-size");
- }
- else
- {
- vlib_cli_output (vm,
- "Setting ip4-reass pool-size (destroyed-reassembly=%u , dropped-fragments=%u)",
- reass, packets);
- }
- }
- if (ht_ratio != (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1))
- {
- if (map_ip4_reass_conf_ht_ratio (ht_ratio, &reass, &packets))
- {
- vlib_cli_output (vm, "Could not set ip4-reass ht-log2len");
- }
- else
- {
- vlib_cli_output (vm,
- "Setting ip4-reass ht-log2len (destroyed-reassembly=%u , dropped-fragments=%u)",
- reass, packets);
- }
- }
- if (lifetime != ~0)
- {
- if (map_ip4_reass_conf_lifetime (lifetime))
- vlib_cli_output (vm, "Could not set ip4-reass lifetime");
- else
- vlib_cli_output (vm, "Setting ip4-reass lifetime");
- }
- if (buffers != ~(0ull))
- {
- if (map_ip4_reass_conf_buffers (buffers))
- vlib_cli_output (vm, "Could not set ip4-reass buffers");
- else
- vlib_cli_output (vm, "Setting ip4-reass buffers");
- }
-
- if (map_main.ip4_reass_conf_buffers >
- map_main.ip4_reass_conf_pool_size *
- MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY)
- {
- vlib_cli_output (vm,
- "Note: 'ip4-reass buffers' > pool-size * max-fragments-per-reassembly.");
- }
+ error = clib_error_return (0, "unknown interface");
+ return error;
}
- if (ip6)
+ int rv = map_if_enable_disable (is_enable, sw_if_index, is_translation);
+ if (rv)
{
- u32 reass = 0, packets = 0;
- if (pool_size != ~0)
- {
- if (map_ip6_reass_conf_pool_size (pool_size, &reass, &packets))
- {
- vlib_cli_output (vm, "Could not set ip6-reass pool-size");
- }
- else
- {
- vlib_cli_output (vm,
- "Setting ip6-reass pool-size (destroyed-reassembly=%u , dropped-fragments=%u)",
- reass, packets);
- }
- }
- if (ht_ratio != (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1))
- {
- if (map_ip6_reass_conf_ht_ratio (ht_ratio, &reass, &packets))
- {
- vlib_cli_output (vm, "Could not set ip6-reass ht-log2len");
- }
- else
- {
- vlib_cli_output (vm,
- "Setting ip6-reass ht-log2len (destroyed-reassembly=%u , dropped-fragments=%u)",
- reass, packets);
- }
- }
- if (lifetime != ~0)
- {
- if (map_ip6_reass_conf_lifetime (lifetime))
- vlib_cli_output (vm, "Could not set ip6-reass lifetime");
- else
- vlib_cli_output (vm, "Setting ip6-reass lifetime");
- }
- if (buffers != ~(0ull))
- {
- if (map_ip6_reass_conf_buffers (buffers))
- vlib_cli_output (vm, "Could not set ip6-reass buffers");
- else
- vlib_cli_output (vm, "Setting ip6-reass buffers");
- }
-
- if (map_main.ip6_reass_conf_buffers >
- map_main.ip6_reass_conf_pool_size *
- MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY)
- {
- vlib_cli_output (vm,
- "Note: 'ip6-reass buffers' > pool-size * max-fragments-per-reassembly.");
- }
+ error = clib_error_return (0, "failure enabling MAP on interface");
}
- return 0;
+ return error;
}
return s;
}
-static_always_inline map_ip4_reass_t *
-map_ip4_reass_lookup (map_ip4_reass_key_t * k, u32 bucket, f64 now)
+static clib_error_t *
+map_tcp_mss_command_fn (vlib_main_t * vm,
+ unformat_input_t * input, vlib_cli_command_t * cmd)
{
- map_main_t *mm = &map_main;
- u32 ri = mm->ip4_reass_hash_table[bucket];
- while (ri != MAP_REASS_INDEX_NONE)
+ unformat_input_t _line_input, *line_input = &_line_input;
+ clib_error_t *error = NULL;
+ u32 tcp_mss = 0;
+
+ /* Get a line of input. */
+ if (!unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
- map_ip4_reass_t *r = pool_elt_at_index (mm->ip4_reass_pool, ri);
- if (r->key.as_u64[0] == k->as_u64[0] &&
- r->key.as_u64[1] == k->as_u64[1] &&
- now < r->ts + (((f64) mm->ip4_reass_conf_lifetime_ms) / 1000))
+ if (unformat (line_input, "%u", &tcp_mss))
+ ;
+ else
{
- return r;
+ error = clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, line_input);
+ goto done;
}
- ri = r->bucket_next;
}
- return NULL;
-}
-#define map_ip4_reass_pool_index(r) (r - map_main.ip4_reass_pool)
-
-void
-map_ip4_reass_free (map_ip4_reass_t * r, u32 ** pi_to_drop)
-{
- map_main_t *mm = &map_main;
- map_ip4_reass_get_fragments (r, pi_to_drop);
-
- // Unlink in hash bucket
- map_ip4_reass_t *r2 = NULL;
- u32 r2i = mm->ip4_reass_hash_table[r->bucket];
- while (r2i != map_ip4_reass_pool_index (r))
- {
- ASSERT (r2i != MAP_REASS_INDEX_NONE);
- r2 = pool_elt_at_index (mm->ip4_reass_pool, r2i);
- r2i = r2->bucket_next;
- }
- if (r2)
+ if (tcp_mss >= (0x1 << 16))
{
- r2->bucket_next = r->bucket_next;
+ error = clib_error_return (0, "invalid value `%u'", tcp_mss);
+ goto done;
}
- else
- {
- mm->ip4_reass_hash_table[r->bucket] = r->bucket_next;
- }
-
- // Unlink in list
- if (r->fifo_next == map_ip4_reass_pool_index (r))
- {
- mm->ip4_reass_fifo_last = MAP_REASS_INDEX_NONE;
- }
- else
- {
- if (mm->ip4_reass_fifo_last == map_ip4_reass_pool_index (r))
- mm->ip4_reass_fifo_last = r->fifo_prev;
- pool_elt_at_index (mm->ip4_reass_pool, r->fifo_prev)->fifo_next =
- r->fifo_next;
- pool_elt_at_index (mm->ip4_reass_pool, r->fifo_next)->fifo_prev =
- r->fifo_prev;
- }
-
- pool_put (mm->ip4_reass_pool, r);
- mm->ip4_reass_allocated--;
-}
-
-map_ip4_reass_t *
-map_ip4_reass_get (u32 src, u32 dst, u16 fragment_id,
- u8 protocol, u32 ** pi_to_drop)
-{
- map_ip4_reass_t *r;
- map_main_t *mm = &map_main;
- map_ip4_reass_key_t k = {.src.data_u32 = src,
- .dst.data_u32 = dst,
- .fragment_id = fragment_id,
- .protocol = protocol
- };
-
- u32 h = 0;
-#ifdef clib_crc32c_uses_intrinsics
- h = clib_crc32c ((u8 *) k.as_u32, 16);
-#else
- u64 tmp = k.as_u32[0] ^ k.as_u32[1] ^ k.as_u32[2] ^ k.as_u32[3];
- h = clib_xxhash (tmp);
-#endif
- h = h >> (32 - mm->ip4_reass_ht_log2len);
-
- f64 now = vlib_time_now (mm->vlib_main);
-
- //Cache garbage collection
- while (mm->ip4_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- map_ip4_reass_t *last =
- pool_elt_at_index (mm->ip4_reass_pool, mm->ip4_reass_fifo_last);
- if (last->ts + (((f64) mm->ip4_reass_conf_lifetime_ms) / 1000) < now)
- map_ip4_reass_free (last, pi_to_drop);
- else
- break;
- }
-
- if ((r = map_ip4_reass_lookup (&k, h, now)))
- return r;
-
- if (mm->ip4_reass_allocated >= mm->ip4_reass_conf_pool_size)
- return NULL;
-
- pool_get (mm->ip4_reass_pool, r);
- mm->ip4_reass_allocated++;
- int i;
- for (i = 0; i < MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- r->fragments[i] = ~0;
-
- u32 ri = map_ip4_reass_pool_index (r);
-
- //Link in new bucket
- r->bucket = h;
- r->bucket_next = mm->ip4_reass_hash_table[h];
- mm->ip4_reass_hash_table[h] = ri;
-
- //Link in fifo
- if (mm->ip4_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- r->fifo_next =
- pool_elt_at_index (mm->ip4_reass_pool,
- mm->ip4_reass_fifo_last)->fifo_next;
- r->fifo_prev = mm->ip4_reass_fifo_last;
- pool_elt_at_index (mm->ip4_reass_pool, r->fifo_prev)->fifo_next = ri;
- pool_elt_at_index (mm->ip4_reass_pool, r->fifo_next)->fifo_prev = ri;
- }
- else
- {
- r->fifo_next = r->fifo_prev = ri;
- mm->ip4_reass_fifo_last = ri;
- }
-
- //Set other fields
- r->ts = now;
- r->key = k;
- r->port = -1;
-#ifdef MAP_IP4_REASS_COUNT_BYTES
- r->expected_total = 0xffff;
- r->forwarded = 0;
-#endif
-
- return r;
-}
-
-int
-map_ip4_reass_add_fragment (map_ip4_reass_t * r, u32 pi)
-{
- if (map_main.ip4_reass_buffered_counter >= map_main.ip4_reass_conf_buffers)
- return -1;
-
- int i;
- for (i = 0; i < MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- if (r->fragments[i] == ~0)
- {
- r->fragments[i] = pi;
- map_main.ip4_reass_buffered_counter++;
- return 0;
- }
- return -1;
-}
-
-static_always_inline map_ip6_reass_t *
-map_ip6_reass_lookup (map_ip6_reass_key_t * k, u32 bucket, f64 now)
-{
- map_main_t *mm = &map_main;
- u32 ri = mm->ip6_reass_hash_table[bucket];
- while (ri != MAP_REASS_INDEX_NONE)
- {
- map_ip6_reass_t *r = pool_elt_at_index (mm->ip6_reass_pool, ri);
- if (now < r->ts + (((f64) mm->ip6_reass_conf_lifetime_ms) / 1000) &&
- r->key.as_u64[0] == k->as_u64[0] &&
- r->key.as_u64[1] == k->as_u64[1] &&
- r->key.as_u64[2] == k->as_u64[2] &&
- r->key.as_u64[3] == k->as_u64[3] &&
- r->key.as_u64[4] == k->as_u64[4])
- return r;
- ri = r->bucket_next;
- }
- return NULL;
-}
-
-#define map_ip6_reass_pool_index(r) (r - map_main.ip6_reass_pool)
-void
-map_ip6_reass_free (map_ip6_reass_t * r, u32 ** pi_to_drop)
-{
- map_main_t *mm = &map_main;
- int i;
- for (i = 0; i < MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- if (r->fragments[i].pi != ~0)
- {
- vec_add1 (*pi_to_drop, r->fragments[i].pi);
- r->fragments[i].pi = ~0;
- map_main.ip6_reass_buffered_counter--;
- }
-
- // Unlink in hash bucket
- map_ip6_reass_t *r2 = NULL;
- u32 r2i = mm->ip6_reass_hash_table[r->bucket];
- while (r2i != map_ip6_reass_pool_index (r))
- {
- ASSERT (r2i != MAP_REASS_INDEX_NONE);
- r2 = pool_elt_at_index (mm->ip6_reass_pool, r2i);
- r2i = r2->bucket_next;
- }
- if (r2)
- {
- r2->bucket_next = r->bucket_next;
- }
- else
- {
- mm->ip6_reass_hash_table[r->bucket] = r->bucket_next;
- }
-
- // Unlink in list
- if (r->fifo_next == map_ip6_reass_pool_index (r))
- {
- //Single element in the list, list is now empty
- mm->ip6_reass_fifo_last = MAP_REASS_INDEX_NONE;
- }
- else
- {
- if (mm->ip6_reass_fifo_last == map_ip6_reass_pool_index (r)) //First element
- mm->ip6_reass_fifo_last = r->fifo_prev;
- pool_elt_at_index (mm->ip6_reass_pool, r->fifo_prev)->fifo_next =
- r->fifo_next;
- pool_elt_at_index (mm->ip6_reass_pool, r->fifo_next)->fifo_prev =
- r->fifo_prev;
- }
-
- // Free from pool if necessary
- pool_put (mm->ip6_reass_pool, r);
- mm->ip6_reass_allocated--;
-}
-
-map_ip6_reass_t *
-map_ip6_reass_get (ip6_address_t * src, ip6_address_t * dst, u32 fragment_id,
- u8 protocol, u32 ** pi_to_drop)
-{
- map_ip6_reass_t *r;
- map_main_t *mm = &map_main;
- map_ip6_reass_key_t k = {
- .src = *src,
- .dst = *dst,
- .fragment_id = fragment_id,
- .protocol = protocol
- };
-
- u32 h = 0;
- int i;
-
-#ifdef clib_crc32c_uses_intrinsics
- h = clib_crc32c ((u8 *) k.as_u32, 40);
-#else
- u64 tmp =
- k.as_u64[0] ^ k.as_u64[1] ^ k.as_u64[2] ^ k.as_u64[3] ^ k.as_u64[4];
- h = clib_xxhash (tmp);
-#endif
-
- h = h >> (32 - mm->ip6_reass_ht_log2len);
-
- f64 now = vlib_time_now (mm->vlib_main);
-
- //Cache garbage collection
- while (mm->ip6_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- map_ip6_reass_t *last =
- pool_elt_at_index (mm->ip6_reass_pool, mm->ip6_reass_fifo_last);
- if (last->ts + (((f64) mm->ip6_reass_conf_lifetime_ms) / 1000) < now)
- map_ip6_reass_free (last, pi_to_drop);
- else
- break;
- }
-
- if ((r = map_ip6_reass_lookup (&k, h, now)))
- return r;
-
- if (mm->ip6_reass_allocated >= mm->ip6_reass_conf_pool_size)
- return NULL;
-
- pool_get (mm->ip6_reass_pool, r);
- mm->ip6_reass_allocated++;
- for (i = 0; i < MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- {
- r->fragments[i].pi = ~0;
- r->fragments[i].next_data_len = 0;
- r->fragments[i].next_data_offset = 0;
- }
-
- u32 ri = map_ip6_reass_pool_index (r);
-
- //Link in new bucket
- r->bucket = h;
- r->bucket_next = mm->ip6_reass_hash_table[h];
- mm->ip6_reass_hash_table[h] = ri;
-
- //Link in fifo
- if (mm->ip6_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- r->fifo_next =
- pool_elt_at_index (mm->ip6_reass_pool,
- mm->ip6_reass_fifo_last)->fifo_next;
- r->fifo_prev = mm->ip6_reass_fifo_last;
- pool_elt_at_index (mm->ip6_reass_pool, r->fifo_prev)->fifo_next = ri;
- pool_elt_at_index (mm->ip6_reass_pool, r->fifo_next)->fifo_prev = ri;
- }
- else
- {
- r->fifo_next = r->fifo_prev = ri;
- mm->ip6_reass_fifo_last = ri;
- }
-
- //Set other fields
- r->ts = now;
- r->key = k;
- r->ip4_header.ip_version_and_header_length = 0;
-#ifdef MAP_IP6_REASS_COUNT_BYTES
- r->expected_total = 0xffff;
- r->forwarded = 0;
-#endif
- return r;
-}
-
-int
-map_ip6_reass_add_fragment (map_ip6_reass_t * r, u32 pi,
- u16 data_offset, u16 next_data_offset,
- u8 * data_start, u16 data_len)
-{
- map_ip6_fragment_t *f = NULL, *prev_f = NULL;
- u16 copied_len = (data_len > 20) ? 20 : data_len;
-
- if (map_main.ip6_reass_buffered_counter >= map_main.ip6_reass_conf_buffers)
- return -1;
-
- //Lookup for fragments for the current buffer
- //and the one before that
- int i;
- for (i = 0; i < MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- {
- if (data_offset && r->fragments[i].next_data_offset == data_offset)
- {
- prev_f = &r->fragments[i]; // This is buffer for previous packet
- }
- else if (r->fragments[i].next_data_offset == next_data_offset)
- {
- f = &r->fragments[i]; // This is a buffer for the current packet
- }
- else if (r->fragments[i].next_data_offset == 0)
- { //Available
- if (f == NULL)
- f = &r->fragments[i];
- else if (prev_f == NULL)
- prev_f = &r->fragments[i];
- }
- }
-
- if (!f || f->pi != ~0)
- return -1;
-
- if (data_offset)
- {
- if (!prev_f)
- return -1;
-
- clib_memcpy (prev_f->next_data, data_start, copied_len);
- prev_f->next_data_len = copied_len;
- prev_f->next_data_offset = data_offset;
- }
- else
- {
- if (((ip4_header_t *) data_start)->ip_version_and_header_length != 0x45)
- return -1;
-
- if (r->ip4_header.ip_version_and_header_length == 0)
- clib_memcpy (&r->ip4_header, data_start, sizeof (ip4_header_t));
- }
-
- if (data_len > 20)
- {
- f->next_data_offset = next_data_offset;
- f->pi = pi;
- map_main.ip6_reass_buffered_counter++;
- }
- return 0;
-}
-
-void
-map_ip4_reass_reinit (u32 * trashed_reass, u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- int i;
+ map_param_set_tcp (tcp_mss);
- if (dropped_packets)
- *dropped_packets = mm->ip4_reass_buffered_counter;
- if (trashed_reass)
- *trashed_reass = mm->ip4_reass_allocated;
- if (mm->ip4_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- u16 ri = mm->ip4_reass_fifo_last;
- do
- {
- map_ip4_reass_t *r = pool_elt_at_index (mm->ip4_reass_pool, ri);
- for (i = 0; i < MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- if (r->fragments[i] != ~0)
- map_ip4_drop_pi (r->fragments[i]);
-
- ri = r->fifo_next;
- pool_put (mm->ip4_reass_pool, r);
- }
- while (ri != mm->ip4_reass_fifo_last);
- }
-
- vec_free (mm->ip4_reass_hash_table);
- vec_resize (mm->ip4_reass_hash_table, 1 << mm->ip4_reass_ht_log2len);
- for (i = 0; i < (1 << mm->ip4_reass_ht_log2len); i++)
- mm->ip4_reass_hash_table[i] = MAP_REASS_INDEX_NONE;
- pool_free (mm->ip4_reass_pool);
- pool_alloc (mm->ip4_reass_pool, mm->ip4_reass_conf_pool_size);
-
- mm->ip4_reass_allocated = 0;
- mm->ip4_reass_fifo_last = MAP_REASS_INDEX_NONE;
- mm->ip4_reass_buffered_counter = 0;
-}
-
-u8
-map_get_ht_log2len (f32 ht_ratio, u16 pool_size)
-{
- u32 desired_size = (u32) (pool_size * ht_ratio);
- u8 i;
- for (i = 1; i < 31; i++)
- if ((1 << i) >= desired_size)
- return i;
- return 4;
-}
-
-int
-map_ip4_reass_conf_ht_ratio (f32 ht_ratio, u32 * trashed_reass,
- u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- if (ht_ratio > MAP_IP4_REASS_CONF_HT_RATIO_MAX)
- return -1;
-
- map_ip4_reass_lock ();
- mm->ip4_reass_conf_ht_ratio = ht_ratio;
- mm->ip4_reass_ht_log2len =
- map_get_ht_log2len (ht_ratio, mm->ip4_reass_conf_pool_size);
- map_ip4_reass_reinit (trashed_reass, dropped_packets);
- map_ip4_reass_unlock ();
- return 0;
-}
-
-int
-map_ip4_reass_conf_pool_size (u16 pool_size, u32 * trashed_reass,
- u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- if (pool_size > MAP_IP4_REASS_CONF_POOL_SIZE_MAX)
- return -1;
-
- map_ip4_reass_lock ();
- mm->ip4_reass_conf_pool_size = pool_size;
- map_ip4_reass_reinit (trashed_reass, dropped_packets);
- map_ip4_reass_unlock ();
- return 0;
-}
-
-int
-map_ip4_reass_conf_lifetime (u16 lifetime_ms)
-{
- map_main.ip4_reass_conf_lifetime_ms = lifetime_ms;
- return 0;
-}
-
-int
-map_ip4_reass_conf_buffers (u32 buffers)
-{
- map_main.ip4_reass_conf_buffers = buffers;
- return 0;
-}
-
-void
-map_ip6_reass_reinit (u32 * trashed_reass, u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- if (dropped_packets)
- *dropped_packets = mm->ip6_reass_buffered_counter;
- if (trashed_reass)
- *trashed_reass = mm->ip6_reass_allocated;
- int i;
- if (mm->ip6_reass_fifo_last != MAP_REASS_INDEX_NONE)
- {
- u16 ri = mm->ip6_reass_fifo_last;
- do
- {
- map_ip6_reass_t *r = pool_elt_at_index (mm->ip6_reass_pool, ri);
- for (i = 0; i < MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++)
- if (r->fragments[i].pi != ~0)
- map_ip6_drop_pi (r->fragments[i].pi);
-
- ri = r->fifo_next;
- pool_put (mm->ip6_reass_pool, r);
- }
- while (ri != mm->ip6_reass_fifo_last);
- mm->ip6_reass_fifo_last = MAP_REASS_INDEX_NONE;
- }
-
- vec_free (mm->ip6_reass_hash_table);
- vec_resize (mm->ip6_reass_hash_table, 1 << mm->ip6_reass_ht_log2len);
- for (i = 0; i < (1 << mm->ip6_reass_ht_log2len); i++)
- mm->ip6_reass_hash_table[i] = MAP_REASS_INDEX_NONE;
- pool_free (mm->ip6_reass_pool);
- pool_alloc (mm->ip6_reass_pool, mm->ip4_reass_conf_pool_size);
-
- mm->ip6_reass_allocated = 0;
- mm->ip6_reass_buffered_counter = 0;
-}
-
-int
-map_ip6_reass_conf_ht_ratio (f32 ht_ratio, u32 * trashed_reass,
- u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- if (ht_ratio > MAP_IP6_REASS_CONF_HT_RATIO_MAX)
- return -1;
-
- map_ip6_reass_lock ();
- mm->ip6_reass_conf_ht_ratio = ht_ratio;
- mm->ip6_reass_ht_log2len =
- map_get_ht_log2len (ht_ratio, mm->ip6_reass_conf_pool_size);
- map_ip6_reass_reinit (trashed_reass, dropped_packets);
- map_ip6_reass_unlock ();
- return 0;
-}
-
-int
-map_ip6_reass_conf_pool_size (u16 pool_size, u32 * trashed_reass,
- u32 * dropped_packets)
-{
- map_main_t *mm = &map_main;
- if (pool_size > MAP_IP6_REASS_CONF_POOL_SIZE_MAX)
- return -1;
-
- map_ip6_reass_lock ();
- mm->ip6_reass_conf_pool_size = pool_size;
- map_ip6_reass_reinit (trashed_reass, dropped_packets);
- map_ip6_reass_unlock ();
- return 0;
-}
+done:
+ unformat_free (line_input);
-int
-map_ip6_reass_conf_lifetime (u16 lifetime_ms)
-{
- map_main.ip6_reass_conf_lifetime_ms = lifetime_ms;
- return 0;
+ return error;
}
-int
-map_ip6_reass_conf_buffers (u32 buffers)
-{
- map_main.ip6_reass_conf_buffers = buffers;
- return 0;
-}
/* *INDENT-OFF* */
-/*?
- * Configure MAP reassembly behaviour
- *
- * @cliexpar
- * @cliexstart{map params reassembly}
- * @cliexend
- ?*/
-VLIB_CLI_COMMAND(map_ip4_reass_lifetime_command, static) = {
- .path = "map params reassembly",
- .short_help = "map params reassembly [ip4 | ip6] [lifetime <lifetime-ms>] "
- "[pool-size <pool-size>] [buffers <buffers>] "
- "[ht-ratio <ht-ratio>]",
- .function = map_params_reass_command_fn,
-};
-
/*?
* Set or copy the IP TOS/Traffic Class field
*
.function = map_traffic_class_command_fn,
};
+/*?
+ * TCP MSS clamping
+ *
+ * @cliexpar
+ * @cliexstart{map params tcp-mss}
+ *
+ * This command is used to set the TCP MSS in translated
+ * or encapsulated packets.
+ * @cliexend
+ ?*/
+VLIB_CLI_COMMAND(map_tcp_mss_command, static) = {
+ .path = "map params tcp-mss",
+ .short_help = "map params tcp-mss <value>",
+ .function = map_tcp_mss_command_fn,
+};
+
/*?
* Bypass IP4/IP6 lookup
*
/*?
* Enable or disable the MAP-E inbound security check
+ * Specifiy if the inbound security check should be done on fragments
*
* @cliexpar
* @cliexstart{map params security-check}
* By default, a decapsulated packet's IPv4 source address will be
* verified against the outer header's IPv6 source address. Disabling
* this feature will allow IPv4 source address spoofing.
+ *
+ * Typically the inbound on-decapsulation security check is only done
+ * on the first packet. The packet that contains the L4
+ * information. While a security check on every fragment is possible,
+ * it has a cost. State must be created on the first fragment.
* @cliexend
?*/
VLIB_CLI_COMMAND(map_security_check_command, static) = {
.path = "map params security-check",
- .short_help = "map params security-check on|off",
+ .short_help = "map params security-check enable|disable fragments on|off",
.function = map_security_check_command_fn,
};
+
/*?
* Specifiy the IPv4 source address used for relayed ICMP error messages
*
*
* @cliexpar
* @cliexstart{map params fragment}
- * @cliexend
- ?*/
-VLIB_CLI_COMMAND(map_fragment_command, static) = {
- .path = "map params fragment",
- .short_help = "map params fragment inner|outer",
- .function = map_fragment_command_fn,
-};
-
-/*?
- * Ignore the IPv4 Don't fragment bit
- *
- * @cliexpar
- * @cliexstart{map params fragment ignore-df}
*
* Allows fragmentation of the IPv4 packet even if the DF bit is
* set. The choice between inner or outer fragmentation of tunnel
* endpoint.
* @cliexend
?*/
-VLIB_CLI_COMMAND(map_fragment_df_command, static) = {
- .path = "map params fragment ignore-df",
- .short_help = "map params fragment ignore-df on|off",
- .function = map_fragment_df_command_fn,
+VLIB_CLI_COMMAND(map_fragment_command, static) = {
+ .path = "map params fragment",
+ .short_help = "map params fragment inner|outer ignore-df|honor-df",
+ .function = map_fragment_command_fn,
};
-/*?
- * Specifiy if the inbound security check should be done on fragments
- *
- * @cliexpar
- * @cliexstart{map params security-check fragments}
- *
- * Typically the inbound on-decapsulation security check is only done
- * on the first packet. The packet that contains the L4
- * information. While a security check on every fragment is possible,
- * it has a cost. State must be created on the first fragment.
- * @cliexend
- ?*/
-VLIB_CLI_COMMAND(map_security_check_frag_command, static) = {
- .path = "map params security-check fragments",
- .short_help = "map params security-check fragments on|off",
- .function = map_security_check_frag_command_fn,
-};
/*?
* Add MAP domain
?*/
VLIB_CLI_COMMAND(map_add_domain_command, static) = {
.path = "map add domain",
- .short_help = "map add domain ip4-pfx <ip4-pfx> ip6-pfx <ip6-pfx> "
+ .short_help = "map add domain [tag <tag>] ip4-pfx <ip4-pfx> "
+ "ip6-pfx <ip6-pfx> "
"ip6-src <ip6-pfx> ea-bits-len <n> psid-offset <n> psid-len <n> "
- "[map-t] [map-ce] [mtu <mtu>]",
+ "[map-t] [mtu <mtu>]",
.function = map_add_domain_command_fn,
};
};
/*?
- * Show MAP fragmentation information
+ * Enable MAP processing on interface (input feature)
*
- * @cliexpar
- * @cliexstart{show map fragments}
- * @cliexend
?*/
-VLIB_CLI_COMMAND(show_map_fragments_command, static) = {
- .path = "show map fragments",
- .short_help = "show map fragments",
- .function = show_map_fragments_command_fn,
+VLIB_CLI_COMMAND(map_if_command, static) = {
+ .path = "map interface",
+ .short_help = "map interface <interface-name> [map-t] [del]",
+ .function = map_if_command_fn,
};
VLIB_PLUGIN_REGISTER() = {
.version = VPP_BUILD_VER,
- .description = "Mapping of address and port (MAP)",
+ .description = "Mapping of Address and Port (MAP)",
};
/* *INDENT-ON* */
-static clib_error_t *
-map_config (vlib_main_t * vm, unformat_input_t * input)
-{
- map_main_t *mm = &map_main;
- u8 is_ce = false;
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (input, "customer edge"))
- is_ce = true;
- else
- return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, input);
- }
-
- mm->is_ce = is_ce;
-
- return 0;
-}
-
-VLIB_CONFIG_FUNCTION (map_config, "map");
-
/*
* map_init
*/
{
map_main_t *mm = &map_main;
clib_error_t *error = 0;
+
+ memset (mm, 0, sizeof (*mm));
+
mm->vnet_main = vnet_get_main ();
mm->vlib_main = vm;
/* ICMP6 Type 1, Code 5 for security check failure */
mm->icmp6_enabled = false;
- mm->is_ce = false;
-
/* Inner or outer fragmentation */
mm->frag_inner = false;
mm->frag_ignore_df = false;
vec_validate (mm->domain_counters, MAP_N_DOMAIN_COUNTER - 1);
- mm->domain_counters[MAP_DOMAIN_COUNTER_RX].name = "rx";
- mm->domain_counters[MAP_DOMAIN_COUNTER_TX].name = "tx";
+ mm->domain_counters[MAP_DOMAIN_COUNTER_RX].name = "/map/rx";
+ mm->domain_counters[MAP_DOMAIN_COUNTER_TX].name = "/map/tx";
vlib_validate_simple_counter (&mm->icmp_relayed, 0);
vlib_zero_simple_counter (&mm->icmp_relayed, 0);
-
- /* IP4 virtual reassembly */
- mm->ip4_reass_hash_table = 0;
- mm->ip4_reass_pool = 0;
- mm->ip4_reass_lock =
- clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);
- *mm->ip4_reass_lock = 0;
- mm->ip4_reass_conf_ht_ratio = MAP_IP4_REASS_HT_RATIO_DEFAULT;
- mm->ip4_reass_conf_lifetime_ms = MAP_IP4_REASS_LIFETIME_DEFAULT;
- mm->ip4_reass_conf_pool_size = MAP_IP4_REASS_POOL_SIZE_DEFAULT;
- mm->ip4_reass_conf_buffers = MAP_IP4_REASS_BUFFERS_DEFAULT;
- mm->ip4_reass_ht_log2len =
- map_get_ht_log2len (mm->ip4_reass_conf_ht_ratio,
- mm->ip4_reass_conf_pool_size);
- mm->ip4_reass_fifo_last = MAP_REASS_INDEX_NONE;
- map_ip4_reass_reinit (NULL, NULL);
+ mm->icmp_relayed.stat_segment_name = "/map/icmp-relayed";
/* IP6 virtual reassembly */
- mm->ip6_reass_hash_table = 0;
- mm->ip6_reass_pool = 0;
- mm->ip6_reass_lock =
- clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);
- *mm->ip6_reass_lock = 0;
- mm->ip6_reass_conf_ht_ratio = MAP_IP6_REASS_HT_RATIO_DEFAULT;
- mm->ip6_reass_conf_lifetime_ms = MAP_IP6_REASS_LIFETIME_DEFAULT;
- mm->ip6_reass_conf_pool_size = MAP_IP6_REASS_POOL_SIZE_DEFAULT;
- mm->ip6_reass_conf_buffers = MAP_IP6_REASS_BUFFERS_DEFAULT;
- mm->ip6_reass_ht_log2len =
- map_get_ht_log2len (mm->ip6_reass_conf_ht_ratio,
- mm->ip6_reass_conf_pool_size);
- mm->ip6_reass_fifo_last = MAP_REASS_INDEX_NONE;
- map_ip6_reass_reinit (NULL, NULL);
#ifdef MAP_SKIP_IP6_LOOKUP
fib_node_register_type (FIB_NODE_TYPE_MAP_E, &map_vft);
#endif
- map_dpo_module_init ();
+
+ /* LPM lookup tables */
+ mm->ip4_prefix_tbl = lpm_table_init (LPM_TYPE_KEY32);
+ mm->ip6_prefix_tbl = lpm_table_init (LPM_TYPE_KEY128);
+ mm->ip6_src_prefix_tbl = lpm_table_init (LPM_TYPE_KEY128);
+
+ mm->bm_trans_enabled_by_sw_if = 0;
+ mm->bm_encap_enabled_by_sw_if = 0;
error = map_plugin_api_hookup (vm);
Code Review / vpp.git / blobdiff