FD.io VPP  v18.10-34-gcce845e
Vector Packet Processing
public_inlines.h
Go to the documentation of this file.
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 #ifndef included_acl_inlines_h
17 #define included_acl_inlines_h
18 
19 #include <stdint.h>
20 
21 #include <vlib/unix/plugin.h>
22 #include <plugins/acl/acl.h>
23 #include <plugins/acl/fa_node.h>
25 
27 
28 #define LOAD_SYMBOL_FROM_PLUGIN_TO(p, s, st) \
29 ({ \
30  st = vlib_get_plugin_symbol(p, #s); \
31  if (!st) \
32  return clib_error_return(0, \
33  "Plugin %s and/or symbol %s not found.", p, #s); \
34 })
35 
36 #define LOAD_SYMBOL(s) LOAD_SYMBOL_FROM_PLUGIN_TO("acl_plugin.so", s, s)
37 
38 
40 {
42 
44  return (mvi(m));
45 }
46 
47 always_inline void *
49 {
50  u8 *p = vlib_buffer_get_current (b0) + offset;
51  return p;
52 }
53 
54 always_inline int
56 {
57  /* For the purposes of this code, "within" means we have at least 8 bytes after it */
58  return (offset <= (b0->current_length - 8));
59 }
60 
61 
62 always_inline void
64  int l3_offset, fa_5tuple_t * p5tuple_pkt)
65 {
66  if (is_ip6)
67  {
68  clib_memcpy (&p5tuple_pkt->ip6_addr,
70  offsetof (ip6_header_t,
71  src_address) + l3_offset),
72  sizeof (p5tuple_pkt->ip6_addr));
73  }
74  else
75  {
76  memset(p5tuple_pkt->l3_zero_pad, 0, sizeof(p5tuple_pkt->l3_zero_pad));
77  clib_memcpy (&p5tuple_pkt->ip4_addr,
79  offsetof (ip4_header_t,
80  src_address) + l3_offset),
81  sizeof (p5tuple_pkt->ip4_addr));
82  }
83 }
84 
85 always_inline void
86 acl_fill_5tuple_l4_and_pkt_data (acl_main_t * am, u32 sw_if_index0, vlib_buffer_t * b0, int is_ip6, int is_input,
87  int l3_offset, fa_session_l4_key_t *p5tuple_l4, fa_packet_info_t *p5tuple_pkt)
88 {
89  /* IP4 and IP6 protocol numbers of ICMP */
90  static u8 icmp_protos_v4v6[] = { IP_PROTOCOL_ICMP, IP_PROTOCOL_ICMP6 };
91 
92  int l4_offset;
93  u16 ports[2];
94  u8 proto;
95 
96  fa_session_l4_key_t tmp_l4 = { .lsb_of_sw_if_index = sw_if_index0 & 0xffff };
97  fa_packet_info_t tmp_pkt = { .is_ip6 = is_ip6, .mask_type_index_lsb = ~0 };
98 
99  if (is_ip6)
100  {
101  proto =
102  *(u8 *) get_ptr_to_offset (b0,
103  offsetof (ip6_header_t,
104  protocol) + l3_offset);
105  l4_offset = l3_offset + sizeof (ip6_header_t);
106 #ifdef FA_NODE_VERBOSE_DEBUG
107  clib_warning ("ACL_FA_NODE_DBG: proto: %d, l4_offset: %d", proto,
108  l4_offset);
109 #endif
110  /* IP6 EH handling is here, increment l4_offset if needs to, update the proto */
111  int need_skip_eh = clib_bitmap_get (am->fa_ipv6_known_eh_bitmap, proto);
112  if (PREDICT_FALSE (need_skip_eh))
113  {
114  while (need_skip_eh && offset_within_packet (b0, l4_offset))
115  {
116  /* Fragment header needs special handling */
117  if (PREDICT_FALSE(ACL_EH_FRAGMENT == proto))
118  {
119  proto = *(u8 *) get_ptr_to_offset (b0, l4_offset);
120  u16 frag_offset;
121  clib_memcpy (&frag_offset, get_ptr_to_offset (b0, 2 + l4_offset), sizeof(frag_offset));
122  frag_offset = clib_net_to_host_u16(frag_offset) >> 3;
123  if (frag_offset)
124  {
125  tmp_pkt.is_nonfirst_fragment = 1;
126  /* invalidate L4 offset so we don't try to find L4 info */
127  l4_offset += b0->current_length;
128  }
129  else
130  {
131  /* First fragment: skip the frag header and move on. */
132  l4_offset += 8;
133  }
134  }
135  else
136  {
137  u8 nwords = *(u8 *) get_ptr_to_offset (b0, 1 + l4_offset);
138  proto = *(u8 *) get_ptr_to_offset (b0, l4_offset);
139  l4_offset += 8 * (1 + (u16) nwords);
140  }
141 #ifdef FA_NODE_VERBOSE_DEBUG
142  clib_warning ("ACL_FA_NODE_DBG: new proto: %d, new offset: %d",
143  proto, l4_offset);
144 #endif
145  need_skip_eh =
147  }
148  }
149  }
150  else
151  {
152  proto =
153  *(u8 *) get_ptr_to_offset (b0,
154  offsetof (ip4_header_t,
155  protocol) + l3_offset);
156  l4_offset = l3_offset + sizeof (ip4_header_t);
157  u16 flags_and_fragment_offset;
158  clib_memcpy (&flags_and_fragment_offset,
159  get_ptr_to_offset (b0,
160  offsetof (ip4_header_t,
161  flags_and_fragment_offset)) + l3_offset,
162  sizeof(flags_and_fragment_offset));
163  flags_and_fragment_offset = clib_net_to_host_u16 (flags_and_fragment_offset);
164 
165  /* non-initial fragments have non-zero offset */
166  if ((PREDICT_FALSE(0xfff & flags_and_fragment_offset)))
167  {
168  tmp_pkt.is_nonfirst_fragment = 1;
169  /* invalidate L4 offset so we don't try to find L4 info */
170  l4_offset += b0->current_length;
171  }
172 
173  }
174  tmp_l4.proto = proto;
175  tmp_l4.is_input = is_input;
176 
177  if (PREDICT_TRUE (offset_within_packet (b0, l4_offset)))
178  {
179  tmp_pkt.l4_valid = 1;
180  if (icmp_protos_v4v6[is_ip6] == proto)
181  {
182  /* type */
183  tmp_l4.port[0] =
184  *(u8 *) get_ptr_to_offset (b0,
185  l4_offset + offsetof (icmp46_header_t,
186  type));
187  /* code */
188  tmp_l4.port[1] =
189  *(u8 *) get_ptr_to_offset (b0,
190  l4_offset + offsetof (icmp46_header_t,
191  code));
192  tmp_l4.is_slowpath = 1;
193  }
194  else if ((IP_PROTOCOL_TCP == proto) || (IP_PROTOCOL_UDP == proto))
195  {
196  clib_memcpy (&ports,
197  get_ptr_to_offset (b0,
198  l4_offset + offsetof (tcp_header_t,
199  src_port)),
200  sizeof (ports));
201  tmp_l4.port[0] = clib_net_to_host_u16 (ports[0]);
202  tmp_l4.port[1] = clib_net_to_host_u16 (ports[1]);
203 
204  tmp_pkt.tcp_flags =
205  *(u8 *) get_ptr_to_offset (b0,
206  l4_offset + offsetof (tcp_header_t,
207  flags));
208  tmp_pkt.tcp_flags_valid = (proto == IP_PROTOCOL_TCP);
209  tmp_l4.is_slowpath = 0;
210  }
211  else
212  {
213  tmp_l4.is_slowpath = 1;
214  }
215  }
216 
217  p5tuple_pkt->as_u64 = tmp_pkt.as_u64;
218  p5tuple_l4->as_u64 = tmp_l4.as_u64;
219 }
220 
221 always_inline void
222 acl_fill_5tuple (acl_main_t * am, u32 sw_if_index0, vlib_buffer_t * b0, int is_ip6,
223  int is_input, int is_l2_path, fa_5tuple_t * p5tuple_pkt)
224 {
225  int l3_offset;
226 
227  if (is_l2_path)
228  {
229  l3_offset = ethernet_buffer_header_size(b0);
230  }
231  else
232  {
233  if (is_input)
234  l3_offset = 0;
235  else
236  l3_offset = vnet_buffer(b0)->ip.save_rewrite_length;
237  }
238 
239  /* key[0..3] contains src/dst address and is cleared/set below */
240  /* Remainder of the key and per-packet non-key data */
241  acl_fill_5tuple_l3_data(am, b0, is_ip6, l3_offset, p5tuple_pkt);
242  acl_fill_5tuple_l4_and_pkt_data(am, sw_if_index0, b0, is_ip6, is_input, l3_offset, &p5tuple_pkt->l4, &p5tuple_pkt->pkt);
243 }
244 
245 always_inline void
246 acl_plugin_fill_5tuple_inline (void *p_acl_main, u32 lc_index, vlib_buffer_t * b0, int is_ip6,
247  int is_input, int is_l2_path, fa_5tuple_opaque_t * p5tuple_pkt)
248 {
249  acl_main_t *am = p_acl_main;
250  acl_fill_5tuple(am, 0, b0, is_ip6, is_input, is_l2_path, (fa_5tuple_t *)p5tuple_pkt);
251 }
252 
253 
254 
255 always_inline int
257  int prefixlen)
258 {
259  if (prefixlen == 0)
260  {
261  /* match any always succeeds */
262  return 1;
263  }
264  uint32_t a1 = clib_net_to_host_u32 (addr1->as_u32);
265  uint32_t a2 = clib_net_to_host_u32 (addr2->as_u32);
266  uint32_t mask0 = 0xffffffff - ((1 << (32 - prefixlen)) - 1);
267  return (a1 & mask0) == a2;
268 }
269 
270 always_inline int
272  int prefixlen)
273 {
274  if (prefixlen == 0)
275  {
276  /* match any always succeeds */
277  return 1;
278  }
279  if (memcmp (addr1, addr2, prefixlen / 8))
280  {
281  /* If the starting full bytes do not match, no point in bittwidling the thumbs further */
282  return 0;
283  }
284  if (prefixlen % 8)
285  {
286  u8 b1 = *((u8 *) addr1 + 1 + prefixlen / 8);
287  u8 b2 = *((u8 *) addr2 + 1 + prefixlen / 8);
288  u8 mask0 = (0xff - ((1 << (8 - (prefixlen % 8))) - 1));
289  return (b1 & mask0) == b2;
290  }
291  else
292  {
293  /* The prefix fits into integer number of bytes, so nothing left to do */
294  return 1;
295  }
296 }
297 
298 always_inline int
299 fa_acl_match_port (u16 port, u16 port_first, u16 port_last, int is_ip6)
300 {
301  return ((port >= port_first) && (port <= port_last));
302 }
303 
304 always_inline int
305 single_acl_match_5tuple (acl_main_t * am, u32 acl_index, fa_5tuple_t * pkt_5tuple,
306  int is_ip6, u8 * r_action, u32 * r_acl_match_p,
307  u32 * r_rule_match_p, u32 * trace_bitmap)
308 {
309  int i;
310  acl_list_t *a;
311  acl_rule_t *r;
312 
313  if (pool_is_free_index (am->acls, acl_index))
314  {
315  if (r_acl_match_p)
316  *r_acl_match_p = acl_index;
317  if (r_rule_match_p)
318  *r_rule_match_p = -1;
319  /* the ACL does not exist but is used for policy. Block traffic. */
320  return 0;
321  }
322  a = am->acls + acl_index;
323  for (i = 0; i < a->count; i++)
324  {
325  r = a->rules + i;
326  if (is_ip6 != r->is_ipv6)
327  {
328  continue;
329  }
330  if (is_ip6) {
332  (&pkt_5tuple->ip6_addr[1], &r->dst.ip6, r->dst_prefixlen))
333  continue;
335  (&pkt_5tuple->ip6_addr[0], &r->src.ip6, r->src_prefixlen))
336  continue;
337  } else {
339  (&pkt_5tuple->ip4_addr[1], &r->dst.ip4, r->dst_prefixlen))
340  continue;
342  (&pkt_5tuple->ip4_addr[0], &r->src.ip4, r->src_prefixlen))
343  continue;
344  }
345 
346  if (r->proto)
347  {
348  if (pkt_5tuple->l4.proto != r->proto)
349  continue;
350 
351  if (PREDICT_FALSE (pkt_5tuple->pkt.is_nonfirst_fragment &&
353  {
354  /* non-initial fragment with frag match configured - match this rule */
355  *trace_bitmap |= 0x80000000;
356  *r_action = r->is_permit;
357  if (r_acl_match_p)
358  *r_acl_match_p = acl_index;
359  if (r_rule_match_p)
360  *r_rule_match_p = i;
361  return 1;
362  }
363 
364  /* A sanity check just to ensure we are about to match the ports extracted from the packet */
365  if (PREDICT_FALSE (!pkt_5tuple->pkt.l4_valid))
366  continue;
367 
368 #ifdef FA_NODE_VERBOSE_DEBUG
370  ("ACL_FA_NODE_DBG acl %d rule %d pkt proto %d match rule %d",
371  acl_index, i, pkt_5tuple->l4.proto, r->proto);
372 #endif
373 
374  if (!fa_acl_match_port
375  (pkt_5tuple->l4.port[0], r->src_port_or_type_first,
376  r->src_port_or_type_last, is_ip6))
377  continue;
378 
379 #ifdef FA_NODE_VERBOSE_DEBUG
381  ("ACL_FA_NODE_DBG acl %d rule %d pkt sport %d match rule [%d..%d]",
382  acl_index, i, pkt_5tuple->l4.port[0], r->src_port_or_type_first,
384 #endif
385 
386  if (!fa_acl_match_port
387  (pkt_5tuple->l4.port[1], r->dst_port_or_code_first,
388  r->dst_port_or_code_last, is_ip6))
389  continue;
390 
391 #ifdef FA_NODE_VERBOSE_DEBUG
393  ("ACL_FA_NODE_DBG acl %d rule %d pkt dport %d match rule [%d..%d]",
394  acl_index, i, pkt_5tuple->l4.port[1], r->dst_port_or_code_first,
396 #endif
397  if (pkt_5tuple->pkt.tcp_flags_valid
398  && ((pkt_5tuple->pkt.tcp_flags & r->tcp_flags_mask) !=
399  r->tcp_flags_value))
400  continue;
401  }
402  /* everything matches! */
403 #ifdef FA_NODE_VERBOSE_DEBUG
404  clib_warning ("ACL_FA_NODE_DBG acl %d rule %d FULL-MATCH, action %d",
405  acl_index, i, r->is_permit);
406 #endif
407  *r_action = r->is_permit;
408  if (r_acl_match_p)
409  *r_acl_match_p = acl_index;
410  if (r_rule_match_p)
411  *r_rule_match_p = i;
412  return 1;
413  }
414  return 0;
415 }
416 
417 always_inline int
418 acl_plugin_single_acl_match_5tuple (void *p_acl_main, u32 acl_index, fa_5tuple_t * pkt_5tuple,
419  int is_ip6, u8 * r_action, u32 * r_acl_match_p,
420  u32 * r_rule_match_p, u32 * trace_bitmap)
421 {
422  acl_main_t * am = p_acl_main;
423  return single_acl_match_5tuple(am, acl_index, pkt_5tuple, is_ip6, r_action,
424  r_acl_match_p, r_rule_match_p, trace_bitmap);
425 }
426 
427 always_inline int
428 linear_multi_acl_match_5tuple (void *p_acl_main, u32 lc_index, fa_5tuple_t * pkt_5tuple,
429  int is_ip6, u8 *r_action, u32 *acl_pos_p, u32 * acl_match_p,
430  u32 * rule_match_p, u32 * trace_bitmap)
431 {
432  acl_main_t *am = p_acl_main;
433  int i;
434  u32 *acl_vector;
435  u8 action = 0;
437 
438  acl_vector = acontext->acl_indices;
439 
440  for (i = 0; i < vec_len (acl_vector); i++)
441  {
442 #ifdef FA_NODE_VERBOSE_DEBUG
443  clib_warning ("ACL_FA_NODE_DBG: Trying to match ACL: %d",
444  acl_vector[i]);
445 #endif
447  (am, acl_vector[i], pkt_5tuple, is_ip6, &action,
448  acl_match_p, rule_match_p, trace_bitmap))
449  {
450  *r_action = action;
451  *acl_pos_p = i;
452  return 1;
453  }
454  }
455  if (vec_len (acl_vector) > 0)
456  {
457  return 0;
458  }
459 #ifdef FA_NODE_VERBOSE_DEBUG
460  clib_warning ("ACL_FA_NODE_DBG: No ACL on lc_index %d", lc_index);
461 #endif
462  /* If there are no ACLs defined we should not be here. */
463  return 0;
464 }
465 
466 
467 
468 /*
469  * This returns true if there is indeed a match on the portranges.
470  * With all these levels of indirections, this is not going to be very fast,
471  * so, best use the individual ports or wildcard ports for performance.
472  */
473 always_inline int
475 {
476 
478  applied_hash_ace_entry_t *pae = vec_elt_at_index((*applied_hash_aces), index);
479 
480  acl_rule_t *r = &(am->acls[pae->acl_index].rules[pae->ace_index]);
481 
482 #ifdef FA_NODE_VERBOSE_DEBUG
483  clib_warning("PORTMATCH: %d <= %d <= %d && %d <= %d <= %d ?",
486 #endif
487 
488  return ( ((r->src_port_or_type_first <= match->l4.port[0]) && r->src_port_or_type_last >= match->l4.port[0]) &&
489  ((r->dst_port_or_code_first <= match->l4.port[1]) && r->dst_port_or_code_last >= match->l4.port[1]) );
490 }
491 
492 always_inline int
493 single_rule_match_5tuple (acl_rule_t * r, int is_ip6, fa_5tuple_t * pkt_5tuple)
494 {
495  if (is_ip6 != r->is_ipv6)
496  {
497  return 0;
498  }
499 
500  if (is_ip6)
501  {
503  (&pkt_5tuple->ip6_addr[1], &r->dst.ip6, r->dst_prefixlen))
504  return 0;
506  (&pkt_5tuple->ip6_addr[0], &r->src.ip6, r->src_prefixlen))
507  return 0;
508  }
509  else
510  {
512  (&pkt_5tuple->ip4_addr[1], &r->dst.ip4, r->dst_prefixlen))
513  return 0;
515  (&pkt_5tuple->ip4_addr[0], &r->src.ip4, r->src_prefixlen))
516  return 0;
517  }
518 
519  if (r->proto)
520  {
521  if (pkt_5tuple->l4.proto != r->proto)
522  return 0;
523 
524  /* A sanity check just to ensure we are about to match the ports extracted from the packet */
525  if (PREDICT_FALSE (!pkt_5tuple->pkt.l4_valid))
526  return 0;
527 
528 
529  if (!fa_acl_match_port
530  (pkt_5tuple->l4.port[0], r->src_port_or_type_first,
531  r->src_port_or_type_last, pkt_5tuple->pkt.is_ip6))
532  return 0;
533 
534 
535  if (!fa_acl_match_port
536  (pkt_5tuple->l4.port[1], r->dst_port_or_code_first,
537  r->dst_port_or_code_last, pkt_5tuple->pkt.is_ip6))
538  return 0;
539 
540  if (pkt_5tuple->pkt.tcp_flags_valid
541  && ((pkt_5tuple->pkt.tcp_flags & r->tcp_flags_mask) !=
542  r->tcp_flags_value))
543  return 0;
544  }
545  /* everything matches! */
546  return 1;
547 }
548 
551 {
553  clib_bihash_kv_48_8_t result;
554  fa_5tuple_t *kv_key = (fa_5tuple_t *) kv.key;
555  hash_acl_lookup_value_t *result_val =
556  (hash_acl_lookup_value_t *) & result.value;
557  u64 *pmatch = (u64 *) match;
558  u64 *pmask;
559  u64 *pkey;
560  int mask_type_index, order_index;
561  u32 curr_match_index = (~0 - 1);
562 
563 
564 
565  u32 lc_index = match->pkt.lc_index;
566  applied_hash_ace_entry_t **applied_hash_aces =
568 
569  hash_applied_mask_info_t **hash_applied_mask_info_vec =
571 
573 
574  DBG ("TRYING TO MATCH: %016llx %016llx %016llx %016llx %016llx %016llx",
575  pmatch[0], pmatch[1], pmatch[2], pmatch[3], pmatch[4], pmatch[5]);
576 
577  for (order_index = 0; order_index < vec_len ((*hash_applied_mask_info_vec));
578  order_index++)
579  {
580  minfo = vec_elt_at_index ((*hash_applied_mask_info_vec), order_index);
581  if (minfo->first_rule_index > curr_match_index)
582  {
583  /* Index in this and following (by construction) partitions are greater than our candidate, Avoid trying to match! */
584  break;
585  }
586 
587  mask_type_index = minfo->mask_type_index;
588  ace_mask_type_entry_t *mte =
589  vec_elt_at_index (am->ace_mask_type_pool, mask_type_index);
590  pmatch = (u64 *) match;
591  pmask = (u64 *) & mte->mask;
592  pkey = (u64 *) kv.key;
593  /*
594  * unrolling the below loop results in a noticeable performance increase.
595  int i;
596  for(i=0; i<6; i++) {
597  kv.key[i] = pmatch[i] & pmask[i];
598  }
599  */
600 
601  *pkey++ = *pmatch++ & *pmask++;
602  *pkey++ = *pmatch++ & *pmask++;
603  *pkey++ = *pmatch++ & *pmask++;
604  *pkey++ = *pmatch++ & *pmask++;
605  *pkey++ = *pmatch++ & *pmask++;
606  *pkey++ = *pmatch++ & *pmask++;
607 
608  /*
609  * The use of temporary variable convinces the compiler
610  * to make a u64 write, avoiding the stall on crc32 operation
611  * just a bit later.
612  */
613  fa_packet_info_t tmp_pkt = kv_key->pkt;
614  tmp_pkt.mask_type_index_lsb = mask_type_index;
615  kv_key->pkt.as_u64 = tmp_pkt.as_u64;
616 
617  int res =
618  clib_bihash_search_inline_2_48_8 (&am->acl_lookup_hash, &kv, &result);
619 
620  if (res == 0)
621  {
622  /* There is a hit in the hash, so check the collision vector */
623  u32 curr_index = result_val->applied_entry_index;
625  vec_elt_at_index ((*applied_hash_aces), curr_index);
627  int i;
628  for (i = 0; i < vec_len (crs); i++)
629  {
630  if (crs[i].applied_entry_index >= curr_match_index)
631  {
632  continue;
633  }
634  if (single_rule_match_5tuple (&crs[i].rule, is_ip6, match))
635  {
636  curr_match_index = crs[i].applied_entry_index;
637  }
638  }
639  }
640  }
641  DBG ("MATCH-RESULT: %d", curr_match_index);
642  return curr_match_index;
643 }
644 
645 always_inline int
646 hash_multi_acl_match_5tuple (void *p_acl_main, u32 lc_index, fa_5tuple_t * pkt_5tuple,
647  int is_ip6, u8 *action, u32 *acl_pos_p, u32 * acl_match_p,
648  u32 * rule_match_p, u32 * trace_bitmap)
649 {
650  acl_main_t *am = p_acl_main;
651  applied_hash_ace_entry_t **applied_hash_aces = vec_elt_at_index(am->hash_entry_vec_by_lc_index, lc_index);
652  u32 match_index = multi_acl_match_get_applied_ace_index(am, is_ip6, pkt_5tuple);
653  if (match_index < vec_len((*applied_hash_aces))) {
654  applied_hash_ace_entry_t *pae = vec_elt_at_index((*applied_hash_aces), match_index);
655  pae->hitcount++;
656  *acl_pos_p = pae->acl_position;
657  *acl_match_p = pae->acl_index;
658  *rule_match_p = pae->ace_index;
659  *action = pae->action;
660  return 1;
661  }
662  return 0;
663 }
664 
665 
666 
667 always_inline int
668 acl_plugin_match_5tuple_inline (void *p_acl_main, u32 lc_index,
669  fa_5tuple_opaque_t * pkt_5tuple,
670  int is_ip6, u8 * r_action,
671  u32 * r_acl_pos_p,
672  u32 * r_acl_match_p,
673  u32 * r_rule_match_p,
674  u32 * trace_bitmap)
675 {
676  acl_main_t *am = p_acl_main;
677  fa_5tuple_t * pkt_5tuple_internal = (fa_5tuple_t *)pkt_5tuple;
678  pkt_5tuple_internal->pkt.lc_index = lc_index;
680  if (PREDICT_FALSE(pkt_5tuple_internal->pkt.is_nonfirst_fragment)) {
681  /*
682  * tuplemerge does not take fragments into account,
683  * and in general making fragments first class citizens has
684  * proved more overhead than it's worth - so just fall back to linear
685  * matching in that case.
686  */
687  return linear_multi_acl_match_5tuple(p_acl_main, lc_index, pkt_5tuple_internal, is_ip6, r_action,
688  r_acl_pos_p, r_acl_match_p, r_rule_match_p, trace_bitmap);
689  } else {
690  return hash_multi_acl_match_5tuple(p_acl_main, lc_index, pkt_5tuple_internal, is_ip6, r_action,
691  r_acl_pos_p, r_acl_match_p, r_rule_match_p, trace_bitmap);
692  }
693  } else {
694  return linear_multi_acl_match_5tuple(p_acl_main, lc_index, pkt_5tuple_internal, is_ip6, r_action,
695  r_acl_pos_p, r_acl_match_p, r_rule_match_p, trace_bitmap);
696  }
697 }
698 
699 
700 
701 #endif
acl_rule_t * rules
Definition: acl.h:95
static void acl_fill_5tuple(acl_main_t *am, u32 sw_if_index0, vlib_buffer_t *b0, int is_ip6, int is_input, int is_l2_path, fa_5tuple_t *p5tuple_pkt)
u8 is_ipv6
Definition: types.h:24
fa_5tuple_t mask
Definition: acl.h:123
Definition: acl.h:119
a
Definition: bitmap.h:538
u32 acl_index
static int acl_plugin_single_acl_match_5tuple(void *p_acl_main, u32 acl_index, fa_5tuple_t *pkt_5tuple, int is_ip6, u8 *r_action, u32 *r_acl_match_p, u32 *r_rule_match_p, u32 *trace_bitmap)
fa_session_l4_key_t l4
Definition: fa_node.h:71
fa_packet_info_t pkt
Definition: fa_node.h:73
#define PREDICT_TRUE(x)
Definition: clib.h:108
unsigned long u64
Definition: types.h:89
int l4_match_nonfirst_fragment
Definition: acl.h:271
static int fa_acl_match_ip4_addr(ip4_address_t *addr1, ip4_address_t *addr2, int prefixlen)
clib_error_t * acl_plugin_methods_vtable_init(acl_plugin_methods_t *m)
static void acl_fill_5tuple_l3_data(acl_main_t *am, vlib_buffer_t *b0, int is_ip6, int l3_offset, fa_5tuple_t *p5tuple_pkt)
u8 dst_prefixlen
Definition: types.h:28
#define ethernet_buffer_header_size(b)
Determine the size of the Ethernet headers of the current frame in the buffer.
Definition: ethernet.h:438
u8 action
static int fa_acl_match_port(u16 port, u16 port_first, u16 port_last, int is_ip6)
u32 count
Definition: acl.h:94
int i
static int fa_acl_match_ip6_addr(ip6_address_t *addr1, ip6_address_t *addr2, int prefixlen)
struct _tcp_header tcp_header_t
unsigned char u8
Definition: types.h:56
static void * get_ptr_to_offset(vlib_buffer_t *b0, int offset)
u16 src_port
Definition: udp.api:41
u16 lsb_of_sw_if_index
Definition: fa_node.h:51
u16 dst_port_or_code_last
Definition: types.h:33
u8 src_prefixlen
Definition: types.h:26
memset(h->entries, 0, sizeof(h->entries[0])*entries)
u32 acl_position
#define always_inline
Definition: clib.h:94
ip46_address_t src
Definition: types.h:25
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static void acl_fill_5tuple_l4_and_pkt_data(acl_main_t *am, u32 sw_if_index0, vlib_buffer_t *b0, int is_ip6, int is_input, int l3_offset, fa_session_l4_key_t *p5tuple_l4, fa_packet_info_t *p5tuple_pkt)
u8 is_permit
Definition: types.h:23
static int hash_multi_acl_match_5tuple(void *p_acl_main, u32 lc_index, fa_5tuple_t *pkt_5tuple, int is_ip6, u8 *action, u32 *acl_pos_p, u32 *acl_match_p, u32 *rule_match_p, u32 *trace_bitmap)
unsigned int u32
Definition: types.h:88
static u32 multi_acl_match_get_applied_ace_index(acl_main_t *am, int is_ip6, fa_5tuple_t *match)
static void acl_plugin_fill_5tuple_inline(void *p_acl_main, u32 lc_index, vlib_buffer_t *b0, int is_ip6, int is_input, int is_l2_path, fa_5tuple_opaque_t *p5tuple_pkt)
ip46_address_t dst
Definition: types.h:27
collision_match_rule_t * colliding_rules
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
u32 l3_zero_pad[6]
Definition: fa_node.h:66
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
u16 dst_port_or_code_first
Definition: types.h:32
hash_applied_mask_info_t ** hash_applied_mask_info_vec_by_lc_index
Definition: acl.h:209
unsigned short u16
Definition: types.h:57
uword * fa_ipv6_known_eh_bitmap
Definition: acl.h:268
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:205
u64 hitcount
#define PREDICT_FALSE(x)
Definition: clib.h:107
clib_bihash_48_8_t acl_lookup_hash
Definition: acl.h:143
vl_api_address_union_t src_address
Definition: ip_types.api:49
u8 proto
Definition: types.h:29
u16 src_port_or_type_first
Definition: types.h:30
u32 flags
Definition: vhost_user.h:115
#define clib_warning(format, args...)
Definition: error.h:59
#define clib_memcpy(a, b, c)
Definition: string.h:75
#define DBG(...)
int use_hash_acl_matching
Definition: acl.h:196
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:271
static clib_error_t * acl_plugin_exports_init(acl_plugin_methods_t *m)
applied_hash_ace_entry_t ** hash_entry_vec_by_lc_index
Definition: acl.h:157
static uword clib_bitmap_get(uword *ai, uword i)
Gets the ith bit value from a bitmap.
Definition: bitmap.h:197
static int single_acl_match_5tuple(acl_main_t *am, u32 acl_index, fa_5tuple_t *pkt_5tuple, int is_ip6, u8 *r_action, u32 *r_acl_match_p, u32 *r_rule_match_p, u32 *trace_bitmap)
static int offset_within_packet(vlib_buffer_t *b0, int offset)
static int match_portranges(acl_main_t *am, fa_5tuple_t *match, u32 index)
u8 tcp_flags_valid
Definition: fa_node.h:33
static int acl_plugin_match_5tuple_inline(void *p_acl_main, u32 lc_index, fa_5tuple_opaque_t *pkt_5tuple, int is_ip6, u8 *r_action, u32 *r_acl_pos_p, u32 *r_acl_match_p, u32 *r_rule_match_p, u32 *trace_bitmap)
u16 src_port_or_type_last
Definition: types.h:31
ace_mask_type_entry_t * ace_mask_type_pool
Definition: acl.h:206
static int single_rule_match_5tuple(acl_rule_t *r, int is_ip6, fa_5tuple_t *pkt_5tuple)
template key/value backing page structure
Definition: bihash_doc.h:44
u8 is_nonfirst_fragment
Definition: fa_node.h:35
acl_lookup_context_t * acl_lookup_contexts
Definition: acl.h:139
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 tcp_flags_mask
Definition: types.h:35
clib_error_t *(* acl_plugin_methods_vtable_init_fn_t)(acl_plugin_methods_t *m)
struct clib_bihash_value offset
template key/value backing page structure
#define vnet_buffer(b)
Definition: buffer.h:344
u8 tcp_flags_value
Definition: types.h:34
#define LOAD_SYMBOL_FROM_PLUGIN_TO(p, s, st)
ip4_address_t ip4_addr[2]
Definition: fa_node.h:67
u16 mask_type_index_lsb
Definition: fa_node.h:31
Definition: acl.h:89
acl_list_t * acls
Definition: acl.h:141
u32 ace_index
static int linear_multi_acl_match_5tuple(void *p_acl_main, u32 lc_index, fa_5tuple_t *pkt_5tuple, int is_ip6, u8 *r_action, u32 *acl_pos_p, u32 *acl_match_p, u32 *rule_match_p, u32 *trace_bitmap)
ip6_address_t ip6_addr[2]
Definition: fa_node.h:69