src/plugins/acl/lookup_context.c

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <plugins/acl/acl.h>
  17 #include <plugins/acl/fa_node.h>
  18 #include <vlib/unix/plugin.h>
  19 #include <plugins/acl/public_inlines.h>
  20 #include "hash_lookup.h"
  21 #include "elog_acl_trace.h"
  22
  23 /* check if a given ACL exists */
  24 static u8
  25 acl_plugin_acl_exists (u32 acl_index)
  26 {
  27   acl_main_t *am = &acl_main;
  28
  29   if (pool_is_free_index (am->acls, acl_index))
  30     return 0;
  31
  32   return 1;
  33 }
  34
  35
  36 static u32 get_acl_user_id(acl_main_t *am, char *user_module_name, char *val1_label, char *val2_label)
  37 {
  38     acl_lookup_context_user_t *auser;
  39
  40     pool_foreach (auser, am->acl_users,
  41     ({
  42       if (0 == strcmp(auser->user_module_name, user_module_name)) {
  43         return (auser - am->acl_users);
  44       }
  45     }));
  46
  47     pool_get(am->acl_users, auser);
  48     auser->user_module_name = user_module_name;
  49     auser->val1_label = val1_label;
  50     auser->val2_label = val2_label;
  51     return (auser - am->acl_users);
  52 }
  53
  54 static int acl_user_id_valid(acl_main_t *am, u32 acl_user_id)
  55 {
  56
  57   if (pool_is_free_index (am->acl_users, acl_user_id))
  58     return 0;
  59
  60   return 1;
  61 }
  62
  63 static int acl_lc_index_valid(acl_main_t *am, u32 lc_index)
  64 {
  65
  66   if (pool_is_free_index (am->acl_lookup_contexts, lc_index))
  67     return 0;
  68
  69   return 1;
  70 }
  71
  72 /*
  73  * If you are using ACL plugin, get this unique ID first,
  74  * so you can identify yourself when creating the lookup contexts.
  75  */
  76
  77 static u32 acl_plugin_register_user_module (char *user_module_name, char *val1_label, char *val2_label)
  78 {
  79   acl_main_t *am = &acl_main;
  80   /*
  81    * Because folks like to call this early on,
  82    * use the global heap, so as to avoid
  83    * initializing the main ACL heap before
  84    * they start using ACLs.
  85    */
  86   u32 user_id = get_acl_user_id(am, user_module_name, val1_label, val2_label);
  87   return user_id;
  88 }
  89
  90 /*
  91  * Allocate a new lookup context index.
  92  * Supply the id assigned to your module during registration,
  93  * and two values of your choice identifying instances
  94  * of use within your module. They are useful for debugging.
  95  * If >= 0 - context id. If < 0 - error code.
  96  */
  97
  98 static int acl_plugin_get_lookup_context_index (u32 acl_user_id, u32 val1, u32 val2)
  99 {
 100   acl_main_t *am = &acl_main;
 101   acl_lookup_context_t *acontext;
 102
 103   if (!acl_user_id_valid(am, acl_user_id))
 104     return VNET_API_ERROR_INVALID_REGISTRATION;
 105
 106   /*
 107    * The lookup context index allocation is
 108    * an operation done within the global heap,
 109    * so no heap switching necessary.
 110    */
 111
 112   pool_get(am->acl_lookup_contexts, acontext);
 113   acontext->acl_indices = 0;
 114   acontext->context_user_id = acl_user_id;
 115   acontext->user_val1 = val1;
 116   acontext->user_val2 = val2;
 117
 118   u32 new_context_id = acontext - am->acl_lookup_contexts;
 119   vec_add1(am->acl_users[acl_user_id].lookup_contexts, new_context_id);
 120
 121   return new_context_id;
 122 }
 123
 124 static void
 125 lock_acl(acl_main_t *am, u32 acl, u32 lc_index)
 126 {
 127   vec_validate(am->lc_index_vec_by_acl, acl);
 128   elog_acl_cond_trace_X2(am, (am->trace_acl), "lock acl %d in lc_index %d", "i4i4", acl, lc_index);
 129   vec_add1(am->lc_index_vec_by_acl[acl], lc_index);
 130 }
 131
 132 static void
 133 lock_acl_vec(u32 lc_index, u32 *acls)
 134 {
 135   int i;
 136   acl_main_t *am = &acl_main;
 137   for(i=0; i<vec_len(acls); i++) {
 138     lock_acl(am, acls[i], lc_index);
 139   }
 140 }
 141
 142 static void
 143 unlock_acl(acl_main_t *am, u32 acl, u32 lc_index)
 144 {
 145   vec_validate(am->lc_index_vec_by_acl, acl);
 146   elog_acl_cond_trace_X2(am, (am->trace_acl), "unlock acl %d in lc_index %d", "i4i4", acl, lc_index);
 147   u32 index = vec_search(am->lc_index_vec_by_acl[acl], lc_index);
 148   if (index != ~0)
 149     vec_del1(am->lc_index_vec_by_acl[acl], index);
 150   else
 151     clib_warning("BUG: can not unlock acl %d lc_index %d", acl, lc_index);
 152 }
 153
 154 static void
 155 unlock_acl_vec(u32 lc_index, u32 *acls)
 156 {
 157   int i;
 158   acl_main_t *am = &acl_main;
 159   for(i=0; i<vec_len(acls); i++)
 160   unlock_acl(am, acls[i], lc_index);
 161 }
 162
 163
 164 static void
 165 apply_acl_vec(u32 lc_index, u32 *acls)
 166 {
 167   int i;
 168   acl_main_t *am = &acl_main;
 169
 170   for(i=0; i<vec_len(acls); i++)
 171     hash_acl_apply(am, lc_index, acls[i], i);
 172 }
 173
 174
 175 static void
 176 unapply_acl_vec(u32 lc_index, u32 *acls)
 177 {
 178   int i;
 179   acl_main_t *am = &acl_main;
 180   if (vec_len(acls) == 0)
 181     return;
 182   for(i=vec_len(acls); i > 0; i--)
 183     hash_acl_unapply(am, lc_index, acls[i-1]);
 184 }
 185
 186 /*
 187  * Release the lookup context index and destroy
 188  * any associated data structures.
 189  */
 190 static void acl_plugin_put_lookup_context_index (u32 lc_index)
 191 {
 192   acl_main_t *am = &acl_main;
 193
 194   elog_acl_cond_trace_X1(am, (am->trace_acl), "LOOKUP-CONTEXT: put-context lc_index %d", "i4", lc_index);
 195   if (!acl_lc_index_valid(am, lc_index)) {
 196     clib_warning("BUG: lc_index %d is not valid", lc_index);
 197     return;
 198   }
 199
 200   void *oldheap = acl_plugin_set_heap ();
 201   acl_lookup_context_t *acontext = pool_elt_at_index(am->acl_lookup_contexts, lc_index);
 202
 203   u32 index = vec_search(am->acl_users[acontext->context_user_id].lookup_contexts, lc_index);
 204   ASSERT(index != ~0);
 205
 206   vec_del1(am->acl_users[acontext->context_user_id].lookup_contexts, index);
 207   unapply_acl_vec(lc_index, acontext->acl_indices);
 208   unlock_acl_vec(lc_index, acontext->acl_indices);
 209   vec_free(acontext->acl_indices);
 210   pool_put(am->acl_lookup_contexts, acontext);
 211   clib_mem_set_heap (oldheap);
 212 }
 213
 214 /*
 215  * Prepare the sequential vector of ACL#s to lookup within a given context.
 216  * Any existing list will be overwritten. acl_list is a vector.
 217  */
 218 static int acl_plugin_set_acl_vec_for_context (u32 lc_index, u32 *acl_list)
 219 {
 220   int rv = 0;
 221   uword *seen_acl_bitmap = 0;
 222   u32 *pacln = 0;
 223   acl_main_t *am = &acl_main;
 224   acl_lookup_context_t *acontext;
 225   if (am->trace_acl) {
 226     u32 i;
 227     elog_acl_cond_trace_X1(am, (1), "LOOKUP-CONTEXT: set-acl-list lc_index %d", "i4", lc_index);
 228     for(i=0; i<vec_len(acl_list); i++) {
 229       elog_acl_cond_trace_X2(am, (1), "   acl-list[%d]: %d", "i4i4", i, acl_list[i]);
 230     }
 231   }
 232   if (!acl_lc_index_valid(am, lc_index)) {
 233     clib_warning("BUG: lc_index %d is not valid", lc_index);
 234     return -1;
 235   }
 236   void *oldheap = acl_plugin_set_heap ();
 237
 238   vec_foreach (pacln, acl_list)
 239   {
 240     if (pool_is_free_index (am->acls, *pacln))
 241       {
 242         /* ACL is not defined. Can not apply */
 243         clib_warning ("ERROR: ACL %d not defined", *pacln);
 244         rv = VNET_API_ERROR_NO_SUCH_ENTRY;
 245         goto done;
 246       }
 247     if (clib_bitmap_get (seen_acl_bitmap, *pacln))
 248       {
 249         /* ACL being applied twice within the list. error. */
 250         clib_warning ("ERROR: ACL %d being applied twice", *pacln);
 251         rv = VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 252         goto done;
 253       }
 254     seen_acl_bitmap = clib_bitmap_set (seen_acl_bitmap, *pacln, 1);
 255   }
 256
 257   acontext = pool_elt_at_index(am->acl_lookup_contexts, lc_index);
 258   u32 *old_acl_vector = acontext->acl_indices;
 259   acontext->acl_indices = vec_dup(acl_list);
 260
 261   unapply_acl_vec(lc_index, old_acl_vector);
 262   unlock_acl_vec(lc_index, old_acl_vector);
 263   lock_acl_vec(lc_index, acontext->acl_indices);
 264   apply_acl_vec(lc_index, acontext->acl_indices);
 265
 266   vec_free(old_acl_vector);
 267
 268 done:
 269   clib_bitmap_free (seen_acl_bitmap);
 270   clib_mem_set_heap (oldheap);
 271   return rv;
 272 }
 273
 274
 275 void acl_plugin_lookup_context_notify_acl_change(u32 acl_num)
 276 {
 277   acl_main_t *am = &acl_main;
 278   if (acl_plugin_acl_exists(acl_num)) {
 279     if (hash_acl_exists(am, acl_num)) {
 280         /* this is a modification, clean up the older entries */
 281         hash_acl_delete(am, acl_num);
 282     }
 283     hash_acl_add(am, acl_num);
 284   } else {
 285     /* this is a deletion notification */
 286     hash_acl_delete(am, acl_num);
 287   }
 288 }
 289
 290
 291 /* Fill the 5-tuple from the packet */
 292
 293 static void acl_plugin_fill_5tuple (u32 lc_index, vlib_buffer_t * b0, int is_ip6, int is_input,
 294                                 int is_l2_path, fa_5tuple_opaque_t * p5tuple_pkt)
 295 {
 296   acl_plugin_fill_5tuple_inline(&acl_main, lc_index, b0, is_ip6, is_input, is_l2_path, p5tuple_pkt);
 297 }
 298
 299 static int acl_plugin_match_5tuple (u32 lc_index,
 300                                            fa_5tuple_opaque_t * pkt_5tuple,
 301                                            int is_ip6, u8 * r_action,
 302                                            u32 * r_acl_pos_p,
 303                                            u32 * r_acl_match_p,
 304                                            u32 * r_rule_match_p,
 305                                            u32 * trace_bitmap)
 306 {
 307   return acl_plugin_match_5tuple_inline (&acl_main, lc_index, pkt_5tuple, is_ip6, r_action, r_acl_pos_p, r_acl_match_p, r_rule_match_p, trace_bitmap);
 308 }
 309
 310
 311 void
 312 acl_plugin_show_lookup_user (u32 user_index)
 313 {
 314     acl_main_t *am = &acl_main;
 315     vlib_main_t *vm = am->vlib_main;
 316     acl_lookup_context_user_t *auser;
 317
 318     pool_foreach (auser, am->acl_users,
 319     ({
 320       u32 curr_user_index = (auser - am->acl_users);
 321       if (user_index == ~0 || (curr_user_index == user_index)) {
 322         vlib_cli_output (vm, "index %d:%s:%s:%s", curr_user_index, auser->user_module_name, auser->val1_label, auser->val2_label);
 323       }
 324     }));
 325 }
 326
 327
 328 void
 329 acl_plugin_show_lookup_context (u32 lc_index)
 330 {
 331   acl_main_t *am = &acl_main;
 332   vlib_main_t *vm = am->vlib_main;
 333   acl_lookup_context_t *acontext;
 334   // clib_warning("LOOKUP-CONTEXT: lc_index %d acl_list [ %U ]", lc_index, format_vec32, acl_list, "%d");
 335   if (!am->acl_lookup_contexts)
 336   {
 337     vlib_cli_output(vm, "ACL lookup contexts are not initialized");
 338     return;
 339   }
 340
 341   pool_foreach (acontext, am->acl_lookup_contexts,
 342   ({
 343     u32 curr_lc_index = (acontext - am->acl_lookup_contexts);
 344     if ((lc_index == ~0) || (curr_lc_index == lc_index)) {
 345       if (acl_user_id_valid(am, acontext->context_user_id)) {
 346         acl_lookup_context_user_t *auser = pool_elt_at_index(am->acl_users, acontext->context_user_id);
 347         vlib_cli_output (vm, "index %d:%s %s: %d %s: %d, acl_indices: %U",
 348                        curr_lc_index, auser->user_module_name, auser->val1_label,
 349                        acontext->user_val1, auser->val2_label, acontext->user_val2,
 350                        format_vec32, acontext->acl_indices, "%d");
 351       } else {
 352         vlib_cli_output (vm, "index %d: user_id: %d user_val1: %d user_val2: %d, acl_indices: %U",
 353                        curr_lc_index, acontext->context_user_id,
 354                        acontext->user_val1, acontext->user_val2,
 355                        format_vec32, acontext->acl_indices, "%d");
 356       }
 357     }
 358   }));
 359 }
 360
 361 void *
 362 acl_plugin_get_p_acl_main(void)
 363 {
 364   return &acl_main;
 365 }
 366
 367 clib_error_t *acl_plugin_methods_vtable_init(acl_plugin_methods_t *m)
 368 {
 369   m->p_acl_main = &acl_main;
 370 #define _(name) m->name = acl_plugin_ ## name;
 371   foreach_acl_plugin_exported_method_name
 372 #undef _
 373   return 0;
 374 }