#include <vpp/app/version.h>
#include <vnet/ethernet/ethernet_types_api.h>
+#include <vnet/ip/format.h>
+#include <vnet/ethernet/ethernet.h>
+#include <vnet/ip/ip_types_api.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#include <acl/acl.api_enum.h>
#include <acl/acl.api_types.h>
-#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
-#include "manual_fns.h"
#include "fa_node.h"
#include "public_inlines.h"
#include <vppinfra/bihash_template.h>
#include <vppinfra/bihash_template.c>
-/* *INDENT-OFF* */
VLIB_PLUGIN_REGISTER () = {
.version = VPP_BUILD_VER,
.description = "Access Control Lists (ACL)",
};
-/* *INDENT-ON* */
/* methods exported from ACL-as-a-service */
static acl_plugin_methods_t acl_plugin;
return s;
}
-static void *
-acl_set_heap (acl_main_t * am)
-{
- if (0 == am->acl_mheap)
- {
- if (0 == am->acl_mheap_size)
- {
- vlib_thread_main_t *tm = vlib_get_thread_main ();
- u64 per_worker_slack = 1000000LL;
- u64 per_worker_size =
- per_worker_slack +
- ((u64) am->fa_conn_table_max_entries) * sizeof (fa_session_t);
- u64 per_worker_size_with_slack = per_worker_slack + per_worker_size;
- u64 main_slack = 2000000LL;
- u64 bihash_size = (u64) am->fa_conn_table_hash_memory_size;
-
- am->acl_mheap_size =
- per_worker_size_with_slack * tm->n_vlib_mains + bihash_size +
- main_slack;
- }
- u64 max_possible = ((uword) ~ 0);
- if (am->acl_mheap_size > max_possible)
- {
- clib_warning ("ACL heap size requested: %lld, max possible %lld",
- am->acl_mheap_size, max_possible);
- }
-
- am->acl_mheap = mheap_alloc_with_lock (0 /* use VM */ ,
- am->acl_mheap_size,
- 1 /* locked */ );
- if (0 == am->acl_mheap)
- {
- clib_error
- ("ACL plugin failed to allocate main heap of %U bytes, abort",
- format_memory_size, am->acl_mheap_size);
- }
- }
- void *oldheap = clib_mem_set_heap (am->acl_mheap);
- return oldheap;
-}
-
-void *
-acl_plugin_set_heap ()
-{
- acl_main_t *am = &acl_main;
- return acl_set_heap (am);
-}
-
-void
-acl_plugin_acl_set_validate_heap (acl_main_t * am, int on)
-{
- clib_mem_set_heap (acl_set_heap (am));
-}
-
-void
-acl_plugin_acl_set_trace_heap (acl_main_t * am, int on)
-{
- clib_mem_set_heap (acl_set_heap (am));
-}
-
static void
vl_api_acl_plugin_get_version_t_handler (vl_api_acl_plugin_get_version_t * mp)
{
acl_main_t *am = &acl_main;
int rv = 0;
- /* *INDENT-OFF* */
REPLY_MACRO2 (VL_API_ACL_PLUGIN_CONTROL_PING_REPLY,
({
rmp->vpe_pid = ntohl (getpid ());
}));
- /* *INDENT-ON* */
}
static void
typedef void (*acl_vector_print_func_t) (vlib_main_t * vm, u8 * out0);
+static inline u8 *
+format_acl_action (u8 * s, u8 action)
+{
+ switch (action)
+ {
+ case 0:
+ s = format (s, "deny");
+ break;
+ case 1:
+ s = format (s, "permit");
+ break;
+ case 2:
+ s = format (s, "permit+reflect");
+ break;
+ default:
+ s = format (s, "action %d", action);
+ }
+ return (s);
+}
+
static void
acl_print_acl_x (acl_vector_print_func_t vpr, vlib_main_t * vm,
acl_main_t * am, int acl_index)
ntohs (VL_API_ACL_PLUGIN_GET_CONN_TABLE_MAX_ENTRIES_REPLY +
am->msg_id_base);
rmp->context = mp->context;
- rmp->conn_table_max_entries = __bswap_64 (am->fa_conn_table_max_entries);
+ rmp->conn_table_max_entries =
+ clib_net_to_host_u64 (am->fa_conn_table_max_entries);
vl_api_send_msg (rp, (u8 *) rmp);
}
acl_plugin_counter_unlock (am);
}
-static int
-acl_api_ip4_invalid_prefix (const vl_api_prefix_t * prefix)
-{
- ip4_address_t ip4_addr;
- ip4_address_t ip4_mask;
- ip4_address_t ip4_masked_addr;
-
- if (prefix->len > 32)
- return 1;
-
- ip4_address_decode (prefix->address.un.ip4, &ip4_addr);
- ip4_preflen_to_mask (prefix->len, &ip4_mask);
- ip4_masked_addr.as_u32 = ip4_addr.as_u32 & ip4_mask.as_u32;
- int ret = (ip4_masked_addr.as_u32 != ip4_addr.as_u32);
- if (ret)
- {
- clib_warning
- ("inconsistent addr %U for prefix len %d; (%U when masked)",
- format_ip4_address, prefix->address.un.ip4, prefix->len,
- format_ip4_address, &ip4_masked_addr);
- }
- return ret;
-}
-
-static int
-acl_api_ip6_invalid_prefix (const vl_api_prefix_t * prefix)
-{
- ip6_address_t ip6_addr;
- ip6_address_t ip6_mask;
- ip6_address_t ip6_masked_addr;
-
- if (prefix->len > 128)
- return 1;
-
- ip6_address_decode (prefix->address.un.ip6, &ip6_addr);
- ip6_preflen_to_mask (prefix->len, &ip6_mask);
- ip6_masked_addr.as_u64[0] = ip6_addr.as_u64[0] & ip6_mask.as_u64[0];
- ip6_masked_addr.as_u64[1] = ip6_addr.as_u64[1] & ip6_mask.as_u64[1];
- int ret = ((ip6_masked_addr.as_u64[0] != ip6_addr.as_u64[0])
- || (ip6_masked_addr.as_u64[1] != ip6_addr.as_u64[1]));
- if (ret)
- {
- clib_warning
- ("inconsistent addr %U for prefix len %d; (%U when masked)",
- format_ip6_address, prefix->address.un.ip6, prefix->len,
- format_ip6_address, &ip6_masked_addr);
- }
- return ret;
-}
-
static int
acl_api_invalid_prefix (const vl_api_prefix_t * prefix)
{
- if (prefix->address.af == ADDRESS_IP6)
- return acl_api_ip6_invalid_prefix (prefix);
- return acl_api_ip4_invalid_prefix (prefix);
+ ip_prefix_t ip_prefix;
+ int valid_af =
+ prefix->address.af == ADDRESS_IP4 || prefix->address.af == ADDRESS_IP6;
+ return (!valid_af) || ip_prefix_decode2 (prefix, &ip_prefix);
}
static int
acl_list_t *a;
acl_rule_t *r;
acl_rule_t *acl_new_rules = 0;
+ size_t tag_len;
int i;
+ tag_len = clib_strnlen ((const char *) tag, sizeof (a->tag));
+ if (tag_len == sizeof (a->tag))
+ return VNET_API_ERROR_INVALID_VALUE;
+
if (am->trace_acl > 255)
clib_warning ("API dbg: acl_add_list index %d tag %s", *acl_list_index,
tag);
return VNET_API_ERROR_INVALID_SRC_ADDRESS;
if (acl_api_invalid_prefix (&rules[i].dst_prefix))
return VNET_API_ERROR_INVALID_DST_ADDRESS;
+ if (rules[i].src_prefix.address.af != rules[i].dst_prefix.address.af)
+ return VNET_API_ERROR_INVALID_SRC_ADDRESS;
if (ntohs (rules[i].srcport_or_icmptype_first) >
ntohs (rules[i].srcport_or_icmptype_last))
return VNET_API_ERROR_INVALID_VALUE_2;
*acl_list_index, tag);
}
- void *oldheap = acl_set_heap (am);
-
/* Create and populate the rules */
if (count > 0)
vec_validate (acl_new_rules, count - 1);
vec_free (a->rules);
}
a->rules = acl_new_rules;
- memcpy (a->tag, tag, sizeof (a->tag));
+ memcpy (a->tag, tag, tag_len + 1);
if (am->trace_acl > 255)
warning_acl_print_acl (am->vlib_main, am, *acl_list_index);
if (am->reclassify_sessions)
/* a change in an ACLs if they are applied may mean a new policy epoch */
policy_notify_acl_change (am, *acl_list_index);
}
-
- /* stats segment expects global heap, so restore it temporarily */
- clib_mem_set_heap (oldheap);
validate_and_reset_acl_counters (am, *acl_list_index);
- oldheap = acl_set_heap (am);
-
- /* notify the lookup contexts about the ACL changes */
acl_plugin_lookup_context_notify_acl_change (*acl_list_index);
- clib_mem_set_heap (oldheap);
return 0;
}
if (acl_is_used_by (acl_list_index, am->lc_index_vec_by_acl))
return VNET_API_ERROR_ACL_IN_USE_BY_LOOKUP_CONTEXT;
- void *oldheap = acl_set_heap (am);
-
/* now we can delete the ACL itself */
a = pool_elt_at_index (am->acls, acl_list_index);
if (a->rules)
pool_put (am->acls, a);
/* acl_list_index is now free, notify the lookup contexts */
acl_plugin_lookup_context_notify_acl_change (acl_list_index);
- clib_mem_set_heap (oldheap);
return 0;
}
if (0 == match)
match = 1;
- void *oldheap = clib_mem_set_heap (cm->vlib_main->heap_base);
int ret = vnet_classify_add_del_table (cm, skip_mask_ptr, nbuckets,
memory_size, skip, match,
next_table_index, miss_next_index,
table_index, current_data_flag,
current_data_offset, is_add,
1 /* delete_chain */ );
- clib_mem_set_heap (oldheap);
return ret;
}
static void
acl_clear_sessions (acl_main_t * am, u32 sw_if_index)
{
- void *oldheap = clib_mem_set_heap (am->vlib_main->heap_base);
vlib_process_signal_event (am->vlib_main, am->fa_cleaner_node_index,
ACL_FA_CLEANER_DELETE_BY_SW_IF_INDEX,
sw_if_index);
- clib_mem_set_heap (oldheap);
}
acl_fa_enable_disable (sw_if_index, 1, enable_disable);
- void *oldheap = clib_mem_set_heap (am->vlib_main->heap_base);
rv = vnet_l2_feature_enable_disable ("l2-input-ip4", "acl-plugin-in-ip4-l2",
sw_if_index, enable_disable, 0, 0);
if (rv)
vnet_l2_feature_enable_disable ("l2-input-nonip",
"acl-plugin-in-nonip-l2", sw_if_index,
enable_disable, 0, 0);
-
- clib_mem_set_heap (oldheap);
-
am->in_acl_on_sw_if_index =
clib_bitmap_set (am->in_acl_on_sw_if_index, sw_if_index, enable_disable);
acl_fa_enable_disable (sw_if_index, 0, enable_disable);
- void *oldheap = clib_mem_set_heap (am->vlib_main->heap_base);
rv =
vnet_l2_feature_enable_disable ("l2-output-ip4", "acl-plugin-out-ip4-l2",
sw_if_index, enable_disable, 0, 0);
vnet_l2_feature_enable_disable ("l2-output-nonip",
"acl-plugin-out-nonip-l2", sw_if_index,
enable_disable, 0, 0);
-
-
- clib_mem_set_heap (oldheap);
-
am->out_acl_on_sw_if_index =
clib_bitmap_set (am->out_acl_on_sw_if_index, sw_if_index, enable_disable);
u32 **pinout_lc_index_by_sw_if_index =
- is_input ? &am->
- input_lc_index_by_sw_if_index : &am->output_lc_index_by_sw_if_index;
+ is_input ? &am->input_lc_index_by_sw_if_index : &am->
+ output_lc_index_by_sw_if_index;
u32 ***pinout_acl_vec_by_sw_if_index =
- is_input ? &am->
- input_acl_vec_by_sw_if_index : &am->output_acl_vec_by_sw_if_index;
+ is_input ? &am->input_acl_vec_by_sw_if_index : &am->
+ output_acl_vec_by_sw_if_index;
u32 ***pinout_sw_if_index_vec_by_acl =
- is_input ? &am->
- input_sw_if_index_vec_by_acl : &am->output_sw_if_index_vec_by_acl;
+ is_input ? &am->input_sw_if_index_vec_by_acl : &am->
+ output_sw_if_index_vec_by_acl;
vec_validate ((*pinout_acl_vec_by_sw_if_index), sw_if_index);
format_bitmap_hex, old_seen_acl_bitmap, format_bitmap_hex,
seen_acl_bitmap, format_bitmap_hex, change_acl_bitmap);
-/* *INDENT-OFF* */
- clib_bitmap_foreach(acln, change_acl_bitmap, ({
+ clib_bitmap_foreach (acln, change_acl_bitmap) {
if (clib_bitmap_get(old_seen_acl_bitmap, acln)) {
/* ACL is being removed. */
if (acln < vec_len((*pinout_sw_if_index_vec_by_acl))) {
vec_validate((*pinout_sw_if_index_vec_by_acl), acln);
vec_add1((*pinout_sw_if_index_vec_by_acl)[acln], sw_if_index);
}
- }));
-/* *INDENT-ON* */
+ }
vec_free ((*pinout_acl_vec_by_sw_if_index)[sw_if_index]);
(*pinout_acl_vec_by_sw_if_index)[sw_if_index] =
{
if (~0 != (*pinout_lc_index_by_sw_if_index)[sw_if_index])
{
- acl_plugin.put_lookup_context_index ((*pinout_lc_index_by_sw_if_index)[sw_if_index]);
+ acl_plugin.
+ put_lookup_context_index ((*pinout_lc_index_by_sw_if_index)
+ [sw_if_index]);
(*pinout_lc_index_by_sw_if_index)[sw_if_index] = ~0;
}
}
-
/* ensure ACL processing is enabled/disabled as needed */
acl_interface_inout_enable_disable (am, sw_if_index, is_input,
vec_len (vec_acl_list_index) > 0);
int *may_clear_sessions)
{
acl_main_t *am = &acl_main;
- void *oldheap = acl_set_heap (am);
acl_interface_set_inout_acl_list (am, sw_if_index, is_input, 0,
may_clear_sessions);
- clib_mem_set_heap (oldheap);
}
static int
: VNET_API_ERROR_ACL_IN_USE_OUTBOUND;
u32 ***pinout_acl_vec_by_sw_if_index =
- is_input ? &am->
- input_acl_vec_by_sw_if_index : &am->output_acl_vec_by_sw_if_index;
+ is_input ? &am->input_acl_vec_by_sw_if_index : &am->
+ output_acl_vec_by_sw_if_index;
int rv = 0;
- void *oldheap = acl_set_heap (am);
-
if (is_add)
{
vec_validate ((*pinout_acl_vec_by_sw_if_index), sw_if_index);
&may_clear_sessions);
done:
vec_free (acl_vec);
- clib_mem_set_heap (oldheap);
return rv;
}
vnet_classify_add_del_session (cm, tag_table,
mask,
- a->
- rules[i].is_permit ? ~0 : 0,
- i, 0, action, metadata, 1);
+ a->rules[i].
+ is_permit ? ~0 : 0, i, 0,
+ action, metadata, 1);
}
}
}
macip_acl_list_t *a;
macip_acl_rule_t *r;
macip_acl_rule_t *acl_new_rules = 0;
+ size_t tag_len;
int i;
int rv = 0;
+ tag_len = clib_strnlen ((const char *) tag, sizeof (a->tag));
+ if (tag_len == sizeof (a->tag))
+ return VNET_API_ERROR_INVALID_VALUE;
+
if (*acl_list_index != ~0)
{
/* They supplied some number, let's see if this MACIP ACL exists */
/* if replacing the ACL, unapply the classifier tables first - they will be gone.. */
if (~0 != *acl_list_index)
rv = macip_maybe_apply_unapply_classifier_tables (am, *acl_list_index, 0);
- void *oldheap = acl_set_heap (am);
/* Create and populate the rules */
if (count > 0)
vec_validate (acl_new_rules, count - 1);
a->rules = acl_new_rules;
a->count = count;
- memcpy (a->tag, tag, sizeof (a->tag));
+ memcpy (a->tag, tag, tag_len + 1);
/* Create and populate the classifier tables */
macip_create_classify_tables (am, *acl_list_index);
- clib_mem_set_heap (oldheap);
/* If the ACL was already applied somewhere, reapply the newly created tables */
rv = rv
|| macip_maybe_apply_unapply_classifier_tables (am, *acl_list_index, 1);
{
return VNET_API_ERROR_NO_SUCH_ENTRY;
}
- void *oldheap = acl_set_heap (am);
a = pool_elt_at_index (am->macip_acls, macip_acl_index);
vec_validate_init_empty (am->macip_acl_by_sw_if_index, sw_if_index, ~0);
vec_validate (am->sw_if_index_vec_by_macip_acl, macip_acl_index);
vec_add1 (am->sw_if_index_vec_by_macip_acl[macip_acl_index], sw_if_index);
- clib_mem_set_heap (oldheap);
/* If there already a MACIP ACL applied, unapply it */
if (~0 != am->macip_acl_by_sw_if_index[sw_if_index])
macip_acl_interface_del_acl (am, sw_if_index);
}
}
- void *oldheap = acl_set_heap (am);
/* Now that classifier tables are detached, clean them up */
macip_destroy_classify_tables (am, acl_list_index);
vec_free (a->rules);
}
pool_put (am->macip_acls, a);
- clib_mem_set_heap (oldheap);
return 0;
}
*
*/
static int
-verify_message_len (void *mp, u32 expected_len, char *where)
+verify_message_len (void *mp, u64 expected_len, char *where)
{
u32 supplied_len = vl_msg_api_get_msg_length (mp);
if (supplied_len < expected_len)
int rv;
u32 acl_list_index = ntohl (mp->acl_index);
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "acl_add_replace"))
{
rv = VNET_API_ERROR_INVALID_VALUE;
}
- /* *INDENT-OFF* */
REPLY_MACRO2(VL_API_ACL_ADD_REPLACE_REPLY,
({
rmp->acl_index = htonl(acl_list_index);
}));
- /* *INDENT-ON* */
}
static void
}
if (0 == rv)
{
- void *oldheap = acl_set_heap (am);
-
u32 *in_acl_vec = 0;
u32 *out_acl_vec = 0;
for (i = 0; i < mp->count; i++)
&may_clear_sessions);
vec_free (in_acl_vec);
vec_free (out_acl_vec);
- clib_mem_set_heap (oldheap);
}
}
int i;
acl_rule_t *acl_rules = acl->rules;
int msg_size = sizeof (*mp) + sizeof (mp->r[0]) * vec_len (acl_rules);
- void *oldheap = acl_set_heap (am);
mp = vl_msg_api_alloc (msg_size);
clib_memset (mp, 0, msg_size);
mp->context = context;
mp->count = htonl (vec_len (acl_rules));
mp->acl_index = htonl (acl - am->acls);
- memcpy (mp->tag, acl->tag, sizeof (mp->tag));
+ snprintf ((char *) mp->tag, sizeof (mp->tag), "%s", acl->tag);
// clib_memcpy (mp->r, acl->rules, acl->count * sizeof(acl->rules[0]));
rules = mp->r;
for (i = 0; i < vec_len (acl_rules); i++)
copy_acl_rule_to_api_rule (&rules[i], &acl_rules[i]);
}
- clib_mem_set_heap (oldheap);
vl_api_send_msg (reg, (u8 *) mp);
}
if (mp->acl_index == ~0)
{
- /* *INDENT-OFF* */
/* Just dump all ACLs */
- pool_foreach (acl, am->acls,
- ({
+ pool_foreach (acl, am->acls)
+ {
send_acl_details(am, reg, acl, mp->context);
- }));
- /* *INDENT-ON* */
+ }
}
else
{
int n_output;
int count;
int i = 0;
- void *oldheap = acl_set_heap (am);
vec_validate (am->input_acl_vec_by_sw_if_index, sw_if_index);
vec_validate (am->output_acl_vec_by_sw_if_index, sw_if_index);
- clib_mem_set_heap (oldheap);
-
n_input = vec_len (am->input_acl_vec_by_sw_if_index[sw_if_index]);
n_output = vec_len (am->output_acl_vec_by_sw_if_index[sw_if_index]);
count = n_input + n_output;
if (mp->sw_if_index == ~0)
{
- /* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
send_acl_interface_list_details(am, reg, swif->sw_if_index, mp->context);
- }));
- /* *INDENT-ON* */
+ }
}
else
{
int rv;
u32 acl_list_index = ~0;
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "macip_acl_add"))
{
rv = VNET_API_ERROR_INVALID_VALUE;
}
- /* *INDENT-OFF* */
REPLY_MACRO2(VL_API_MACIP_ACL_ADD_REPLY,
({
rmp->acl_index = htonl(acl_list_index);
}));
- /* *INDENT-ON* */
}
static void
int rv;
u32 acl_list_index = ntohl (mp->acl_index);
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "macip_acl_add_replace"))
{
rv = VNET_API_ERROR_INVALID_VALUE;
}
- /* *INDENT-OFF* */
REPLY_MACRO2(VL_API_MACIP_ACL_ADD_REPLACE_REPLY,
({
rmp->acl_index = htonl(acl_list_index);
}));
- /* *INDENT-ON* */
}
static void
mp->context = context;
if (acl)
{
- memcpy (mp->tag, acl->tag, sizeof (mp->tag));
+ snprintf ((char *) mp->tag, sizeof (mp->tag), "%s", acl->tag);
mp->count = htonl (acl->count);
mp->acl_index = htonl (acl - am->macip_acls);
rules = mp->r;
if (mp->acl_index == ~0)
{
/* Just dump all ACLs for now, with sw_if_index = ~0 */
- /* *INDENT-OFF* */
- pool_foreach (acl, am->macip_acls,
- ({
+ pool_foreach (acl, am->macip_acls)
+ {
send_macip_acl_details (am, reg, acl, mp->context);
- }));
- /* *INDENT-ON* */
+ }
}
else
{
if (~0 != am->macip_acl_by_sw_if_index[sw_if_index])
{
send_macip_acl_interface_list_details (am, reg, sw_if_index,
- am->macip_acl_by_sw_if_index
+ am->
+ macip_acl_by_sw_if_index
[sw_if_index],
mp->context);
}
vnet_interface_main_t *im = &am->vnet_main->interface_main;
u32 sw_if_index = ntohl (mp->sw_if_index);
u16 *vec_in = 0, *vec_out = 0;
- void *oldheap = acl_set_heap (am);
if (pool_is_free_index (im->sw_interfaces, sw_if_index))
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
rv = acl_set_etype_whitelists (am, sw_if_index, vec_in, vec_out);
}
- clib_mem_set_heap (oldheap);
REPLY_MACRO (VL_API_ACL_INTERFACE_SET_ETYPE_WHITELIST_REPLY);
}
if ((0 == whitelist_in) && (0 == whitelist_out))
return; /* nothing to do */
- void *oldheap = acl_set_heap (am);
-
n_input = vec_len (whitelist_in);
n_output = vec_len (whitelist_out);
count = n_input + n_output;
{
mp->whitelist[n_input + i] = htons (whitelist_out[i]);
}
- clib_mem_set_heap (oldheap);
vl_api_send_msg (reg, (u8 *) mp);
}
if (mp->sw_if_index == ~0)
{
- /* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
send_acl_interface_etype_whitelist_details(am, reg, swif->sw_if_index, mp->context);
- }));
- /* *INDENT-ON* */
+ }
}
else
{
}
}
+static void
+vl_api_acl_plugin_use_hash_lookup_set_t_handler (
+ vl_api_acl_plugin_use_hash_lookup_set_t *mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_plugin_use_hash_lookup_set_reply_t *rmp;
+ vl_api_registration_t *reg;
+ int rv = 0;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ am->use_hash_acl_matching = mp->enable;
+ REPLY_MACRO (VL_API_ACL_PLUGIN_USE_HASH_LOOKUP_SET_REPLY);
+}
+
+static void
+vl_api_acl_plugin_use_hash_lookup_get_t_handler (
+ vl_api_acl_plugin_use_hash_lookup_get_t *mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_plugin_use_hash_lookup_get_reply_t *rmp;
+ int msg_size = sizeof (*rmp);
+ vl_api_registration_t *reg;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ rmp = vl_msg_api_alloc (msg_size);
+ clib_memset (rmp, 0, msg_size);
+ rmp->_vl_msg_id =
+ ntohs (VL_API_ACL_PLUGIN_USE_HASH_LOOKUP_GET_REPLY + am->msg_id_base);
+ rmp->context = mp->context;
+ rmp->enable = am->use_hash_acl_matching;
+ vl_api_send_msg (reg, (u8 *) rmp);
+}
+
static void
acl_set_timeout_sec (int timeout_type, u32 value)
{
acl_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
{
acl_main_t *am = &acl_main;
- if (0 == am->acl_mheap)
- {
- /* ACL heap is not initialized, so definitely nothing to do. */
- return 0;
- }
if (0 == is_add)
{
int may_clear_sessions = 1;
if (unformat (input, "main"))
{
if (unformat (input, "validate %u", &val))
- acl_plugin_acl_set_validate_heap (am, val);
+ clib_warning ("ACL local heap is deprecated");
else if (unformat (input, "trace %u", &val))
- acl_plugin_acl_set_trace_heap (am, val);
+ clib_warning ("ACL local heap is deprecated");
goto done;
}
else if (unformat (input, "hash"))
{
if (unformat (input, "validate %u", &val))
- acl_plugin_hash_acl_set_validate_heap (val);
+ clib_warning ("ACL local heap is deprecated");
else if (unformat (input, "trace %u", &val))
- acl_plugin_hash_acl_set_trace_heap (val);
+ clib_warning ("ACL local heap is deprecated");
goto done;
}
goto done;
break;
}
+ unformat_free (line_input);
if (~0 == sw_if_index)
return (clib_error_return (0, "invalid interface"));
if (~0 == acl_index)
acl_interface_add_del_inout_acl (sw_if_index, is_add, is_input, acl_index);
- unformat_free (line_input);
return (NULL);
}
int rv;
int rule_idx = 0;
int n_rules_override = -1;
+ u32 acl_index = ~0;
u32 proto = 0;
u32 port1 = 0;
u32 port2 = 0;
u32 action = 0;
u32 tcpflags, tcpmask;
- u32 src_prefix_length = 0, dst_prefix_length = 0;
- ip4_address_t src_v4address, dst_v4address;
- ip6_address_t src_v6address, dst_v6address;
- u8 *tag = (u8 *) "cli";
+ ip_prefix_t src, dst;
+ u8 *tag = 0;
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, "ipv6"))
- {
- vec_validate_acl_rules (rules, rule_idx);
- rules[rule_idx].is_ipv6 = 1;
- }
- else if (unformat (line_input, "ipv4"))
+ if (unformat (line_input, "index %d", &acl_index))
{
- vec_validate_acl_rules (rules, rule_idx);
- rules[rule_idx].is_ipv6 = 0;
+ /* operate on this acl index (which must exist),
+ * If not specified, or set to -1, create a new ACL
+ */
}
else if (unformat (line_input, "permit+reflect"))
{
vec_validate_acl_rules (rules, rule_idx);
rules[rule_idx].is_permit = action;
}
- else if (unformat (line_input, "src %U/%d",
- unformat_ip4_address, &src_v4address,
- &src_prefix_length))
+ else if (unformat (line_input, "src %U", unformat_ip_prefix, &src))
{
vec_validate_acl_rules (rules, rule_idx);
- memcpy (rules[rule_idx].src_ip_addr, &src_v4address, 4);
- rules[rule_idx].src_ip_prefix_len = src_prefix_length;
- rules[rule_idx].is_ipv6 = 0;
+ ip_prefix_encode2 (&src, &rules[rule_idx].src_prefix);
}
- else if (unformat (line_input, "src %U/%d",
- unformat_ip6_address, &src_v6address,
- &src_prefix_length))
+ else if (unformat (line_input, "dst %U", unformat_ip_prefix, &dst))
{
vec_validate_acl_rules (rules, rule_idx);
- memcpy (rules[rule_idx].src_ip_addr, &src_v6address, 16);
- rules[rule_idx].src_ip_prefix_len = src_prefix_length;
- rules[rule_idx].is_ipv6 = 1;
- }
- else if (unformat (line_input, "dst %U/%d",
- unformat_ip4_address, &dst_v4address,
- &dst_prefix_length))
- {
- vec_validate_acl_rules (rules, rule_idx);
- memcpy (rules[rule_idx].dst_ip_addr, &dst_v4address, 4);
- rules[rule_idx].dst_ip_prefix_len = dst_prefix_length;
- rules[rule_idx].is_ipv6 = 0;
- }
- else if (unformat (line_input, "dst %U/%d",
- unformat_ip6_address, &dst_v6address,
- &dst_prefix_length))
- {
- vec_validate_acl_rules (rules, rule_idx);
- memcpy (rules[rule_idx].dst_ip_addr, &dst_v6address, 16);
- rules[rule_idx].dst_ip_prefix_len = dst_prefix_length;
- rules[rule_idx].is_ipv6 = 1;
+ ip_prefix_encode2 (&dst, &rules[rule_idx].dst_prefix);
}
else if (unformat (line_input, "sport %d-%d", &port1, &port2))
{
break;
}
- u32 acl_index = ~0;
+ if (!tag)
+ vec_add (tag, "cli", 4);
rv = acl_add_list (vec_len (rules), rules, &acl_index, tag);
vec_free (rules);
+ vec_free (tag);
+ unformat_free (line_input);
if (rv)
return (clib_error_return (0, "failed"));
return (NULL);
}
+static clib_error_t *
+acl_delete_aclplugin_acl_fn (vlib_main_t *vm, unformat_input_t *input,
+ vlib_cli_command_t *cmd)
+{
+ unformat_input_t _line_input, *line_input = &_line_input;
+ int rv;
+ u32 acl_index = ~0;
+
+ 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, "index %d", &acl_index))
+ {
+ /* operate on this acl index (which must exist) */
+ }
+ else
+ break;
+ }
+
+ rv = acl_del_list (acl_index);
+
+ unformat_free (line_input);
+ if (rv)
+ return (clib_error_return (0, "failed"));
+
+ vlib_cli_output (vm, "Deleted ACL index:%d", acl_index);
+ return (NULL);
+}
+
static clib_error_t *
acl_show_aclplugin_macip_acl_fn (vlib_main_t * vm,
unformat_input_t *
vlib_cli_command_t * cmd)
{
clib_error_t *error = 0;
- acl_main_t *am = &acl_main;
-
- vlib_cli_output (vm, "ACL plugin main heap statistics:\n");
- if (am->acl_mheap)
- {
- vlib_cli_output (vm, " %U\n", format_mheap, am->acl_mheap, 1);
- }
- else
- {
- vlib_cli_output (vm, " Not initialized\n");
- }
- vlib_cli_output (vm, "ACL hash lookup support heap statistics:\n");
- if (am->hash_lookup_mheap)
- {
- vlib_cli_output (vm, " %U\n", format_mheap, am->hash_lookup_mheap, 1);
- }
- else
- {
- vlib_cli_output (vm, " Not initialized\n");
- }
+ vlib_cli_output (vm, "ACL memory is now part of the main heap");
return error;
}
vlib_cli_output (vm, " link list id: %u", sess->link_list_id);
}
vlib_cli_output (vm, " connection add/del stats:", wk);
- /* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
u32 sw_if_index = swif->sw_if_index;
u64 n_adds =
(sw_if_index < vec_len (pw->fa_session_adds_by_sw_if_index) ?
n_adds -
n_dels,
n_epoch_changes);
- }));
- /* *INDENT-ON* */
+ }
vlib_cli_output (vm, " connection timeout type lists:", wk);
u8 tt = 0;
}
vlib_cli_output (vm, "Stats counters enabled for interface ACLs: %d",
acl_main.interface_acl_counters_enabled);
+ vlib_cli_output (vm, "Use hash-based lookup for ACLs: %d",
+ acl_main.use_hash_acl_matching);
if (show_mask_type)
acl_plugin_show_tables_mask_type ();
if (show_acl_hash_info)
return error;
}
- /* *INDENT-OFF* */
VLIB_CLI_COMMAND (aclplugin_set_command, static) = {
.path = "set acl-plugin",
.short_help = "set acl-plugin session timeout {{udp idle}|tcp {idle|transient}} <seconds>",
/*?
* Create an Access Control List (ACL)
- * an ACL is composed of more than one Access control element (ACE). Multiple
+ * If index is not specified, a new one will be created. Otherwise, replace
+ * the one at this index.
+ *
+ * An ACL is composed of more than one Access control element (ACE). Multiple
* ACEs can be specified with this command using a comma separated list.
*
- * Each ACE describes a tuple of src+dst IP prefix, ip protocol, src+dst port ranges.
- * (the ACL plugin also support ICMP types/codes instead of UDP/TCP ports, but
- * this CLI does not).
+ * Each ACE describes a tuple of src+dst IP prefix, ip protocol, src+dst port
+ * ranges. (the ACL plugin also support ICMP types/codes instead of UDP/TCP
+ * ports, but this CLI does not).
*
- * An ACL can optionally be assigned a 'tag' - which is an identifier understood
- * by the client. VPP does not examine it in any way.
+ * An ACL can optionally be assigned a 'tag' - which is an identifier
+ * understood by the client. VPP does not examine it in any way.
*
- * @cliexpar
- * <b><em> set acl-plugin acl <permit|deny> src <PREFIX> dst <PREFIX> proto <TCP|UDP> sport <X-Y> dport <X-Y> [tag FOO] </b></em>
- * @cliexend
+ * @cliexcmd{set acl-plugin acl <permit|deny|permit+reflect> src <PREFIX> dst
+ * <PREFIX> proto <TCP|UDP> sport <X-Y> dport <X-Y> tcpflags <X> mask <X>
+ * [tag FOO]}
?*/
VLIB_CLI_COMMAND (aclplugin_set_acl_command, static) = {
- .path = "set acl-plugin acl",
- .short_help = "set acl-plugin acl <permit|deny> src <PREFIX> dst <PREFIX> proto X sport X-Y dport X-Y [tag FOO] {use comma separated list for multiple rules}",
- .function = acl_set_aclplugin_acl_fn,
+ .path = "set acl-plugin acl",
+ .short_help =
+ "set acl-plugin acl [index <idx>] <permit|deny|permit+reflect> src "
+ "<PREFIX> dst <PREFIX> [proto X] [sport X[-Y]] [dport X[-Y]] [tcpflags "
+ "<int> mask <int>] [tag FOO] {use comma separated list for multiple "
+ "rules}",
+ .function = acl_set_aclplugin_acl_fn,
+};
+
+/*?
+ * Delete an Access Control List (ACL)
+ * Removes an ACL at the specified index, which must exist but not in use by
+ * any interface.
+ *
+ * @cliexcmd{delete acl-plugin acl index <idx>}
+ ?*/
+VLIB_CLI_COMMAND (aclplugin_delete_acl_command, static) = {
+ .path = "delete acl-plugin acl",
+ .short_help = "delete acl-plugin acl index <idx>",
+ .function = acl_delete_aclplugin_acl_fn,
};
-/* *INDENT-ON* */
static clib_error_t *
acl_plugin_config (vlib_main_t * vm, unformat_input_t * input)
if (unformat
(input, "main heap size %U", unformat_memory_size,
&main_heap_size))
- am->acl_mheap_size = main_heap_size;
+ clib_warning
+ ("WARNING: ACL heap is now part of the main heap. 'main heap size' is ineffective.");
else
if (unformat
(input, "hash lookup heap size %U", unformat_memory_size,
&hash_heap_size))
- am->hash_lookup_mheap_size = hash_heap_size;
- else if (unformat (input, "hash lookup hash buckets %d",
- &hash_lookup_hash_buckets))
+ clib_warning
+ ("WARNING: ACL heap is now part of the main heap. 'hash lookup heap size' is ineffective.");
+ else
+ if (unformat
+ (input, "hash lookup hash buckets %d", &hash_lookup_hash_buckets))
am->hash_lookup_hash_buckets = hash_lookup_hash_buckets;
else
if (unformat
if (error)
return error;
- am->acl_mheap_size = 0; /* auto size when initializing */
- am->hash_lookup_mheap_size = ACL_PLUGIN_HASH_LOOKUP_HEAP_SIZE;
-
am->hash_lookup_hash_buckets = ACL_PLUGIN_HASH_LOOKUP_HASH_BUCKETS;
am->hash_lookup_hash_memory = ACL_PLUGIN_HASH_LOOKUP_HASH_MEMORY;
vec_validate (pw->expired,
ACL_N_TIMEOUTS *
am->fa_max_deleted_sessions_per_interval);
- _vec_len (pw->expired) = 0;
+ vec_set_len (pw->expired, 0);
vec_validate_init_empty (pw->fa_conn_list_head, ACL_N_TIMEOUTS - 1,
FA_SESSION_BOGUS_INDEX);
vec_validate_init_empty (pw->fa_conn_list_tail, ACL_N_TIMEOUTS - 1,
Code Review / vpp.git / blobdiff