X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Facl%2Facl.c;h=48678f5e48fdd11d0cc5266c35991bc7fc5c7357;hb=40490db79b755c5ca7113e2b772fe6052925f044;hp=d4cbeb2ef0d3e56c3a07f21e95123244d8743456;hpb=94f509615eb97cebc9192e7290c84cf166518039;p=vpp.git diff --git a/src/plugins/acl/acl.c b/src/plugins/acl/acl.c index d4cbeb2ef0d..48678f5e48f 100644 --- a/src/plugins/acl/acl.c +++ b/src/plugins/acl/acl.c @@ -28,28 +28,11 @@ #include /* define message IDs */ -#include +#include +#include -/* define message structures */ -#define vl_typedefs -#include -#undef vl_typedefs - -/* 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 "manual_fns.h" #include "fa_node.h" #include "public_inlines.h" @@ -66,32 +49,10 @@ acl_main_t 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* */ @@ -166,37 +127,12 @@ void 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 @@ -259,13 +195,14 @@ 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]; + 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, @@ -296,6 +233,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) { @@ -347,6 +308,82 @@ 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_ip4_invalid_prefix (void *ip4_pref_raw, u8 ip4_prefix_len) +{ + ip4_address_t ip4_addr; + ip4_address_t ip4_mask; + ip4_address_t ip4_masked_addr; + + memcpy (&ip4_addr, ip4_pref_raw, sizeof (ip4_addr)); + ip4_preflen_to_mask (ip4_prefix_len, &ip4_mask); + ip4_masked_addr.as_u32 = ip4_addr.as_u32 & ip4_mask.as_u32; + int ret = (ip4_masked_addr.as_u32 != ip4_addr.as_u32); + if (ret) + { + clib_warning + ("inconsistent addr %U for prefix len %d; (%U when masked)", + format_ip4_address, ip4_pref_raw, ip4_prefix_len, format_ip4_address, + &ip4_masked_addr); + } + return ret; +} + +static int +acl_api_ip6_invalid_prefix (void *ip6_pref_raw, u8 ip6_prefix_len) +{ + ip6_address_t ip6_addr; + ip6_address_t ip6_mask; + ip6_address_t ip6_masked_addr; + + memcpy (&ip6_addr, ip6_pref_raw, sizeof (ip6_addr)); + ip6_preflen_to_mask (ip6_prefix_len, &ip6_mask); + ip6_masked_addr.as_u64[0] = ip6_addr.as_u64[0] & ip6_mask.as_u64[0]; + ip6_masked_addr.as_u64[1] = ip6_addr.as_u64[1] & ip6_mask.as_u64[1]; + int ret = ((ip6_masked_addr.as_u64[0] != ip6_addr.as_u64[0]) + || (ip6_masked_addr.as_u64[1] != ip6_addr.as_u64[1])); + if (ret) + { + clib_warning + ("inconsistent addr %U for prefix len %d; (%U when masked)", + format_ip6_address, ip6_pref_raw, ip6_prefix_len, format_ip6_address, + &ip6_masked_addr); + } + return ret; +} static int acl_add_list (u32 count, vl_api_acl_rule_t rules[], @@ -362,6 +399,43 @@ 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 (rules[i].is_ipv6) + { + if (rules[i].src_ip_prefix_len > 128) + return VNET_API_ERROR_INVALID_VALUE; + if (rules[i].dst_ip_prefix_len > 128) + return VNET_API_ERROR_INVALID_VALUE; + if (acl_api_ip6_invalid_prefix + (&rules[i].src_ip_addr, rules[i].src_ip_prefix_len)) + return VNET_API_ERROR_INVALID_SRC_ADDRESS; + if (acl_api_ip6_invalid_prefix + (&rules[i].dst_ip_addr, rules[i].dst_ip_prefix_len)) + return VNET_API_ERROR_INVALID_DST_ADDRESS; + } + else + { + if (rules[i].src_ip_prefix_len > 32) + return VNET_API_ERROR_INVALID_VALUE; + if (rules[i].dst_ip_prefix_len > 32) + return VNET_API_ERROR_INVALID_VALUE; + if (acl_api_ip4_invalid_prefix + (&rules[i].src_ip_addr, rules[i].src_ip_prefix_len)) + return VNET_API_ERROR_INVALID_SRC_ADDRESS; + if (acl_api_ip4_invalid_prefix + (&rules[i].dst_ip_addr, rules[i].dst_ip_prefix_len)) + 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 */ @@ -430,7 +504,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); @@ -440,6 +513,11 @@ acl_add_list (u32 count, vl_api_acl_rule_t rules[], 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); @@ -636,6 +714,16 @@ acl_interface_out_enable_disable (acl_main_t * am, u32 sw_if_index, 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) @@ -764,10 +852,6 @@ 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, sw_if_index, is_input); @@ -1872,6 +1956,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) { @@ -1976,7 +2075,8 @@ 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; + 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); @@ -1985,14 +2085,14 @@ send_acl_details (acl_main_t * am, vl_api_registration_t * reg, /* 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); @@ -2272,13 +2372,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 @@ -2503,40 +2601,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_set_timeout_sec (int timeout_type, u32 value) { @@ -2860,6 +2924,223 @@ 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; + ip4_address_t src_v4address, dst_v4address; + ip6_address_t src_v6address, dst_v6address; + 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, "ipv6")) + { + vec_validate_acl_rules (rules, rule_idx); + rules[rule_idx].is_ipv6 = 1; + } + else if (unformat (line_input, "ipv4")) + { + vec_validate_acl_rules (rules, rule_idx); + rules[rule_idx].is_ipv6 = 0; + } + else 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_ip4_address, &src_v4address, + &src_prefix_length)) + { + vec_validate_acl_rules (rules, rule_idx); + memcpy (rules[rule_idx].src_ip_addr, &src_v4address, 4); + rules[rule_idx].src_ip_prefix_len = src_prefix_length; + rules[rule_idx].is_ipv6 = 0; + } + else if (unformat (line_input, "src %U/%d", + unformat_ip6_address, &src_v6address, + &src_prefix_length)) + { + vec_validate_acl_rules (rules, rule_idx); + memcpy (rules[rule_idx].src_ip_addr, &src_v6address, 16); + rules[rule_idx].src_ip_prefix_len = src_prefix_length; + rules[rule_idx].is_ipv6 = 1; + } + else if (unformat (line_input, "dst %U/%d", + unformat_ip4_address, &dst_v4address, + &dst_prefix_length)) + { + vec_validate_acl_rules (rules, rule_idx); + memcpy (rules[rule_idx].dst_ip_addr, &dst_v4address, 4); + rules[rule_idx].dst_ip_prefix_len = dst_prefix_length; + rules[rule_idx].is_ipv6 = 0; + } + else if (unformat (line_input, "dst %U/%d", + unformat_ip6_address, &dst_v6address, + &dst_prefix_length)) + { + vec_validate_acl_rules (rules, rule_idx); + memcpy (rules[rule_idx].dst_ip_addr, &dst_v6address, 16); + rules[rule_idx].dst_ip_prefix_len = dst_prefix_length; + rules[rule_idx].is_ipv6 = 1; + } + 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 * @@ -3199,41 +3480,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; @@ -3368,6 +3640,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) @@ -3463,6 +3737,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 * @@ -3532,6 +3843,10 @@ 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) { @@ -3542,21 +3857,8 @@ 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); @@ -3633,7 +3935,13 @@ acl_init (vlib_main_t * vm) /* 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; }