X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Facl%2Facl.c;h=b18e8515cde5026e964b80a8349331f31c459ff6;hb=df87f8092;hp=4f63a975267ea02d0b3178fbbaa670588f62d812;hpb=4bc1796b346efd10f3fb19b176ff089179263a24;p=vpp.git diff --git a/src/plugins/acl/acl.c b/src/plugins/acl/acl.c index 4f63a975267..b18e8515cde 100644 --- a/src/plugins/acl/acl.c +++ b/src/plugins/acl/acl.c @@ -20,41 +20,28 @@ #include #include +#include #include #include +#include +#include +#include +#include + #include #include /* define message IDs */ -#include - -/* define message structures */ -#define vl_typedefs -#include -#undef vl_typedefs +#include +#include -/* define generated endian-swappers */ -#define vl_endianfun -#include -#undef vl_endianfun - -/* instantiate all the print functions we know about */ #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) -#define vl_printfun -#include -#undef vl_printfun - -/* Get the API version number */ -#define vl_api_version(n,v) static u32 api_version=(v); -#include -#undef vl_api_version #include "fa_node.h" #include "public_inlines.h" acl_main_t acl_main; -acl_main_t *p_acl_main = &acl_main; #define REPLY_MSG_ID_BASE am->msg_id_base #include @@ -66,35 +53,16 @@ acl_main_t *p_acl_main = &acl_main; #include #include -/* 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* */ +/* methods exported from ACL-as-a-service */ +static acl_plugin_methods_t acl_plugin; + /* Format vec16. */ u8 * format_vec16 (u8 * s, va_list * va) @@ -111,99 +79,6 @@ format_vec16 (u8 * s, va_list * va) return s; } - - -u8 -acl_plugin_acl_exists (u32 acl_index) -{ - acl_main_t *am = &acl_main; - - if (pool_is_free_index (am->acls, acl_index)) - return 0; - - return 1; -} - -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 (0 /* use VM */ , am->acl_mheap_size); - 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); - } - mheap_t *h = mheap_header (am->acl_mheap); - h->flags |= MHEAP_FLAG_THREAD_SAFE; - } - 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)); - 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; - } -} - -void -acl_plugin_acl_set_trace_heap (acl_main_t * am, int on) -{ - clib_mem_set_heap (acl_set_heap (am)); - mheap_t *h = mheap_header (am->acl_mheap); - if (on) - { - h->flags |= MHEAP_FLAG_TRACE; - } - else - { - h->flags &= ~MHEAP_FLAG_TRACE; - } -} - static void vl_api_acl_plugin_get_version_t_handler (vl_api_acl_plugin_get_version_t * mp) { @@ -217,7 +92,7 @@ vl_api_acl_plugin_get_version_t_handler (vl_api_acl_plugin_get_version_t * mp) return; rmp = vl_msg_api_alloc (msg_size); - memset (rmp, 0, msg_size); + clib_memset (rmp, 0, msg_size); rmp->_vl_msg_id = ntohs (VL_API_ACL_PLUGIN_GET_VERSION_REPLY + am->msg_id_base); rmp->context = mp->context; @@ -259,19 +134,40 @@ print_cli_and_reset (vlib_main_t * vm, u8 * out0) 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) { 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]; - out0 = format (out0, " %4d: %s ", j, r->is_ipv6 ? "ipv6" : "ipv4"); + 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, r->is_ipv6 ? IP46_TYPE_IP6 : IP46_TYPE_IP4, @@ -301,6 +197,30 @@ acl_print_acl_x (acl_vector_print_func_t vpr, vlib_main_t * vm, } } +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) { @@ -352,6 +272,45 @@ policy_notify_acl_change (acl_main_t * am, u32 acl_num) } +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[], @@ -367,6 +326,21 @@ 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 */ @@ -386,8 +360,6 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], *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); @@ -395,21 +367,13 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], for (i = 0; i < count; i++) { r = vec_elt_at_index (acl_new_rules, i); - memset (r, 0, sizeof (*r)); + 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); @@ -423,7 +387,7 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], { /* Get ACL index */ pool_get_aligned (am->acls, a, CLIB_CACHE_LINE_BYTES); - memset (a, 0, sizeof (*a)); + clib_memset (a, 0, sizeof (*a)); /* Will return the newly allocated ACL index */ *acl_list_index = a - am->acls; } @@ -435,7 +399,6 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], 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); @@ -444,10 +407,8 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], /* a change in an ACLs if they are applied may mean a new policy epoch */ policy_notify_acl_change (am, *acl_list_index); } - - /* notify the lookup contexts about the ACL changes */ + validate_and_reset_acl_counters (am, *acl_list_index); acl_plugin_lookup_context_notify_acl_change (*acl_list_index); - clib_mem_set_heap (oldheap); return 0; } @@ -478,12 +439,10 @@ acl_del_list (u32 acl_list_index) return VNET_API_ERROR_ACL_IN_USE_INBOUND; if (acl_is_used_by (acl_list_index, am->output_sw_if_index_vec_by_acl)) return VNET_API_ERROR_ACL_IN_USE_OUTBOUND; - /* lookup contexts cover other cases, not just inbound/oubound, so check that */ + /* lookup contexts cover other cases, not just inbound/outbound, so check that */ 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) @@ -491,90 +450,9 @@ acl_del_list (u32 acl_list_index) 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; } -/* Some aids in ASCII graphing the content */ -#define XX "\377" -#define __ "\000" -#define _(x) -#define v -/* *INDENT-OFF* */ - -u8 ip4_5tuple_mask[] = - _(" dmac smac etype ") - _(ether) __ __ __ __ __ __ v __ __ __ __ __ __ v __ __ v - _(" v ihl totlen ") - _(0x0000) - __ __ __ __ - _(" ident fl+fo ") - _(0x0004) - __ __ __ __ - _(" ttl pr checksum ") - _(0x0008) - __ XX __ __ - _(" src address ") - _(0x000C) - XX XX XX XX - _(" dst address ") - _(0x0010) - XX XX XX XX - _("L4 T/U sport dport ") - _(tcpudp) - XX XX XX XX - _(padpad) - __ __ __ __ - _(padpad) - __ __ __ __ - _(padeth) - __ __; - - u8 ip6_5tuple_mask[] = - _(" dmac smac etype ") - _(ether) __ __ __ __ __ __ v __ __ __ __ __ __ v __ __ v - _(" v tc + flow ") - _(0x0000) __ __ __ __ - _(" plen nh hl ") - _(0x0004) __ __ XX __ - _(" src address ") - _(0x0008) XX XX XX XX - _(0x000C) XX XX XX XX - _(0x0010) XX XX XX XX - _(0x0014) XX XX XX XX - _(" dst address ") - _(0x0018) XX XX XX XX - _(0x001C) XX XX XX XX - _(0x0020) XX XX XX XX - _(0x0024) XX XX XX XX - _("L4T/U sport dport ") - _(tcpudp) XX XX XX XX _(padpad) __ __ __ __ _(padeth) __ __; - - u8 dot1q_5tuple_mask[] = - _(" dmac smac dot1q etype ") - _(ether) __ __ __ __ __ __ v __ __ __ __ __ __ v XX XX __ __ v XX XX v - _(padpad) __ __ __ __ - _(padpad) __ __ __ __ - _(padpad) __ __ __ __ - _(padeth) __ __; - - u8 dot1ad_5tuple_mask[] = - _(" dmac smac dot1ad dot1q etype ") - _(ether) __ __ __ __ __ __ v __ __ __ __ __ __ v XX XX __ __ XX XX __ __ v XX XX v - _(padpad) __ __ __ __ - _(padpad) __ __ __ __ - _(padeth) __ __; - - u8 ethertype_mask[] = - _(" dmac smac etype ") - _(ether) __ __ __ __ __ __ v __ __ __ __ __ __ v XX XX __ __; - -/* *INDENT-ON* */ -#undef XX -#undef __ -#undef _ -#undef v - static int count_skip (u8 * p, u32 size) { @@ -590,33 +468,6 @@ count_skip (u8 * p, u32 size) return (p64 - (u64 *) p) / 2; } -static int -acl_classify_add_del_table_tiny (vnet_classify_main_t * cm, u8 * mask, - u32 mask_len, u32 next_table_index, - u32 miss_next_index, u32 * table_index, - int is_add) -{ - u32 nbuckets = 1; - u32 memory_size = 2 << 13; - u32 skip = count_skip (mask, mask_len); - u32 match = (mask_len / 16) - skip; - u8 *skip_mask_ptr = mask + 16 * skip; - u32 current_data_flag = 0; - int current_data_offset = 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 int acl_classify_add_del_table_small (vnet_classify_main_t * cm, u8 * mask, u32 mask_len, u32 next_table_index, @@ -634,524 +485,31 @@ acl_classify_add_del_table_small (vnet_classify_main_t * cm, u8 * mask, 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 int -acl_unhook_l2_input_classify (acl_main_t * am, u32 sw_if_index) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u32 ip4_table_index = ~0; - u32 ip6_table_index = ~0; - u32 dot1q_table_index = ~0; - u32 dot1ad_table_index = ~0; - u32 etype_table_index = ~0; - void *oldheap = acl_set_heap (am); - - vec_validate_init_empty (am->acl_ip4_input_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_ip6_input_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_dot1q_input_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_dot1ad_input_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_etype_input_classify_table_by_sw_if_index, - sw_if_index, ~0); - - /* switch to global heap while calling vnet_* functions */ - clib_mem_set_heap (cm->vlib_main->heap_base); - vnet_l2_input_classify_enable_disable (sw_if_index, 0); - - if (am->acl_ip4_input_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - ip4_table_index = - am->acl_ip4_input_classify_table_by_sw_if_index[sw_if_index]; - am->acl_ip4_input_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip4, - &ip4_table_index, 0); - } - if (am->acl_ip6_input_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - ip6_table_index = - am->acl_ip6_input_classify_table_by_sw_if_index[sw_if_index]; - am->acl_ip6_input_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip6, - &ip6_table_index, 0); - } - if (am->acl_dot1q_input_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - dot1q_table_index = - am->acl_dot1q_input_classify_table_by_sw_if_index[sw_if_index]; - am->acl_dot1q_input_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - ~0, &dot1q_table_index, 0); - } - if (am->acl_dot1ad_input_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - dot1ad_table_index = - am->acl_dot1ad_input_classify_table_by_sw_if_index[sw_if_index]; - am->acl_dot1ad_input_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - } - if (am->acl_etype_input_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - etype_table_index = - am->acl_etype_input_classify_table_by_sw_if_index[sw_if_index]; - am->acl_etype_input_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ethertype_mask, - sizeof (ethertype_mask) - 1, ~0, - ~0, &etype_table_index, 0); - } - clib_mem_set_heap (oldheap); - return 0; -} - -static int -acl_unhook_l2_output_classify (acl_main_t * am, u32 sw_if_index) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u32 ip4_table_index = ~0; - u32 ip6_table_index = ~0; - u32 dot1q_table_index = ~0; - u32 dot1ad_table_index = ~0; - u32 etype_table_index = ~0; - void *oldheap = acl_set_heap (am); - - vec_validate_init_empty (am->acl_ip4_output_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_ip6_output_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty (am->acl_dot1q_output_classify_table_by_sw_if_index, - sw_if_index, ~0); - vec_validate_init_empty - (am->acl_dot1ad_output_classify_table_by_sw_if_index, sw_if_index, ~0); - vec_validate_init_empty (am->acl_etype_output_classify_table_by_sw_if_index, - sw_if_index, ~0); - - /* switch to global heap while calling vnet_* functions */ - clib_mem_set_heap (cm->vlib_main->heap_base); - - vnet_l2_output_classify_enable_disable (sw_if_index, 0); - - if (am->acl_ip4_output_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - ip4_table_index = - am->acl_ip4_output_classify_table_by_sw_if_index[sw_if_index]; - am->acl_ip4_output_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip4, - &ip4_table_index, 0); - } - if (am->acl_ip6_output_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - ip6_table_index = - am->acl_ip6_output_classify_table_by_sw_if_index[sw_if_index]; - am->acl_ip6_output_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip6, - &ip6_table_index, 0); - } - if (am->acl_dot1q_output_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - dot1q_table_index = - am->acl_dot1q_output_classify_table_by_sw_if_index[sw_if_index]; - am->acl_dot1q_output_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - ~0, &dot1q_table_index, 0); - } - if (am->acl_dot1ad_output_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - dot1ad_table_index = - am->acl_dot1ad_output_classify_table_by_sw_if_index[sw_if_index]; - am->acl_dot1ad_output_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - } - if (am->acl_etype_output_classify_table_by_sw_if_index[sw_if_index] != ~0) - { - etype_table_index = - am->acl_etype_output_classify_table_by_sw_if_index[sw_if_index]; - am->acl_etype_output_classify_table_by_sw_if_index[sw_if_index] = ~0; - acl_classify_add_del_table_tiny (cm, ethertype_mask, - sizeof (ethertype_mask) - 1, ~0, - ~0, &etype_table_index, 0); - } - clib_mem_set_heap (oldheap); - return 0; -} - -static void -acl_add_vlan_session (acl_main_t * am, u32 table_index, u8 is_output, - u8 is_dot1ad, u8 is_ip6) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u8 *match; - u32 next_acl; - u8 idx; - u8 session_idx; - - if (is_ip6) - { - next_acl = - (is_output) ? am-> - l2_output_classify_next_acl_ip6 : am->l2_input_classify_next_acl_ip6; - } - else - { - next_acl = - (is_output) ? am-> - l2_output_classify_next_acl_ip4 : am->l2_input_classify_next_acl_ip4; - } - match = (is_dot1ad) ? dot1ad_5tuple_mask : dot1q_5tuple_mask; - idx = (is_dot1ad) ? 20 : 16; - if (is_dot1ad) - { - /* 802.1ad ethertype */ - match[12] = 0x88; - match[13] = 0xa8; - /* 802.1q ethertype */ - match[16] = 0x81; - match[17] = 0x00; - } - else - { - /* 802.1q ethertype */ - match[12] = 0x81; - match[13] = 0x00; - } - - /* add sessions to vlan tables per ethernet_type */ - if (is_ip6) - { - match[idx] = 0x86; - match[idx + 1] = 0xdd; - session_idx = 1; - } - else - { - match[idx] = 0x08; - match[idx + 1] = 0x00; - session_idx = 0; - } - vnet_classify_add_del_session (cm, table_index, match, next_acl, - session_idx, 0, 0, 0, 1); - /* reset the mask back to being a mask */ - match[idx] = 0xff; - match[idx + 1] = 0xff; - match[12] = 0xff; - match[13] = 0xff; - if (is_dot1ad) - { - match[16] = 0xff; - match[17] = 0xff; - } -} - static int intf_has_etype_whitelist (acl_main_t * am, u32 sw_if_index, int is_input) { u16 **v = is_input ? am->input_etype_whitelist_by_sw_if_index : am->output_etype_whitelist_by_sw_if_index; - return ((vec_len (v) > sw_if_index) && vec_elt (v, sw_if_index)); -} - -static int -etype_whitelist_add_sessions (acl_main_t * am, u32 sw_if_index, int is_input, - u32 etype_table_index) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u16 **v = is_input - ? am->input_etype_whitelist_by_sw_if_index - : am->output_etype_whitelist_by_sw_if_index; - u8 *match = ethertype_mask; - - int i; - int rv = 0; - u16 *whitelist = vec_elt (v, sw_if_index); - u32 next = ~0; /* permit */ - for (i = 0; i < vec_len (whitelist); i++) - { - /* big-endian */ - match[12] = (whitelist[i] >> 8) & 0xff; - match[13] = whitelist[i] & 0xff; - rv = rv - || vnet_classify_add_del_session (cm, etype_table_index, match, next, - whitelist[i], 0, 0, 0, 1); - } - - /* restore the mask */ - match[12] = 0xff; - match[13] = 0xff; - return rv; -} - -static int -acl_hook_l2_input_classify (acl_main_t * am, u32 sw_if_index) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u32 ip4_table_index = ~0; - u32 ip6_table_index = ~0; - u32 dot1q_table_index = ~0; - u32 dot1ad_table_index = ~0; - u32 etype_table_index = ~0; - int rv; - - void *prevheap = clib_mem_set_heap (cm->vlib_main->heap_base); - - /* in case there were previous tables attached */ - acl_unhook_l2_input_classify (am, sw_if_index); - rv = - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip4, - &ip4_table_index, 1); - if (rv) - goto done; - - rv = - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip6, - &ip6_table_index, 1); - if (rv) - { - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip4, - &ip4_table_index, 0); - goto done; - } - - if (intf_has_etype_whitelist (am, sw_if_index, 1)) - { - acl_classify_add_del_table_tiny (cm, ethertype_mask, sizeof (ethertype_mask) - 1, ~0, 0, /* drop if no match */ - &etype_table_index, 1); - etype_whitelist_add_sessions (am, sw_if_index, 1, etype_table_index); - } - - rv = - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, - etype_table_index, ~0, - &dot1ad_table_index, 1); - rv = - acl_classify_add_del_table_tiny (cm, dot1q_5tuple_mask, - sizeof (dot1q_5tuple_mask) - 1, - dot1ad_table_index, ~0, - &dot1q_table_index, 1); - if (rv) - { - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip6, - &ip6_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip4, - &ip4_table_index, 0); - goto done; - } - - rv = - vnet_l2_input_classify_set_tables (sw_if_index, ip4_table_index, - ip6_table_index, dot1q_table_index); - - if (rv) - { - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip4, - &ip4_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_input_classify_next_acl_ip6, - &ip6_table_index, 0); - acl_classify_add_del_table_tiny (cm, dot1q_5tuple_mask, - sizeof (dot1q_5tuple_mask) - 1, ~0, - ~0, &dot1q_table_index, 0); - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - goto done; - } - - /* add sessions to vlan tables per ethernet_type */ - acl_add_vlan_session (am, dot1q_table_index, 0, 0, 0); - acl_add_vlan_session (am, dot1q_table_index, 0, 0, 1); - acl_add_vlan_session (am, dot1ad_table_index, 0, 1, 0); - acl_add_vlan_session (am, dot1ad_table_index, 0, 1, 1); - - am->acl_ip4_input_classify_table_by_sw_if_index[sw_if_index] = - ip4_table_index; - am->acl_ip6_input_classify_table_by_sw_if_index[sw_if_index] = - ip6_table_index; - am->acl_dot1q_input_classify_table_by_sw_if_index[sw_if_index] = - dot1q_table_index; - am->acl_dot1ad_input_classify_table_by_sw_if_index[sw_if_index] = - dot1ad_table_index; - am->acl_dot1ad_input_classify_table_by_sw_if_index[sw_if_index] = - dot1ad_table_index; - am->acl_etype_input_classify_table_by_sw_if_index[sw_if_index] = - etype_table_index; - - vnet_l2_input_classify_enable_disable (sw_if_index, 1); -done: - clib_mem_set_heap (prevheap); - return rv; -} - -static int -acl_hook_l2_output_classify (acl_main_t * am, u32 sw_if_index) -{ - vnet_classify_main_t *cm = &vnet_classify_main; - u32 ip4_table_index = ~0; - u32 ip6_table_index = ~0; - u32 dot1q_table_index = ~0; - u32 dot1ad_table_index = ~0; - u32 etype_table_index = ~0; - int rv; - - void *prevheap = clib_mem_set_heap (cm->vlib_main->heap_base); - - /* in case there were previous tables attached */ - acl_unhook_l2_output_classify (am, sw_if_index); - rv = - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip4, - &ip4_table_index, 1); - if (rv) - goto done; - rv = - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip6, - &ip6_table_index, 1); - if (rv) - { - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip4, - &ip4_table_index, 0); - goto done; - } - - if (intf_has_etype_whitelist (am, sw_if_index, 0)) - { - acl_classify_add_del_table_tiny (cm, ethertype_mask, sizeof (ethertype_mask) - 1, ~0, 0, /* drop if no match */ - &etype_table_index, 1); - etype_whitelist_add_sessions (am, sw_if_index, 0, etype_table_index); - } - - - rv = - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, - etype_table_index, ~0, - &dot1ad_table_index, 1); - rv = - acl_classify_add_del_table_tiny (cm, dot1q_5tuple_mask, - sizeof (dot1q_5tuple_mask) - 1, - dot1ad_table_index, ~0, - &dot1q_table_index, 1); - if (rv) - { - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip6, - &ip6_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip4, - &ip4_table_index, 0); - goto done; - } - - rv = - vnet_l2_output_classify_set_tables (sw_if_index, ip4_table_index, - ip6_table_index, dot1q_table_index); -/* - clib_warning - ("ACL enabling on interface sw_if_index %d, setting tables to the following: ip4: %d ip6: %d\n", - sw_if_index, ip4_table_index, ip6_table_index); -*/ - if (rv) - { - acl_classify_add_del_table_tiny (cm, ip6_5tuple_mask, - sizeof (ip6_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip6, - &ip6_table_index, 0); - acl_classify_add_del_table_tiny (cm, ip4_5tuple_mask, - sizeof (ip4_5tuple_mask) - 1, ~0, - am->l2_output_classify_next_acl_ip4, - &ip4_table_index, 0); - acl_classify_add_del_table_tiny (cm, dot1q_5tuple_mask, - sizeof (dot1q_5tuple_mask) - 1, ~0, - ~0, &dot1q_table_index, 0); - acl_classify_add_del_table_tiny (cm, dot1ad_5tuple_mask, - sizeof (dot1ad_5tuple_mask) - 1, ~0, - ~0, &dot1ad_table_index, 0); - goto done; - } - - /* add sessions to vlan tables per ethernet_type */ - acl_add_vlan_session (am, dot1q_table_index, 1, 0, 0); - acl_add_vlan_session (am, dot1q_table_index, 1, 0, 1); - acl_add_vlan_session (am, dot1ad_table_index, 1, 1, 0); - acl_add_vlan_session (am, dot1ad_table_index, 1, 1, 1); - - am->acl_ip4_output_classify_table_by_sw_if_index[sw_if_index] = - ip4_table_index; - am->acl_ip6_output_classify_table_by_sw_if_index[sw_if_index] = - ip6_table_index; - am->acl_dot1q_output_classify_table_by_sw_if_index[sw_if_index] = - dot1q_table_index; - am->acl_dot1ad_output_classify_table_by_sw_if_index[sw_if_index] = - dot1ad_table_index; - am->acl_etype_output_classify_table_by_sw_if_index[sw_if_index] = - etype_table_index; - - vnet_l2_output_classify_enable_disable (sw_if_index, 1); -done: - clib_mem_set_heap (prevheap); - return rv; + u16 *whitelist = (vec_len (v) > sw_if_index) ? vec_elt (v, sw_if_index) : 0; + return vec_len (whitelist) > 0; } 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); } @@ -1172,15 +530,19 @@ acl_interface_in_enable_disable (acl_main_t * am, u32 sw_if_index, acl_fa_enable_disable (sw_if_index, 1, enable_disable); - if (enable_disable) - { - rv = acl_hook_l2_input_classify (am, sw_if_index); - } - else - { - rv = acl_unhook_l2_input_classify (am, sw_if_index); - } + rv = vnet_l2_feature_enable_disable ("l2-input-ip4", "acl-plugin-in-ip4-l2", + sw_if_index, enable_disable, 0, 0); + if (rv) + clib_error ("Could not enable on input"); + rv = vnet_l2_feature_enable_disable ("l2-input-ip6", "acl-plugin-in-ip6-l2", + sw_if_index, enable_disable, 0, 0); + if (rv) + clib_error ("Could not enable on input"); + if (intf_has_etype_whitelist (am, sw_if_index, 1)) + vnet_l2_feature_enable_disable ("l2-input-nonip", + "acl-plugin-in-nonip-l2", sw_if_index, + enable_disable, 0, 0); am->in_acl_on_sw_if_index = clib_bitmap_set (am->in_acl_on_sw_if_index, sw_if_index, enable_disable); @@ -1191,7 +553,7 @@ static int acl_interface_out_enable_disable (acl_main_t * am, u32 sw_if_index, int enable_disable) { - int rv; + int rv = 0; /* Utterly wrong? */ if (pool_is_free_index (am->vnet_main->interface_main.sw_interfaces, @@ -1204,21 +566,36 @@ acl_interface_out_enable_disable (acl_main_t * am, u32 sw_if_index, acl_fa_enable_disable (sw_if_index, 0, enable_disable); - if (enable_disable) - { - rv = acl_hook_l2_output_classify (am, sw_if_index); - } - else - { - rv = acl_unhook_l2_output_classify (am, sw_if_index); - } - + rv = + vnet_l2_feature_enable_disable ("l2-output-ip4", "acl-plugin-out-ip4-l2", + sw_if_index, enable_disable, 0, 0); + if (rv) + clib_error ("Could not enable on output"); + rv = + vnet_l2_feature_enable_disable ("l2-output-ip6", "acl-plugin-out-ip6-l2", + sw_if_index, enable_disable, 0, 0); + if (rv) + clib_error ("Could not enable on output"); + if (intf_has_etype_whitelist (am, sw_if_index, 0)) + vnet_l2_feature_enable_disable ("l2-output-nonip", + "acl-plugin-out-nonip-l2", sw_if_index, + enable_disable, 0, 0); am->out_acl_on_sw_if_index = clib_bitmap_set (am->out_acl_on_sw_if_index, sw_if_index, enable_disable); 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) @@ -1274,16 +651,16 @@ acl_interface_set_inout_acl_list (acl_main_t * am, u32 sw_if_index, 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); @@ -1347,26 +724,23 @@ acl_interface_set_inout_acl_list (acl_main_t * am, u32 sw_if_index, 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, + acl_plugin.get_lookup_context_index (am->interface_acl_user_id, sw_if_index, is_input); (*pinout_lc_index_by_sw_if_index)[sw_if_index] = lc_index; } - acl_plugin_set_acl_vec_for_context (lc_index, vec_acl_list_index); + acl_plugin.set_acl_vec_for_context (lc_index, vec_acl_list_index); } else { 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); @@ -1383,10 +757,8 @@ acl_interface_reset_inout_acls (u32 sw_if_index, u8 is_input, 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 @@ -1402,11 +774,9 @@ acl_interface_add_del_inout_acl (u32 sw_if_index, u8 is_add, u8 is_input, : 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); @@ -1424,7 +794,7 @@ acl_interface_add_del_inout_acl (u32 sw_if_index, u8 is_add, u8 is_input, } else { - if (sw_if_index > vec_len (*pinout_acl_vec_by_sw_if_index)) + if (sw_if_index >= vec_len (*pinout_acl_vec_by_sw_if_index)) { rv = VNET_API_ERROR_NO_SUCH_ENTRY; goto done; @@ -1447,7 +817,6 @@ acl_interface_add_del_inout_acl (u32 sw_if_index, u8 is_add, u8 is_input, &may_clear_sessions); done: vec_free (acl_vec); - clib_mem_set_heap (oldheap); return rv; } @@ -1688,7 +1057,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) */ for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); /* source MAC address */ memcpy (&mask[6], mt->mac_mask, 6); @@ -1696,20 +1065,20 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) { case 0: default: - memset (&mask[12], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */ l3_offset = 14; last_tag_table = &mt->arp_table_index; break; case 1: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */ l3_offset = 18; last_tag_table = &mt->arp_dot1q_table_index; break; case 2: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* VLAN tag2 */ - memset (&mask[20], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */ + clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */ l3_offset = 22; last_tag_table = &mt->arp_dot1ad_table_index; break; @@ -1734,26 +1103,26 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) if (mt->has_egress) { /* egress ARP table */ - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); switch (tags) { case 0: default: - memset (&mask[12], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */ l3_offset = 14; out_last_tag_table = &mt->out_arp_table_index; break; case 1: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */ l3_offset = 18; out_last_tag_table = &mt->out_arp_dot1q_table_index; break; case 2: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* VLAN tag2 */ - memset (&mask[20], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */ + clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */ l3_offset = 22; out_last_tag_table = &mt->out_arp_dot1ad_table_index; break; @@ -1790,25 +1159,25 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) */ for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); memcpy (&mask[6], mt->mac_mask, 6); l3_src_offs = tags * 4 + get_l3_src_offset (is6); switch (tags) { case 0: default: - memset (&mask[12], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */ last_tag_table = &mt->table_index; break; case 1: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */ last_tag_table = &mt->dot1q_table_index; break; case 2: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* VLAN tag2 */ - memset (&mask[20], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */ + clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */ last_tag_table = &mt->dot1ad_table_index; break; } @@ -1836,7 +1205,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) { for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); /* MAC destination */ memcpy (&mask[0], mt->mac_mask, 6); l3_dst_offs = tags * 4 + get_l3_dst_offset (is6); @@ -1844,18 +1213,18 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) { case 0: default: - memset (&mask[12], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* ethernet protocol */ out_last_tag_table = &mt->out_table_index; break; case 1: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* ethernet protocol */ out_last_tag_table = &mt->out_dot1q_table_index; break; case 2: - memset (&mask[12], 0xff, 2); /* VLAN tag1 */ - memset (&mask[16], 0xff, 2); /* VLAN tag2 */ - memset (&mask[20], 0xff, 2); /* ethernet protocol */ + clib_memset (&mask[12], 0xff, 2); /* VLAN tag1 */ + clib_memset (&mask[16], 0xff, 2); /* VLAN tag2 */ + clib_memset (&mask[20], 0xff, 2); /* ethernet protocol */ out_last_tag_table = &mt->out_dot1ad_table_index; break; } @@ -1910,7 +1279,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); l3_src_offs = tags * 4 + get_l3_src_offset (is6); memcpy (&mask[6], a->rules[i].src_mac, 6); switch (tags) @@ -1952,13 +1321,13 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) vnet_classify_add_del_session (cm, tag_table, mask, a->rules[i].is_permit ? ~0 : 0, i, 0, action, metadata, 1); - memset (&mask[12], 0, sizeof (mask) - 12); + clib_memset (&mask[12], 0, sizeof (mask) - 12); } /* add ARP table entry too */ if (!is6 && (mvec[match_type_index].arp_table_index != ~0)) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); memcpy (&mask[6], a->rules[i].src_mac, 6); for (tags = 2; tags >= 0; tags--) @@ -2005,7 +1374,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) /* Add the egress entry with destination set */ for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); l3_dst_offs = tags * 4 + get_l3_dst_offset (is6); /* src mac in the other direction becomes dst */ memcpy (&mask[0], a->rules[i].src_mac, 6); @@ -2051,7 +1420,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) mask, a->rules[i].is_permit ? ~0 : 0, i, 0, action, metadata, 1); - // memset (&mask[12], 0, sizeof (mask) - 12); + // clib_memset (&mask[12], 0, sizeof (mask) - 12); } /* add ARP table entry too */ @@ -2059,7 +1428,7 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) { for (tags = 2; tags >= 0; tags--) { - memset (mask, 0, sizeof (mask)); + clib_memset (mask, 0, sizeof (mask)); switch (tags) { case 0: @@ -2090,9 +1459,9 @@ macip_create_classify_tables (acl_main_t * am, u32 macip_acl_index) 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); } } } @@ -2204,7 +1573,6 @@ macip_acl_add_list (u32 count, vl_api_macip_acl_rule_t rules[], /* 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); @@ -2213,21 +1581,19 @@ macip_acl_add_list (u32 count, vl_api_macip_acl_rule_t rules[], { 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) { /* Get ACL index */ pool_get_aligned (am->macip_acls, a, CLIB_CACHE_LINE_BYTES); - memset (a, 0, sizeof (*a)); + clib_memset (a, 0, sizeof (*a)); /* Will return the newly allocated ACL index */ *acl_list_index = a - am->macip_acls; } @@ -2245,9 +1611,8 @@ macip_acl_add_list (u32 count, vl_api_macip_acl_rule_t rules[], a->count = count; memcpy (a->tag, tag, sizeof (a->tag)); - /* Create and populate the classifer tables */ + /* 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); @@ -2308,12 +1673,10 @@ macip_acl_interface_add_acl (acl_main_t * am, u32 sw_if_index, { 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); @@ -2350,7 +1713,6 @@ macip_acl_del_list (u32 acl_list_index) } } - void *oldheap = acl_set_heap (am); /* Now that classifier tables are detached, clean them up */ macip_destroy_classify_tables (am, acl_list_index); @@ -2361,7 +1723,6 @@ macip_acl_del_list (u32 acl_list_index) vec_free (a->rules); } pool_put (am->macip_acls, a); - clib_mem_set_heap (oldheap); return 0; } @@ -2455,6 +1816,21 @@ vl_api_acl_del_t_handler (vl_api_acl_del_t * mp) 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) { @@ -2500,8 +1876,6 @@ 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++) @@ -2519,7 +1893,6 @@ static void &may_clear_sessions); vec_free (in_acl_vec); vec_free (out_acl_vec); - clib_mem_set_heap (oldheap); } } @@ -2530,19 +1903,12 @@ static void 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); @@ -2559,26 +1925,25 @@ send_acl_details (acl_main_t * am, vl_api_registration_t * reg, 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; - void *oldheap = acl_set_heap (am); + acl_rule_t *acl_rules = acl->rules; + int msg_size = sizeof (*mp) + sizeof (mp->r[0]) * vec_len (acl_rules); mp = vl_msg_api_alloc (msg_size); - memset (mp, 0, msg_size); + clib_memset (mp, 0, msg_size); mp->_vl_msg_id = ntohs (VL_API_ACL_DETAILS + am->msg_id_base); /* 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); vl_api_send_msg (reg, (u8 *) mp); } @@ -2634,13 +1999,10 @@ send_acl_interface_list_details (acl_main_t * am, 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; @@ -2649,7 +2011,7 @@ send_acl_interface_list_details (acl_main_t * am, msg_size += sizeof (mp->acls[0]) * count; mp = vl_msg_api_alloc (msg_size); - memset (mp, 0, msg_size); + clib_memset (mp, 0, msg_size); mp->_vl_msg_id = ntohs (VL_API_ACL_INTERFACE_LIST_DETAILS + am->msg_id_base); @@ -2801,7 +2163,7 @@ send_macip_acl_details (acl_main_t * am, vl_api_registration_t * reg, int msg_size = sizeof (*mp) + (acl ? sizeof (mp->r[0]) * acl->count : 0); mp = vl_msg_api_alloc (msg_size); - memset (mp, 0, msg_size); + clib_memset (mp, 0, msg_size); mp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_DETAILS + am->msg_id_base); /* fill in the message */ @@ -2816,17 +2178,14 @@ send_macip_acl_details (acl_main_t * am, vl_api_registration_t * reg, { 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 @@ -2855,13 +2214,11 @@ vl_api_macip_acl_dump_t_handler (vl_api_macip_acl_dump_t * mp) 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 @@ -2891,7 +2248,7 @@ vl_api_macip_acl_interface_get_t_handler (vl_api_macip_acl_interface_get_t * return; rmp = vl_msg_api_alloc (msg_size); - memset (rmp, 0, msg_size); + clib_memset (rmp, 0, msg_size); rmp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_INTERFACE_GET_REPLY + am->msg_id_base); rmp->context = mp->context; @@ -2915,7 +2272,7 @@ send_macip_acl_interface_list_details (acl_main_t * am, int msg_size = sizeof (*rmp) + sizeof (rmp->acls[0]); rmp = vl_msg_api_alloc (msg_size); - memset (rmp, 0, msg_size); + clib_memset (rmp, 0, msg_size); rmp->_vl_msg_id = ntohs (VL_API_MACIP_ACL_INTERFACE_LIST_DETAILS + am->msg_id_base); @@ -2947,7 +2304,8 @@ static void 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); } @@ -2975,7 +2333,6 @@ static void 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; @@ -2991,7 +2348,6 @@ static void 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); } @@ -3021,8 +2377,6 @@ send_acl_interface_etype_whitelist_details (acl_main_t * am, 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; @@ -3031,7 +2385,7 @@ send_acl_interface_etype_whitelist_details (acl_main_t * am, msg_size += sizeof (mp->whitelist[0]) * count; mp = vl_msg_api_alloc (msg_size); - memset (mp, 0, msg_size); + clib_memset (mp, 0, msg_size); mp->_vl_msg_id = ntohs (VL_API_ACL_INTERFACE_ETYPE_WHITELIST_DETAILS + am->msg_id_base); @@ -3048,7 +2402,6 @@ send_acl_interface_etype_whitelist_details (acl_main_t * am, { mp->whitelist[n_input + i] = htons (whitelist_out[i]); } - clib_mem_set_heap (oldheap); vl_api_send_msg (reg, (u8 *) mp); } @@ -3086,84 +2439,6 @@ static void } } - - -/* 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 -#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_setup_fa_nodes (void) -{ - vlib_main_t *vm = vlib_get_main (); - acl_main_t *am = &acl_main; - vlib_node_t *n, *n4, *n6; - - n = vlib_get_node_by_name (vm, (u8 *) "l2-input-classify"); - n4 = vlib_get_node_by_name (vm, (u8 *) "acl-plugin-in-ip4-l2"); - n6 = vlib_get_node_by_name (vm, (u8 *) "acl-plugin-in-ip6-l2"); - - - am->l2_input_classify_next_acl_ip4 = - vlib_node_add_next_with_slot (vm, n->index, n4->index, ~0); - am->l2_input_classify_next_acl_ip6 = - vlib_node_add_next_with_slot (vm, n->index, n6->index, ~0); - - feat_bitmap_init_next_nodes (vm, n4->index, L2INPUT_N_FEAT, - l2input_get_feat_names (), - am->fa_acl_in_ip4_l2_node_feat_next_node_index); - - feat_bitmap_init_next_nodes (vm, n6->index, L2INPUT_N_FEAT, - l2input_get_feat_names (), - am->fa_acl_in_ip6_l2_node_feat_next_node_index); - - - n = vlib_get_node_by_name (vm, (u8 *) "l2-output-classify"); - n4 = vlib_get_node_by_name (vm, (u8 *) "acl-plugin-out-ip4-l2"); - n6 = vlib_get_node_by_name (vm, (u8 *) "acl-plugin-out-ip6-l2"); - - am->l2_output_classify_next_acl_ip4 = - vlib_node_add_next_with_slot (vm, n->index, n4->index, ~0); - am->l2_output_classify_next_acl_ip6 = - vlib_node_add_next_with_slot (vm, n->index, n6->index, ~0); - - feat_bitmap_init_next_nodes (vm, n4->index, L2OUTPUT_N_FEAT, - l2output_get_feat_names (), - am->fa_acl_out_ip4_l2_node_feat_next_node_index); - - feat_bitmap_init_next_nodes (vm, n6->index, L2OUTPUT_N_FEAT, - l2output_get_feat_names (), - am->fa_acl_out_ip6_l2_node_feat_next_node_index); -} - static void acl_set_timeout_sec (int timeout_type, u32 value) { @@ -3210,11 +2485,6 @@ static clib_error_t * 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; @@ -3287,17 +2557,17 @@ acl_set_aclplugin_fn (vlib_main_t * vm, 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; @@ -3463,7 +2733,7 @@ macip_acl_print (acl_main_t * am, u32 macip_acl_index) int i; /* Don't try to print someone else's memory */ - if (macip_acl_index > vec_len (am->macip_acls)) + if (macip_acl_index >= vec_len (am->macip_acls)) return; macip_acl_list_t *a = vec_elt_at_index (am->macip_acls, macip_acl_index); @@ -3487,6 +2757,196 @@ macip_acl_print (acl_main_t * am, u32 macip_acl_index) } +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, IP46_TYPE_ANY, + &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, IP46_TYPE_ANY, + &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 * @@ -3747,26 +3207,7 @@ acl_show_aclplugin_memory_fn (vlib_main_t * vm, 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; } @@ -3826,41 +3267,32 @@ acl_plugin_show_sessions (acl_main_t * am, 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; @@ -3906,6 +3338,10 @@ acl_plugin_show_sessions (acl_main_t * am, pw->interrupt_is_unwanted); vlib_cli_output (vm, " interrupt generation: %d", pw->interrupt_generation); + vlib_cli_output (vm, " received session change requests: %d", + pw->rcvd_session_change_requests); + vlib_cli_output (vm, " sent session change requests: %d", + pw->sent_session_change_requests); } vlib_cli_output (vm, "\n\nConn cleaner thread counters:"); #define _(cnt, desc) vlib_cli_output(vm, " %20lu: %s", am->cnt, desc); @@ -3991,6 +3427,8 @@ acl_show_aclplugin_tables_fn (vlib_main_t * vm, 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) @@ -4086,6 +3524,43 @@ VLIB_CLI_COMMAND (aclplugin_clear_command, static) = { .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 + * set acl-plugin interface acl [del] + * @cliexend + ?*/ +VLIB_CLI_COMMAND (aclplugin_set_interface_command, static) = { + .path = "set acl-plugin interface", + .short_help = "set acl-plugin interface [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 + * set acl-plugin acl src dst proto sport dport [tag FOO] + * @cliexend + ?*/ +VLIB_CLI_COMMAND (aclplugin_set_acl_command, static) = { + .path = "set acl-plugin acl", + .short_help = "set acl-plugin acl src dst 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 * @@ -4093,21 +3568,25 @@ acl_plugin_config (vlib_main_t * vm, unformat_input_t * input) { acl_main_t *am = &acl_main; u32 conn_table_hash_buckets; - u32 conn_table_hash_memory_size; + uword conn_table_hash_memory_size; u32 conn_table_max_entries; uword main_heap_size; uword hash_heap_size; u32 hash_lookup_hash_buckets; - u32 hash_lookup_hash_memory; + uword hash_lookup_hash_memory; u32 reclassify_sessions; + u32 use_tuple_merge; + u32 tuple_merge_split_threshold; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "connection hash buckets %d", &conn_table_hash_buckets)) am->fa_conn_table_hash_num_buckets = conn_table_hash_buckets; - else if (unformat (input, "connection hash memory %d", - &conn_table_hash_memory_size)) + else + if (unformat + (input, "connection hash memory %U", unformat_memory_size, + &conn_table_hash_memory_size)) am->fa_conn_table_hash_memory_size = conn_table_hash_memory_size; else if (unformat (input, "connection count max %d", &conn_table_max_entries)) @@ -4116,18 +3595,31 @@ 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 (input, "hash lookup hash memory %d", - &hash_lookup_hash_memory)) + else + if (unformat + (input, "hash lookup hash memory %U", unformat_memory_size, + &hash_lookup_hash_memory)) am->hash_lookup_hash_memory = hash_lookup_hash_memory; + else if (unformat (input, "use tuple merge %d", &use_tuple_merge)) + am->use_tuple_merge = use_tuple_merge; + else + if (unformat + (input, "tuple merge split threshold %d", + &tuple_merge_split_threshold)) + am->tuple_merge_split_threshold = tuple_merge_split_threshold; + else if (unformat (input, "reclassify sessions %d", &reclassify_sessions)) am->reclassify_sessions = reclassify_sessions; @@ -4141,33 +3633,27 @@ acl_plugin_config (vlib_main_t * vm, unformat_input_t * input) VLIB_CONFIG_FUNCTION (acl_plugin_config, "acl-plugin"); +/* Set up the API message handling tables */ +#include +#include + static clib_error_t * acl_init (vlib_main_t * vm) { acl_main_t *am = &acl_main; clib_error_t *error = 0; - memset (am, 0, sizeof (*am)); + clib_memset (am, 0, sizeof (*am)); am->vlib_main = 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); + am->msg_id_base = setup_message_id_table (); - acl_setup_fa_nodes (); + error = acl_plugin_exports_init (&acl_plugin); - am->acl_mheap_size = 0; /* auto size when initializing */ - am->hash_lookup_mheap_size = ACL_PLUGIN_HASH_LOOKUP_HEAP_SIZE; + if (error) + return error; am->hash_lookup_hash_buckets = ACL_PLUGIN_HASH_LOOKUP_HASH_BUCKETS; am->hash_lookup_hash_memory = ACL_PLUGIN_HASH_LOOKUP_HASH_MEMORY; @@ -4200,6 +3686,10 @@ acl_init (vlib_main_t * vm) for (wk = 0; wk < vec_len (am->per_worker_data); wk++) { acl_fa_per_worker_data_t *pw = &am->per_worker_data[wk]; + if (tm->n_vlib_mains > 1) + { + clib_spinlock_init (&pw->pending_session_change_request_lock); + } vec_validate (pw->expired, ACL_N_TIMEOUTS * am->fa_max_deleted_sessions_per_interval); @@ -4227,8 +3717,18 @@ acl_init (vlib_main_t * vm) /* use the new fancy hash-based matching */ am->use_hash_acl_matching = 1; - - am->interface_acl_user_id = ~0; /* defer till the first use */ + /* use tuplemerge by default */ + am->use_tuple_merge = 1; + /* Set the default threshold */ + am->tuple_merge_split_threshold = TM_SPLIT_THRESHOLD; + + 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; }