#include <vpp/app/version.h>
#include <vnet/ethernet/ethernet_types_api.h>
+#include <vnet/ip/format.h>
+#include <vnet/ethernet/ethernet.h>
+#include <vnet/ip/ip_types_api.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#include <acl/acl.api_types.h>
#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
-#include "manual_fns.h"
#include "fa_node.h"
#include "public_inlines.h"
typedef void (*acl_vector_print_func_t) (vlib_main_t * vm, u8 * out0);
+static inline u8 *
+format_acl_action (u8 * s, u8 action)
+{
+ switch (action)
+ {
+ case 0:
+ s = format (s, "deny");
+ break;
+ case 1:
+ s = format (s, "permit");
+ break;
+ case 2:
+ s = format (s, "permit+reflect");
+ break;
+ default:
+ s = format (s, "action %d", action);
+ }
+ return (s);
+}
+
static void
acl_print_acl_x (acl_vector_print_func_t vpr, vlib_main_t * vm,
acl_main_t * am, int acl_index)
ntohs (VL_API_ACL_PLUGIN_GET_CONN_TABLE_MAX_ENTRIES_REPLY +
am->msg_id_base);
rmp->context = mp->context;
- rmp->conn_table_max_entries = __bswap_64 (am->fa_conn_table_max_entries);
+ rmp->conn_table_max_entries =
+ clib_net_to_host_u64 (am->fa_conn_table_max_entries);
vl_api_send_msg (rp, (u8 *) rmp);
}
acl_list_t *a;
acl_rule_t *r;
acl_rule_t *acl_new_rules = 0;
+ size_t tag_len;
int i;
+ tag_len = clib_strnlen ((const char *) tag, sizeof (a->tag));
+ if (tag_len == sizeof (a->tag))
+ return VNET_API_ERROR_INVALID_VALUE;
+
if (am->trace_acl > 255)
clib_warning ("API dbg: acl_add_list index %d tag %s", *acl_list_index,
tag);
vec_free (a->rules);
}
a->rules = acl_new_rules;
- memcpy (a->tag, tag, sizeof (a->tag));
+ memcpy (a->tag, tag, tag_len + 1);
if (am->trace_acl > 255)
warning_acl_print_acl (am->vlib_main, am, *acl_list_index);
if (am->reclassify_sessions)
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);
seen_acl_bitmap, format_bitmap_hex, change_acl_bitmap);
/* *INDENT-OFF* */
- clib_bitmap_foreach(acln, change_acl_bitmap, ({
+ clib_bitmap_foreach (acln, change_acl_bitmap) {
if (clib_bitmap_get(old_seen_acl_bitmap, acln)) {
/* ACL is being removed. */
if (acln < vec_len((*pinout_sw_if_index_vec_by_acl))) {
vec_validate((*pinout_sw_if_index_vec_by_acl), acln);
vec_add1((*pinout_sw_if_index_vec_by_acl)[acln], sw_if_index);
}
- }));
+ }
/* *INDENT-ON* */
vec_free ((*pinout_acl_vec_by_sw_if_index)[sw_if_index]);
{
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;
}
}
: 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;
if (is_add)
{
vnet_classify_add_del_session (cm, tag_table,
mask,
- a->
- rules[i].is_permit ? ~0 : 0,
- i, 0, action, metadata, 1);
+ a->rules[i].
+ is_permit ? ~0 : 0, i, 0,
+ action, metadata, 1);
}
}
}
macip_acl_list_t *a;
macip_acl_rule_t *r;
macip_acl_rule_t *acl_new_rules = 0;
+ size_t tag_len;
int i;
int rv = 0;
+ tag_len = clib_strnlen ((const char *) tag, sizeof (a->tag));
+ if (tag_len == sizeof (a->tag))
+ return VNET_API_ERROR_INVALID_VALUE;
+
if (*acl_list_index != ~0)
{
/* They supplied some number, let's see if this MACIP ACL exists */
a->rules = acl_new_rules;
a->count = count;
- memcpy (a->tag, tag, sizeof (a->tag));
+ memcpy (a->tag, tag, tag_len + 1);
/* Create and populate the classifier tables */
macip_create_classify_tables (am, *acl_list_index);
*
*/
static int
-verify_message_len (void *mp, u32 expected_len, char *where)
+verify_message_len (void *mp, u64 expected_len, char *where)
{
u32 supplied_len = vl_msg_api_get_msg_length (mp);
if (supplied_len < expected_len)
int rv;
u32 acl_list_index = ntohl (mp->acl_index);
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "acl_add_replace"))
{
mp->context = context;
mp->count = htonl (vec_len (acl_rules));
mp->acl_index = htonl (acl - am->acls);
- memcpy (mp->tag, acl->tag, sizeof (mp->tag));
+ snprintf ((char *) mp->tag, sizeof (mp->tag), "%s", acl->tag);
// clib_memcpy (mp->r, acl->rules, acl->count * sizeof(acl->rules[0]));
rules = mp->r;
for (i = 0; i < vec_len (acl_rules); i++)
{
/* *INDENT-OFF* */
/* Just dump all ACLs */
- pool_foreach (acl, am->acls,
- ({
+ pool_foreach (acl, am->acls)
+ {
send_acl_details(am, reg, acl, mp->context);
- }));
+ }
/* *INDENT-ON* */
}
else
if (mp->sw_if_index == ~0)
{
/* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
send_acl_interface_list_details(am, reg, swif->sw_if_index, mp->context);
- }));
+ }
/* *INDENT-ON* */
}
else
int rv;
u32 acl_list_index = ~0;
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "macip_acl_add"))
{
int rv;
u32 acl_list_index = ntohl (mp->acl_index);
u32 acl_count = ntohl (mp->count);
- u32 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
+ u64 expected_len = sizeof (*mp) + acl_count * sizeof (mp->r[0]);
if (verify_message_len (mp, expected_len, "macip_acl_add_replace"))
{
mp->context = context;
if (acl)
{
- memcpy (mp->tag, acl->tag, sizeof (mp->tag));
+ snprintf ((char *) mp->tag, sizeof (mp->tag), "%s", acl->tag);
mp->count = htonl (acl->count);
mp->acl_index = htonl (acl - am->macip_acls);
rules = mp->r;
{
/* Just dump all ACLs for now, with sw_if_index = ~0 */
/* *INDENT-OFF* */
- pool_foreach (acl, am->macip_acls,
- ({
+ pool_foreach (acl, am->macip_acls)
+ {
send_macip_acl_details (am, reg, acl, mp->context);
- }));
+ }
/* *INDENT-ON* */
}
else
if (~0 != am->macip_acl_by_sw_if_index[sw_if_index])
{
send_macip_acl_interface_list_details (am, reg, sw_if_index,
- am->macip_acl_by_sw_if_index
+ am->
+ macip_acl_by_sw_if_index
[sw_if_index],
mp->context);
}
if (mp->sw_if_index == ~0)
{
/* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
send_acl_interface_etype_whitelist_details(am, reg, swif->sw_if_index, mp->context);
- }));
+ }
/* *INDENT-ON* */
}
else
}
}
+static void
+vl_api_acl_plugin_use_hash_lookup_set_t_handler (
+ vl_api_acl_plugin_use_hash_lookup_set_t *mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_plugin_use_hash_lookup_set_reply_t *rmp;
+ vl_api_registration_t *reg;
+ int rv = 0;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ am->use_hash_acl_matching = mp->enable;
+ REPLY_MACRO (VL_API_ACL_PLUGIN_USE_HASH_LOOKUP_SET_REPLY);
+}
+
+static void
+vl_api_acl_plugin_use_hash_lookup_get_t_handler (
+ vl_api_acl_plugin_use_hash_lookup_get_t *mp)
+{
+ acl_main_t *am = &acl_main;
+ vl_api_acl_plugin_use_hash_lookup_get_reply_t *rmp;
+ int msg_size = sizeof (*rmp);
+ vl_api_registration_t *reg;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ rmp = vl_msg_api_alloc (msg_size);
+ clib_memset (rmp, 0, msg_size);
+ rmp->_vl_msg_id =
+ ntohs (VL_API_ACL_PLUGIN_USE_HASH_LOOKUP_GET_REPLY + am->msg_id_base);
+ rmp->context = mp->context;
+ rmp->enable = am->use_hash_acl_matching;
+ vl_api_send_msg (reg, (u8 *) rmp);
+}
+
static void
acl_set_timeout_sec (int timeout_type, u32 value)
{
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";
+ ip_prefix_t src, dst;
+ u8 *tag = 0;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
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))
+ else if (unformat (line_input, "src %U", unformat_ip_prefix, &src))
{
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;
+ ip_prefix_encode2 (&src, &rules[rule_idx].src_prefix);
}
- else if (unformat (line_input, "dst %U/%d",
- unformat_ip46_address, &dst, IP46_TYPE_ANY,
- &dst_prefix_length))
+ else if (unformat (line_input, "dst %U", unformat_ip_prefix, &dst))
{
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;
+ ip_prefix_encode2 (&dst, &rules[rule_idx].dst_prefix);
}
else if (unformat (line_input, "sport %d-%d", &port1, &port2))
{
}
u32 acl_index = ~0;
+ if (!tag)
+ vec_add (tag, "cli", 4);
rv = acl_add_list (vec_len (rules), rules, &acl_index, tag);
vec_free (rules);
+ vec_free (tag);
if (rv)
return (clib_error_return (0, "failed"));
}
vlib_cli_output (vm, " connection add/del stats:", wk);
/* *INDENT-OFF* */
- pool_foreach (swif, im->sw_interfaces,
- ({
+ pool_foreach (swif, im->sw_interfaces)
+ {
u32 sw_if_index = swif->sw_if_index;
u64 n_adds =
(sw_if_index < vec_len (pw->fa_session_adds_by_sw_if_index) ?
n_adds -
n_dels,
n_epoch_changes);
- }));
+ }
/* *INDENT-ON* */
vlib_cli_output (vm, " connection timeout type lists:", wk);
}
vlib_cli_output (vm, "Stats counters enabled for interface ACLs: %d",
acl_main.interface_acl_counters_enabled);
+ vlib_cli_output (vm, "Use hash-based lookup for ACLs: %d",
+ acl_main.use_hash_acl_matching);
if (show_mask_type)
acl_plugin_show_tables_mask_type ();
if (show_acl_hash_info)
* an ACL is composed of more than one Access control element (ACE). Multiple
* ACEs can be specified with this command using a comma separated list.
*
- * Each ACE describes a tuple of src+dst IP prefix, ip protocol, src+dst port ranges.
- * (the ACL plugin also support ICMP types/codes instead of UDP/TCP ports, but
- * this CLI does not).
+ * Each ACE describes a tuple of src+dst IP prefix, ip protocol, src+dst port
+ * ranges. (the ACL plugin also support ICMP types/codes instead of UDP/TCP
+ * ports, but this CLI does not).
*
- * An ACL can optionally be assigned a 'tag' - which is an identifier understood
- * by the client. VPP does not examine it in any way.
+ * An ACL can optionally be assigned a 'tag' - which is an identifier
+ * understood by the client. VPP does not examine it in any way.
*
- * @cliexpar
- * <b><em> set acl-plugin acl <permit|deny> src <PREFIX> dst <PREFIX> proto <TCP|UDP> sport <X-Y> dport <X-Y> [tag FOO] </b></em>
- * @cliexend
+ * @cliexcmd{set acl-plugin acl <permit|deny> src <PREFIX> dst <PREFIX> proto
+ * <TCP|UDP> sport <X-Y> dport <X-Y> [tag FOO]}
?*/
VLIB_CLI_COMMAND (aclplugin_set_acl_command, static) = {
.path = "set acl-plugin acl",