#include <vnet/classify/in_out_acl.h>
#include <vpp/app/version.h>
+#include <vnet/ethernet/ethernet_types_api.h>
+
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
/* define message IDs */
-#include <acl/acl_msg_enum.h>
-
-/* define message structures */
-#define vl_typedefs
-#include <acl/acl_all_api_h.h>
-#undef vl_typedefs
-
-/* define generated endian-swappers */
-#define vl_endianfun
-#include <acl/acl_all_api_h.h>
-#undef vl_endianfun
+#include <acl/acl.api_enum.h>
+#include <acl/acl.api_types.h>
-/* instantiate all the print functions we know about */
#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
-#define vl_printfun
-#include <acl/acl_all_api_h.h>
-#undef vl_printfun
-
-/* Get the API version number */
-#define vl_api_version(n,v) static u32 api_version=(v);
-#include <acl/acl_all_api_h.h>
-#undef vl_api_version
+#include "manual_fns.h"
#include "fa_node.h"
#include "public_inlines.h"
#include <vppinfra/bihash_template.h>
#include <vppinfra/bihash_template.c>
-/* List of message types that this plugin understands */
-
-#define foreach_acl_plugin_api_msg \
-_(ACL_PLUGIN_GET_VERSION, acl_plugin_get_version) \
-_(ACL_PLUGIN_CONTROL_PING, acl_plugin_control_ping) \
-_(ACL_ADD_REPLACE, acl_add_replace) \
-_(ACL_DEL, acl_del) \
-_(ACL_INTERFACE_ADD_DEL, acl_interface_add_del) \
-_(ACL_INTERFACE_SET_ACL_LIST, acl_interface_set_acl_list) \
-_(ACL_DUMP, acl_dump) \
-_(ACL_INTERFACE_LIST_DUMP, acl_interface_list_dump) \
-_(MACIP_ACL_ADD, macip_acl_add) \
-_(MACIP_ACL_ADD_REPLACE, macip_acl_add_replace) \
-_(MACIP_ACL_DEL, macip_acl_del) \
-_(MACIP_ACL_INTERFACE_ADD_DEL, macip_acl_interface_add_del) \
-_(MACIP_ACL_DUMP, macip_acl_dump) \
-_(MACIP_ACL_INTERFACE_GET, macip_acl_interface_get) \
-_(MACIP_ACL_INTERFACE_LIST_DUMP, macip_acl_interface_list_dump) \
-_(ACL_INTERFACE_SET_ETYPE_WHITELIST, acl_interface_set_etype_whitelist) \
-_(ACL_INTERFACE_ETYPE_WHITELIST_DUMP, acl_interface_etype_whitelist_dump)
-
-
/* *INDENT-OFF* */
VLIB_PLUGIN_REGISTER () = {
.version = VPP_BUILD_VER,
- .description = "Access Control Lists",
+ .description = "Access Control Lists (ACL)",
};
/* *INDENT-ON* */
acl_plugin_acl_set_validate_heap (acl_main_t * am, int on)
{
clib_mem_set_heap (acl_set_heap (am));
-#if USE_DLMALLOC == 0
- mheap_t *h = mheap_header (am->acl_mheap);
- if (on)
- {
- h->flags |= MHEAP_FLAG_VALIDATE;
- h->flags &= ~MHEAP_FLAG_SMALL_OBJECT_CACHE;
- mheap_validate (h);
- }
- else
- {
- h->flags &= ~MHEAP_FLAG_VALIDATE;
- h->flags |= MHEAP_FLAG_SMALL_OBJECT_CACHE;
- }
-#endif
}
void
acl_plugin_acl_set_trace_heap (acl_main_t * am, int on)
{
clib_mem_set_heap (acl_set_heap (am));
-#if USE_DLMALLOC == 0
- mheap_t *h = mheap_header (am->acl_mheap);
- if (on)
- {
- h->flags |= MHEAP_FLAG_TRACE;
- }
- else
- {
- h->flags &= ~MHEAP_FLAG_TRACE;
- }
-#endif
}
static void
acl_main_t * am, int acl_index)
{
acl_rule_t *r;
+ acl_rule_t *acl_rules = am->acls[acl_index].rules;
u8 *out0 = format (0, "acl-index %u count %u tag {%s}\n", acl_index,
- am->acls[acl_index].count, am->acls[acl_index].tag);
+ vec_len (acl_rules), am->acls[acl_index].tag);
int j;
vpr (vm, out0);
- for (j = 0; j < am->acls[acl_index].count; j++)
+ for (j = 0; j < vec_len (acl_rules); j++)
{
- r = &am->acls[acl_index].rules[j];
+ r = &acl_rules[j];
out0 = format (out0, " %9d: %s ", j, r->is_ipv6 ? "ipv6" : "ipv4");
out0 = format_acl_action (out0, r->is_permit);
out0 = format (out0, " src %U/%d", format_ip46_address, &r->src,
}
}
+static void
+ vl_api_acl_plugin_get_conn_table_max_entries_t_handler
+ (vl_api_acl_plugin_get_conn_table_max_entries_t * mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_plugin_get_conn_table_max_entries_reply_t *rmp;
+ int msg_size = sizeof (*rmp);
+ vl_api_registration_t *rp;
+
+ rp = vl_api_client_index_to_registration (mp->client_index);
+ if (rp == 0)
+ return;
+
+ rmp = vl_msg_api_alloc (msg_size);
+ memset (rmp, 0, msg_size);
+ rmp->_vl_msg_id =
+ 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);
+
+ vl_api_send_msg (rp, (u8 *) rmp);
+}
+
static void
acl_print_acl (vlib_main_t * vm, acl_main_t * am, int acl_index)
{
}
+static void
+validate_and_reset_acl_counters (acl_main_t * am, u32 acl_index)
+{
+ int i;
+ /* counters are set as vectors [acl#] pointing to vectors of [acl rule] */
+ acl_plugin_counter_lock (am);
+
+ int old_len = vec_len (am->combined_acl_counters);
+
+ vec_validate (am->combined_acl_counters, acl_index);
+
+ for (i = old_len; i < vec_len (am->combined_acl_counters); i++)
+ {
+ am->combined_acl_counters[i].name = 0;
+ /* filled in once only */
+ am->combined_acl_counters[i].stat_segment_name = (void *)
+ format (0, "/acl/%d/matches%c", i, 0);
+ i32 rule_count = vec_len (am->acls[i].rules);
+ /* Validate one extra so we always have at least one counter for an ACL */
+ vlib_validate_combined_counter (&am->combined_acl_counters[i],
+ rule_count);
+ vlib_clear_combined_counters (&am->combined_acl_counters[i]);
+ }
+
+ /* (re)validate for the actual ACL that is getting added/updated */
+ i32 rule_count = vec_len (am->acls[acl_index].rules);
+ /* Validate one extra so we always have at least one counter for an ACL */
+ vlib_validate_combined_counter (&am->combined_acl_counters[acl_index],
+ rule_count);
+ vlib_clear_combined_counters (&am->combined_acl_counters[acl_index]);
+ acl_plugin_counter_unlock (am);
+}
+
+static int
+acl_api_invalid_prefix (const vl_api_prefix_t * prefix)
+{
+ ip_prefix_t ip_prefix;
+ return ip_prefix_decode2 (prefix, &ip_prefix);
+}
static int
acl_add_list (u32 count, vl_api_acl_rule_t rules[],
clib_warning ("API dbg: acl_add_list index %d tag %s", *acl_list_index,
tag);
+ /* check if what they request is consistent */
+ for (i = 0; i < count; i++)
+ {
+ if (acl_api_invalid_prefix (&rules[i].src_prefix))
+ return VNET_API_ERROR_INVALID_SRC_ADDRESS;
+ if (acl_api_invalid_prefix (&rules[i].dst_prefix))
+ return VNET_API_ERROR_INVALID_DST_ADDRESS;
+ if (ntohs (rules[i].srcport_or_icmptype_first) >
+ ntohs (rules[i].srcport_or_icmptype_last))
+ return VNET_API_ERROR_INVALID_VALUE_2;
+ if (ntohs (rules[i].dstport_or_icmpcode_first) >
+ ntohs (rules[i].dstport_or_icmpcode_last))
+ return VNET_API_ERROR_INVALID_VALUE_2;
+ }
+
if (*acl_list_index != ~0)
{
/* They supplied some number, let's see if this ACL exists */
r = vec_elt_at_index (acl_new_rules, i);
clib_memset (r, 0, sizeof (*r));
r->is_permit = rules[i].is_permit;
- r->is_ipv6 = rules[i].is_ipv6;
- if (r->is_ipv6)
- {
- memcpy (&r->src, rules[i].src_ip_addr, sizeof (r->src));
- memcpy (&r->dst, rules[i].dst_ip_addr, sizeof (r->dst));
- }
- else
- {
- memcpy (&r->src.ip4, rules[i].src_ip_addr, sizeof (r->src.ip4));
- memcpy (&r->dst.ip4, rules[i].dst_ip_addr, sizeof (r->dst.ip4));
- }
- r->src_prefixlen = rules[i].src_ip_prefix_len;
- r->dst_prefixlen = rules[i].dst_ip_prefix_len;
+ r->is_ipv6 = rules[i].src_prefix.address.af;
+ ip_address_decode (&rules[i].src_prefix.address, &r->src);
+ ip_address_decode (&rules[i].dst_prefix.address, &r->dst);
+ r->src_prefixlen = rules[i].src_prefix.len;
+ r->dst_prefixlen = rules[i].dst_prefix.len;
r->proto = rules[i].proto;
r->src_port_or_type_first = ntohs (rules[i].srcport_or_icmptype_first);
r->src_port_or_type_last = ntohs (rules[i].srcport_or_icmptype_last);
vec_free (a->rules);
}
a->rules = acl_new_rules;
- a->count = count;
memcpy (a->tag, tag, sizeof (a->tag));
if (am->trace_acl > 255)
warning_acl_print_acl (am->vlib_main, am, *acl_list_index);
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 rv;
}
+static int
+acl_stats_intf_counters_enable_disable (acl_main_t * am, int enable_disable)
+{
+ int rv = 0;
+
+ am->interface_acl_counters_enabled = enable_disable;
+
+ return rv;
+}
+
static int
acl_interface_inout_enable_disable (acl_main_t * am, u32 sw_if_index,
int is_input, int enable_disable)
u32 lc_index = (*pinout_lc_index_by_sw_if_index)[sw_if_index];
if (~0 == lc_index)
{
- if (~0 == am->interface_acl_user_id)
- am->interface_acl_user_id =
- acl_plugin.register_user_module ("interface ACL", "sw_if_index",
- "is_input");
lc_index =
acl_plugin.get_lookup_context_index (am->interface_acl_user_id,
sw_if_index, is_input);
{
r = &acl_new_rules[i];
r->is_permit = rules[i].is_permit;
- r->is_ipv6 = rules[i].is_ipv6;
- memcpy (&r->src_mac, rules[i].src_mac, 6);
- memcpy (&r->src_mac_mask, rules[i].src_mac_mask, 6);
- if (rules[i].is_ipv6)
- memcpy (&r->src_ip_addr.ip6, rules[i].src_ip_addr, 16);
- else
- memcpy (&r->src_ip_addr.ip4, rules[i].src_ip_addr, 4);
- r->src_prefixlen = rules[i].src_ip_prefix_len;
+ r->is_ipv6 = rules[i].src_prefix.address.af;
+ mac_address_decode (rules[i].src_mac, (mac_address_t *) & r->src_mac);
+ mac_address_decode (rules[i].src_mac_mask,
+ (mac_address_t *) & r->src_mac_mask);
+ ip_address_decode (&rules[i].src_prefix.address, &r->src_ip_addr);
+ r->src_prefixlen = rules[i].src_prefix.len;
}
if (~0 == *acl_list_index)
REPLY_MACRO (VL_API_ACL_DEL_REPLY);
}
+
+static void
+ vl_api_acl_stats_intf_counters_enable_t_handler
+ (vl_api_acl_stats_intf_counters_enable_t * mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_stats_intf_counters_enable_reply_t *rmp;
+ int rv;
+
+ rv = acl_stats_intf_counters_enable_disable (am, mp->enable);
+
+ REPLY_MACRO (VL_API_ACL_DEL_REPLY);
+}
+
+
static void
vl_api_acl_interface_add_del_t_handler (vl_api_acl_interface_add_del_t * mp)
{
copy_acl_rule_to_api_rule (vl_api_acl_rule_t * api_rule, acl_rule_t * r)
{
api_rule->is_permit = r->is_permit;
- api_rule->is_ipv6 = r->is_ipv6;
- if (r->is_ipv6)
- {
- memcpy (api_rule->src_ip_addr, &r->src, sizeof (r->src));
- memcpy (api_rule->dst_ip_addr, &r->dst, sizeof (r->dst));
- }
- else
- {
- memcpy (api_rule->src_ip_addr, &r->src.ip4, sizeof (r->src.ip4));
- memcpy (api_rule->dst_ip_addr, &r->dst.ip4, sizeof (r->dst.ip4));
- }
- api_rule->src_ip_prefix_len = r->src_prefixlen;
- api_rule->dst_ip_prefix_len = r->dst_prefixlen;
+ ip_address_encode (&r->src, r->is_ipv6 ? IP46_TYPE_IP6 : IP46_TYPE_IP4,
+ &api_rule->src_prefix.address);
+ ip_address_encode (&r->dst, r->is_ipv6 ? IP46_TYPE_IP6 : IP46_TYPE_IP4,
+ &api_rule->dst_prefix.address);
+ api_rule->src_prefix.len = r->src_prefixlen;
+ api_rule->dst_prefix.len = r->dst_prefixlen;
api_rule->proto = r->proto;
api_rule->srcport_or_icmptype_first = htons (r->src_port_or_type_first);
api_rule->srcport_or_icmptype_last = htons (r->src_port_or_type_last);
vl_api_acl_details_t *mp;
vl_api_acl_rule_t *rules;
int i;
- int msg_size = sizeof (*mp) + sizeof (mp->r[0]) * acl->count;
+ 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);
/* fill in the message */
mp->context = context;
- mp->count = htonl (acl->count);
+ mp->count = htonl (vec_len (acl_rules));
mp->acl_index = htonl (acl - am->acls);
memcpy (mp->tag, acl->tag, sizeof (mp->tag));
// clib_memcpy (mp->r, acl->rules, acl->count * sizeof(acl->rules[0]));
rules = mp->r;
- for (i = 0; i < acl->count; i++)
+ for (i = 0; i < vec_len (acl_rules); i++)
{
- copy_acl_rule_to_api_rule (&rules[i], &acl->rules[i]);
+ copy_acl_rule_to_api_rule (&rules[i], &acl_rules[i]);
}
clib_mem_set_heap (oldheap);
{
r = &acl->rules[i];
rules[i].is_permit = r->is_permit;
- rules[i].is_ipv6 = r->is_ipv6;
- memcpy (rules[i].src_mac, &r->src_mac, sizeof (r->src_mac));
- memcpy (rules[i].src_mac_mask, &r->src_mac_mask,
- sizeof (r->src_mac_mask));
- if (r->is_ipv6)
- memcpy (rules[i].src_ip_addr, &r->src_ip_addr.ip6,
- sizeof (r->src_ip_addr.ip6));
- else
- memcpy (rules[i].src_ip_addr, &r->src_ip_addr.ip4,
- sizeof (r->src_ip_addr.ip4));
- rules[i].src_ip_prefix_len = r->src_prefixlen;
+ mac_address_encode ((mac_address_t *) & r->src_mac,
+ rules[i].src_mac);
+ mac_address_encode ((mac_address_t *) & r->src_mac_mask,
+ rules[i].src_mac_mask);
+ ip_address_encode (&r->src_ip_addr,
+ r->is_ipv6 ? IP46_TYPE_IP6 : IP46_TYPE_IP4,
+ &rules[i].src_prefix.address);
+ rules[i].src_prefix.len = r->src_prefixlen;
}
}
else
if (mp->acl_index == ~0)
{
/* Just dump all ACLs for now, with sw_if_index = ~0 */
- pool_foreach (acl, am->macip_acls, (
- {
- send_macip_acl_details (am, reg,
- acl,
- mp->context);
- }
- ));
+ /* *INDENT-OFF* */
+ pool_foreach (acl, am->macip_acls,
+ ({
+ send_macip_acl_details (am, reg, acl, mp->context);
+ }));
/* *INDENT-ON* */
}
else
}
}
-
-
-/* Set up the API message handling tables */
-static clib_error_t *
-acl_plugin_api_hookup (vlib_main_t * vm)
-{
- acl_main_t *am = &acl_main;
-#define _(N,n) \
- vl_msg_api_set_handlers((VL_API_##N + am->msg_id_base), \
- #n, \
- vl_api_##n##_t_handler, \
- vl_noop_handler, \
- vl_api_##n##_t_endian, \
- vl_api_##n##_t_print, \
- sizeof(vl_api_##n##_t), 1);
- foreach_acl_plugin_api_msg;
-#undef _
-
- return 0;
-}
-
-#define vl_msg_name_crc_list
-#include <acl/acl_all_api_h.h>
-#undef vl_msg_name_crc_list
-
-static void
-setup_message_id_table (acl_main_t * am, api_main_t * apim)
-{
-#define _(id,n,crc) \
- vl_msg_api_add_msg_name_crc (apim, #n "_" #crc, id + am->msg_id_base);
- foreach_vl_msg_name_crc_acl;
-#undef _
-}
-
static void
acl_set_timeout_sec (int timeout_type, u32 value)
{
}
+static clib_error_t *
+acl_set_aclplugin_interface_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ unformat_input_t _line_input, *line_input = &_line_input;
+ u32 sw_if_index, is_add, is_input, acl_index;
+
+ is_add = is_input = 1;
+ acl_index = sw_if_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, "%U",
+ unformat_vnet_sw_interface, vnet_get_main (),
+ &sw_if_index))
+ ;
+ else if (unformat (line_input, "add"))
+ is_add = 1;
+ else if (unformat (line_input, "del"))
+ is_add = 0;
+ else if (unformat (line_input, "acl %d", &acl_index))
+ ;
+ else if (unformat (line_input, "input"))
+ is_input = 1;
+ else if (unformat (line_input, "output"))
+ is_input = 0;
+ else
+ break;
+ }
+
+ if (~0 == sw_if_index)
+ return (clib_error_return (0, "invalid interface"));
+ if (~0 == acl_index)
+ return (clib_error_return (0, "invalid acl"));
+
+ acl_interface_add_del_inout_acl (sw_if_index, is_add, is_input, acl_index);
+
+ unformat_free (line_input);
+ return (NULL);
+}
+
+#define vec_validate_acl_rules(v, idx) \
+ do { \
+ if (vec_len(v) < idx+1) { \
+ vec_validate(v, idx); \
+ v[idx].is_permit = 0x1; \
+ v[idx].srcport_or_icmptype_last = 0xffff; \
+ v[idx].dstport_or_icmpcode_last = 0xffff; \
+ } \
+ } while (0)
+
+static clib_error_t *
+acl_set_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;
+ vl_api_acl_rule_t *rules = 0;
+ int rv;
+ int rule_idx = 0;
+ int n_rules_override = -1;
+ u32 proto = 0;
+ u32 port1 = 0;
+ u32 port2 = 0;
+ u32 action = 0;
+ u32 tcpflags, tcpmask;
+ u32 src_prefix_length = 0, dst_prefix_length = 0;
+ ip46_address_t src, dst;
+ u8 *tag = (u8 *) "cli";
+
+ 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, "permit+reflect"))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].is_permit = 2;
+ }
+ else if (unformat (line_input, "permit"))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].is_permit = 1;
+ }
+ else if (unformat (line_input, "deny"))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].is_permit = 0;
+ }
+ else if (unformat (line_input, "count %d", &n_rules_override))
+ {
+ /* we will use this later */
+ }
+ else if (unformat (line_input, "action %d", &action))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].is_permit = action;
+ }
+ else if (unformat (line_input, "src %U/%d",
+ unformat_ip46_address, &src, &src_prefix_length))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ ip_address_encode (&src, IP46_TYPE_ANY,
+ &rules[rule_idx].src_prefix.address);
+ rules[rule_idx].src_prefix.address.af = ADDRESS_IP4;
+ rules[rule_idx].src_prefix.len = src_prefix_length;
+ }
+ else if (unformat (line_input, "dst %U/%d",
+ unformat_ip46_address, &dst, &dst_prefix_length))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ ip_address_encode (&dst, IP46_TYPE_ANY,
+ &rules[rule_idx].dst_prefix.address);
+ rules[rule_idx].dst_prefix.address.af = ADDRESS_IP4;
+ rules[rule_idx].dst_prefix.len = dst_prefix_length;
+ }
+ else if (unformat (line_input, "sport %d-%d", &port1, &port2))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].srcport_or_icmptype_first = htons (port1);
+ rules[rule_idx].srcport_or_icmptype_last = htons (port2);
+ }
+ else if (unformat (line_input, "sport %d", &port1))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].srcport_or_icmptype_first = htons (port1);
+ rules[rule_idx].srcport_or_icmptype_last = htons (port1);
+ }
+ else if (unformat (line_input, "dport %d-%d", &port1, &port2))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].dstport_or_icmpcode_first = htons (port1);
+ rules[rule_idx].dstport_or_icmpcode_last = htons (port2);
+ }
+ else if (unformat (line_input, "dport %d", &port1))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].dstport_or_icmpcode_first = htons (port1);
+ rules[rule_idx].dstport_or_icmpcode_last = htons (port1);
+ }
+ else if (unformat (line_input, "tcpflags %d %d", &tcpflags, &tcpmask))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].tcp_flags_value = tcpflags;
+ rules[rule_idx].tcp_flags_mask = tcpmask;
+ }
+ else
+ if (unformat (line_input, "tcpflags %d mask %d", &tcpflags, &tcpmask))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].tcp_flags_value = tcpflags;
+ rules[rule_idx].tcp_flags_mask = tcpmask;
+ }
+ else if (unformat (line_input, "proto %d", &proto))
+ {
+ vec_validate_acl_rules (rules, rule_idx);
+ rules[rule_idx].proto = proto;
+ }
+ else if (unformat (line_input, "tag %s", &tag))
+ {
+ }
+ else if (unformat (line_input, ","))
+ {
+ rule_idx++;
+ vec_validate_acl_rules (rules, rule_idx);
+ }
+ else
+ break;
+ }
+
+ u32 acl_index = ~0;
+
+ rv = acl_add_list (vec_len (rules), rules, &acl_index, tag);
+
+ vec_free (rules);
+
+ if (rv)
+ return (clib_error_return (0, "failed"));
+
+ vlib_cli_output (vm, "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_output (vm, " link list id: %u", sess->link_list_id);
}
vlib_cli_output (vm, " connection add/del stats:", wk);
- 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)
- ?
- pw->fa_session_adds_by_sw_if_index
- [sw_if_index] : 0;
- u64 n_dels =
- sw_if_index <
- vec_len
- (pw->fa_session_dels_by_sw_if_index)
- ?
- pw->fa_session_dels_by_sw_if_index
- [sw_if_index] : 0;
- u64 n_epoch_changes =
- sw_if_index <
- vec_len
- (pw->fa_session_epoch_change_by_sw_if_index)
- ?
- pw->fa_session_epoch_change_by_sw_if_index
- [sw_if_index] : 0;
- vlib_cli_output (vm,
- " sw_if_index %d: add %lu - del %lu = %lu; epoch chg: %lu",
- sw_if_index,
- n_adds,
- n_dels,
- n_adds -
- n_dels,
- n_epoch_changes);
- }
- ));
+ /* *INDENT-OFF* */
+ 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) ?
+ pw->fa_session_adds_by_sw_if_index[sw_if_index] :
+ 0);
+ u64 n_dels =
+ (sw_if_index < vec_len (pw->fa_session_dels_by_sw_if_index) ?
+ pw->fa_session_dels_by_sw_if_index[sw_if_index] :
+ 0);
+ u64 n_epoch_changes =
+ (sw_if_index < vec_len (pw->fa_session_epoch_change_by_sw_if_index) ?
+ pw->fa_session_epoch_change_by_sw_if_index[sw_if_index] :
+ 0);
+ vlib_cli_output (vm,
+ " sw_if_index %d: add %lu - del %lu = %lu; epoch chg: %lu",
+ sw_if_index,
+ n_adds,
+ n_dels,
+ n_adds -
+ n_dels,
+ n_epoch_changes);
+ }));
+ /* *INDENT-ON* */
vlib_cli_output (vm, " connection timeout type lists:", wk);
u8 tt = 0;
show_applied_info = 1;
show_bihash = 1;
}
+ vlib_cli_output (vm, "Stats counters enabled for interface ACLs: %d",
+ acl_main.interface_acl_counters_enabled);
if (show_mask_type)
acl_plugin_show_tables_mask_type ();
if (show_acl_hash_info)
.short_help = "clear acl-plugin sessions",
.function = acl_clear_aclplugin_fn,
};
+
+/*?
+ * [un]Apply an ACL to an interface.
+ * The ACL is applied in a given direction, either input or output.
+ * The ACL being applied must already exist.
+ *
+ * @cliexpar
+ * <b><em> set acl-plugin interface <input|output> acl <index> [del] </b></em>
+ * @cliexend
+ ?*/
+VLIB_CLI_COMMAND (aclplugin_set_interface_command, static) = {
+ .path = "set acl-plugin interface",
+ .short_help = "set acl-plugin interface <interface> <input|output> <acl INDEX> [del] ",
+ .function = acl_set_aclplugin_interface_fn,
+};
+
+/*?
+ * Create an Access Control List (ACL)
+ * 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).
+ *
+ * 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
+ ?*/
+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,
+};
/* *INDENT-ON* */
static clib_error_t *
VLIB_CONFIG_FUNCTION (acl_plugin_config, "acl-plugin");
+/* Set up the API message handling tables */
+#include <vnet/format_fns.h>
+#include <acl/acl.api.c>
+
static clib_error_t *
acl_init (vlib_main_t * vm)
{
am->vnet_main = vnet_get_main ();
am->log_default = vlib_log_register_class ("acl_plugin", 0);
- u8 *name = format (0, "acl_%08x%c", api_version, 0);
-
/* Ask for a correctly-sized block of API message decode slots */
- am->msg_id_base = vl_msg_api_get_msg_ids ((char *) name,
- VL_MSG_FIRST_AVAILABLE);
-
- error = acl_plugin_api_hookup (vm);
-
- /* Add our API messages to the global name_crc hash table */
- setup_message_id_table (am, &api_main);
-
- vec_free (name);
-
- if (error)
- return error;
+ am->msg_id_base = setup_message_id_table ();
error = acl_plugin_exports_init (&acl_plugin);
/* Set the default threshold */
am->tuple_merge_split_threshold = TM_SPLIT_THRESHOLD;
- am->interface_acl_user_id = ~0; /* defer till the first use */
+ am->interface_acl_user_id =
+ acl_plugin.register_user_module ("interface ACL", "sw_if_index",
+ "is_input");
+
+ am->acl_counter_lock = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,
+ CLIB_CACHE_LINE_BYTES);
+ am->acl_counter_lock[0] = 0; /* should be no need */
return error;
}
Code Review / vpp.git / blobdiff