FD.io VPP  v18.10-34-gcce845e
Vector Packet Processing
session_rules_table.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 <vnet/session/mma_16.h>
18 #include <vnet/session/mma_40.h>
21 #include <vnet/session/transport.h>
22 
23 u32
25 {
26  return ((ri << 1) | is_ip4);
27 }
28 
29 void
30 session_rule_tag_key_index_parse (u32 rti_key, u32 * ri, u8 * is_ip4)
31 {
32  *is_ip4 = rti_key & 1;
33  *ri = rti_key >> 1;
34 }
35 
36 u8 *
38 {
39  uword *tip;
41 
42  tip =
43  hash_get (srt->tags_by_rules, session_rule_tag_key_index (ri, is_ip4));
44  if (tip)
45  {
46  rt = pool_elt_at_index (srt->rule_tags, *tip);
47  return rt->tag;
48  }
49  return 0;
50 }
51 
52 void
54 {
55  uword *rip, *rtip;
57  u32 rti_key;
58 
59  if (tag == 0)
60  return;
61  rip = hash_get_mem (srt->rules_by_tag, tag);
62  if (!rip)
63  {
64  clib_warning ("tag has no rule associated");
65  return;
66  }
67  rti_key = session_rule_tag_key_index (*rip, is_ip4);
68  rtip = hash_get (srt->tags_by_rules, rti_key);
69  if (!rtip)
70  {
71  clib_warning ("rule has no tag associated");
72  return;
73  }
74  rt = pool_elt_at_index (srt->rule_tags, *rtip);
75  ASSERT (rt);
76  hash_unset_mem (srt->rules_by_tag, tag);
77  hash_unset (srt->tags_by_rules, rti_key);
78  pool_put (srt->rule_tags, rt);
79 }
80 
81 void
83  u32 rule_index, u8 is_ip4)
84 {
85  uword *rip;
87  u32 rti_key;
88 
89  if (tag == 0)
90  return;
91  rip = hash_get_mem (srt->rules_by_tag, tag);
92  if (rip)
93  session_rules_table_del_tag (srt, tag, is_ip4);
94  pool_get (srt->rule_tags, rt);
95  rt->tag = vec_dup (tag);
96  hash_set_mem (srt->rules_by_tag, rt->tag, rule_index);
97  rti_key = session_rule_tag_key_index (rule_index, is_ip4);
98  hash_set (srt->tags_by_rules, rti_key, rt - srt->rule_tags);
99 }
100 
101 u32
103 {
104  uword *rp;
105  if (tag == 0)
107  rp = hash_get_mem (srt->rules_by_tag, tag);
108  return (rp == 0 ? SESSION_RULES_TABLE_INVALID_INDEX : *rp);
109 }
110 
111 static void
113 {
114  if (pref->fp_proto == FIB_PROTOCOL_IP4)
115  ip4_address_normalize (&pref->fp_addr.ip4, pref->fp_len);
116  else
117  ip6_address_normalize (&pref->fp_addr.ip6, pref->fp_len);
118 }
119 
120 u8 *
121 format_session_rule4 (u8 * s, va_list * args)
122 {
123  session_rules_table_t *srt = va_arg (*args, session_rules_table_t *);
124  mma_rule_16_t *sr = va_arg (*args, mma_rule_16_t *);
125  session_mask_or_match_4_t *mask, *match;
126  mma_rules_table_16_t *srt4;
127  u8 *tag = 0, *null_tag = format (0, "none");
128  u32 ri;
129  int i;
130 
131  srt4 = &srt->session_rules_tables_16;
132  ri = mma_rules_table_rule_index_16 (srt4, sr);
133  tag = session_rules_table_rule_tag (srt, ri, 1);
134  match = (session_mask_or_match_4_t *) & sr->match;
135  mask = (session_mask_or_match_4_t *) & sr->mask;
136 
137  s = format (s, "[%d] rule: %U/%d %d %U/%d %d action: %d tag: %v", ri,
138  format_ip4_address, &match->lcl_ip,
139  ip4_mask_to_preflen (&mask->lcl_ip),
140  clib_net_to_host_u16 (match->lcl_port), format_ip4_address,
141  &match->rmt_ip, ip4_mask_to_preflen (&mask->rmt_ip),
142  clib_net_to_host_u16 (match->rmt_port), sr->action_index,
143  tag ? tag : null_tag);
144  if (vec_len (sr->next_indices))
145  {
146  s = format (s, "\n children: ");
147  for (i = 0; i < vec_len (sr->next_indices); i++)
148  s = format (s, "%d ", sr->next_indices[i]);
149  }
150  vec_free (null_tag);
151  return s;
152 }
153 
154 u8 *
155 format_session_rule6 (u8 * s, va_list * args)
156 {
157  session_rules_table_t *srt = va_arg (*args, session_rules_table_t *);
158  mma_rule_40_t *sr = va_arg (*args, mma_rule_40_t *);
159  session_mask_or_match_6_t *mask, *match;
160  mma_rules_table_40_t *srt6;
161  u8 *tag = 0, *null_tag = format (0, "none");
162  u32 ri;
163  int i;
164 
165  srt6 = &srt->session_rules_tables_40;
166  ri = mma_rules_table_rule_index_40 (srt6, sr);
167  tag = session_rules_table_rule_tag (srt, ri, 0);
168  match = (session_mask_or_match_6_t *) & sr->match;
169  mask = (session_mask_or_match_6_t *) & sr->mask;
170 
171  s = format (s, "[%d] rule: %U/%d %d %U/%d %d action: %d tag: %v", ri,
172  format_ip6_address, &match->lcl_ip,
173  ip6_mask_to_preflen (&mask->lcl_ip),
174  clib_net_to_host_u16 (match->lcl_port), format_ip6_address,
175  &match->rmt_ip, ip6_mask_to_preflen (&mask->rmt_ip),
176  clib_net_to_host_u16 (match->rmt_port), sr->action_index,
177  tag ? tag : null_tag);
178  if (vec_len (sr->next_indices))
179  {
180  s = format (s, "\n children: ");
181  for (i = 0; i < vec_len (sr->next_indices); i++)
182  s = format (s, "%d ", sr->next_indices[i]);
183  }
184  vec_free (null_tag);
185  return s;
186 }
187 
188 void *
190 {
191  if (fib_proto == FIB_PROTOCOL_IP4)
192  return &srt->session_rules_tables_16;
193  else if (fib_proto == FIB_PROTOCOL_IP6)
194  return &srt->session_rules_tables_40;
195  return 0;
196 }
197 
198 int
199 rule_cmp_16 (mma_rule_16_t * rule1, mma_rule_16_t * rule2)
200 {
201  session_mask_or_match_4_t *m1, *m2;
202 
203  m1 = (session_mask_or_match_4_t *) & rule1->max_match;
204  m2 = (session_mask_or_match_4_t *) & rule2->max_match;
205  if (m1->rmt_ip.as_u32 != m2->rmt_ip.as_u32)
206  return (m1->rmt_ip.as_u32 < m2->rmt_ip.as_u32 ? -1 : 1);
207  if (m1->lcl_ip.as_u32 != m2->lcl_ip.as_u32)
208  return (m1->lcl_ip.as_u32 < m2->lcl_ip.as_u32 ? -1 : 1);
209  if (m1->rmt_port != m2->rmt_port)
210  return (m1->rmt_port < m2->rmt_port ? -1 : 1);
211  if (m1->lcl_port != m2->lcl_port)
212  return (m1->lcl_port < m2->lcl_port ? -1 : 1);
213  return 0;
214 }
215 
216 int
217 rule_cmp_40 (mma_rule_40_t * rule1, mma_rule_40_t * rule2)
218 {
219  session_mask_or_match_6_t *r1, *r2;
220  r1 = (session_mask_or_match_6_t *) & rule1->max_match;
221  r2 = (session_mask_or_match_6_t *) & rule2->max_match;
222  if (r1->rmt_ip.as_u64[0] != r2->rmt_ip.as_u64[0])
223  return (r1->rmt_ip.as_u64[0] < r2->rmt_ip.as_u64[0] ? -1 : 1);
224  if (r1->rmt_ip.as_u64[1] != r2->rmt_ip.as_u64[1])
225  return (r1->rmt_ip.as_u64[1] < r2->rmt_ip.as_u64[1] ? -1 : 1);
226  if (r1->lcl_ip.as_u64[0] != r2->lcl_ip.as_u64[0])
227  return (r1->lcl_ip.as_u64[0] < r2->lcl_ip.as_u64[0] ? -1 : 1);
228  if (r1->lcl_ip.as_u64[1] != r2->lcl_ip.as_u64[1])
229  return (r1->lcl_ip.as_u64[1] < r2->lcl_ip.as_u64[1]) ? -1 : 1;
230  if (r1->rmt_port != r2->rmt_port)
231  return (r1->rmt_port < r2->rmt_port ? -1 : 1);
232  if (r1->lcl_port != r2->lcl_port)
233  return (r1->lcl_port < r2->lcl_port ? -1 : 1);
234  return 0;
235 }
236 
237 void
238 session_rules_table_init_rule_16 (mma_rule_16_t * rule,
239  fib_prefix_t * lcl, u16 lcl_port,
240  fib_prefix_t * rmt, u16 rmt_port)
241 {
242  session_mask_or_match_4_t *match, *mask, *max_match;
243  fib_pref_normalize (lcl);
244  fib_pref_normalize (rmt);
245  match = (session_mask_or_match_4_t *) & rule->match;
246  match->lcl_ip.as_u32 = lcl->fp_addr.ip4.as_u32;
247  match->rmt_ip.as_u32 = rmt->fp_addr.ip4.as_u32;
248  match->lcl_port = lcl_port;
249  match->rmt_port = rmt_port;
250  mask = (session_mask_or_match_4_t *) & rule->mask;
251  ip4_preflen_to_mask (lcl->fp_len, &mask->lcl_ip);
252  ip4_preflen_to_mask (rmt->fp_len, &mask->rmt_ip);
253  mask->lcl_port = lcl_port == 0 ? 0 : (u16) ~ 0;
254  mask->rmt_port = rmt_port == 0 ? 0 : (u16) ~ 0;
255  max_match = (session_mask_or_match_4_t *) & rule->max_match;
257  &max_match->rmt_ip);
259  &max_match->lcl_ip);
260  max_match->lcl_port = lcl_port == 0 ? (u16) ~ 0 : lcl_port;
261  max_match->rmt_port = rmt_port == 0 ? (u16) ~ 0 : rmt_port;
262 }
263 
264 void
265 session_rules_table_init_rule_40 (mma_rule_40_t * rule,
266  fib_prefix_t * lcl, u16 lcl_port,
267  fib_prefix_t * rmt, u16 rmt_port)
268 {
269  session_mask_or_match_6_t *match, *mask, *max_match;
270  fib_pref_normalize (lcl);
271  fib_pref_normalize (rmt);
272  match = (session_mask_or_match_6_t *) & rule->match;
273  clib_memcpy (&match->lcl_ip, &lcl->fp_addr.ip6, sizeof (match->lcl_ip));
274  clib_memcpy (&match->rmt_ip, &rmt->fp_addr.ip6, sizeof (match->rmt_ip));
275  match->lcl_port = lcl_port;
276  match->rmt_port = rmt_port;
277  mask = (session_mask_or_match_6_t *) & rule->mask;
278  ip6_preflen_to_mask (lcl->fp_len, &mask->lcl_ip);
279  ip6_preflen_to_mask (rmt->fp_len, &mask->rmt_ip);
280  mask->lcl_port = lcl_port == 0 ? 0 : (u16) ~ 0;
281  mask->rmt_port = rmt_port == 0 ? 0 : (u16) ~ 0;
282  max_match = (session_mask_or_match_6_t *) & rule->max_match;
284  &max_match->rmt_ip);
286  &max_match->lcl_ip);
287  max_match->lcl_port = lcl_port == 0 ? (u16) ~ 0 : lcl_port;
288  max_match->rmt_port = rmt_port == 0 ? (u16) ~ 0 : rmt_port;
289 }
290 
291 mma_rule_16_t *
292 session_rules_table_alloc_rule_16 (mma_rules_table_16_t * srt,
293  fib_prefix_t * lcl, u16 lcl_port,
294  fib_prefix_t * rmt, u16 rmt_port)
295 {
296  mma_rule_16_t *rule = 0;
297  rule = mma_rules_table_rule_alloc_16 (srt);
298  session_rules_table_init_rule_16 (rule, lcl, lcl_port, rmt, rmt_port);
299  return rule;
300 }
301 
302 mma_rule_40_t *
303 session_rules_table_alloc_rule_40 (mma_rules_table_40_t * srt,
304  fib_prefix_t * lcl, u16 lcl_port,
305  fib_prefix_t * rmt, u16 rmt_port)
306 {
307  mma_rule_40_t *rule;
308  rule = mma_rules_table_rule_alloc_40 (srt);
309  session_rules_table_init_rule_40 (rule, lcl, lcl_port, rmt, rmt_port);
310  return rule;
311 }
312 
313 u32
315  ip4_address_t * lcl_ip,
316  ip4_address_t * rmt_ip, u16 lcl_port,
317  u16 rmt_port)
318 {
319  mma_rules_table_16_t *srt4 = &srt->session_rules_tables_16;
320  session_mask_or_match_4_t key = {
321  .lcl_ip.as_u32 = lcl_ip->as_u32,
322  .rmt_ip.as_u32 = rmt_ip->as_u32,
323  .lcl_port = lcl_port,
324  .rmt_port = rmt_port,
325  };
326  return mma_rules_table_lookup_rule_16 (srt4,
327  (mma_mask_or_match_16_t *) & key,
328  srt4->root_index);
329 }
330 
331 u32
333  ip4_address_t * lcl_ip, ip4_address_t * rmt_ip,
334  u16 lcl_port, u16 rmt_port)
335 {
336  mma_rules_table_16_t *srt4 = &srt->session_rules_tables_16;
337  session_mask_or_match_4_t key = {
338  .lcl_ip.as_u32 = lcl_ip->as_u32,
339  .rmt_ip.as_u32 = rmt_ip->as_u32,
340  .lcl_port = lcl_port,
341  .rmt_port = rmt_port,
342  };
343  return mma_rules_table_lookup_16 (srt4, (mma_mask_or_match_16_t *) & key,
344  srt4->root_index);
345 }
346 
347 u32
349  ip6_address_t * lcl_ip,
350  ip6_address_t * rmt_ip, u16 lcl_port,
351  u16 rmt_port)
352 {
353  mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40;
354  session_mask_or_match_6_t key = {
355  .lcl_port = lcl_port,
356  .rmt_port = rmt_port,
357  };
358  clib_memcpy (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip));
359  clib_memcpy (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip));
360  return mma_rules_table_lookup_rule_40 (srt6,
361  (mma_mask_or_match_40_t *) & key,
362  srt6->root_index);
363 }
364 
365 u32
367  ip6_address_t * lcl_ip, ip6_address_t * rmt_ip,
368  u16 lcl_port, u16 rmt_port)
369 {
370  mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40;
371  session_mask_or_match_6_t key = {
372  .lcl_port = lcl_port,
373  .rmt_port = rmt_port,
374  };
375  clib_memcpy (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip));
376  clib_memcpy (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip));
377  return mma_rules_table_lookup_40 (srt6, (mma_mask_or_match_40_t *) & key,
378  srt6->root_index);
379 }
380 
381 /**
382  * Add/delete session rule
383  *
384  * @param srt table where rule should be added
385  * @param args rule arguments
386  *
387  * @return 0 if success, clib_error_t error otherwise
388  */
389 clib_error_t *
392 {
393  u8 fib_proto = args->rmt.fp_proto, *rt;
394  u32 ri_from_tag, ri;
395  int rv;
396 
397  ri_from_tag = session_rules_table_rule_for_tag (srt, args->tag);
398  if (args->is_add && ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
399  return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
400  "tag exists");
401 
402  if (fib_proto == FIB_PROTOCOL_IP4)
403  {
404  mma_rules_table_16_t *srt4;
405  srt4 = &srt->session_rules_tables_16;
406  if (args->is_add)
407  {
408  mma_rule_16_t *rule4;
409  rule4 = session_rules_table_alloc_rule_16 (srt4, &args->lcl,
410  args->lcl_port,
411  &args->rmt,
412  args->rmt_port);
413  rule4->action_index = args->action_index;
414  rv = mma_rules_table_add_rule_16 (srt4, rule4);
415  if (!rv)
416  {
417  ri = mma_rules_table_rule_index_16 (srt4, rule4);
418  session_rules_table_add_tag (srt, args->tag, ri, 1);
419  }
420  else
421  {
423  &args->lcl.fp_addr.ip4,
424  &args->rmt.fp_addr.ip4,
425  args->lcl_port,
426  args->rmt_port);
428  {
429  rt = session_rules_table_rule_tag (srt, ri, 1);
430  session_rules_table_del_tag (srt, rt, 1);
431  session_rules_table_add_tag (srt, args->tag, ri, 1);
432  }
433  }
434  }
435  else
436  {
437  mma_rule_16_t *rule;
438  if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
439  {
440  rule = mma_rules_table_get_rule_16 (srt4, ri_from_tag);
441  mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index);
442  session_rules_table_del_tag (srt, args->tag, 1);
443  }
444  else
445  {
446  mma_rule_16_t _rule;
447  rule = &_rule;
448  memset (rule, 0, sizeof (*rule));
449  session_rules_table_init_rule_16 (rule, &args->lcl,
450  args->lcl_port, &args->rmt,
451  args->rmt_port);
452  mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index);
453  }
454  }
455  }
456  else if (fib_proto == FIB_PROTOCOL_IP6)
457  {
458  mma_rules_table_40_t *srt6;
459  mma_rule_40_t *rule6;
460  srt6 = &srt->session_rules_tables_40;
461  if (args->is_add)
462  {
463  rule6 = session_rules_table_alloc_rule_40 (srt6, &args->lcl,
464  args->lcl_port,
465  &args->rmt,
466  args->rmt_port);
467  rule6->action_index = args->action_index;
468  rv = mma_rules_table_add_rule_40 (srt6, rule6);
469  if (!rv)
470  {
471  ri = mma_rules_table_rule_index_40 (srt6, rule6);
472  session_rules_table_add_tag (srt, args->tag, ri, 0);
473  }
474  else
475  {
477  &args->lcl.fp_addr.ip6,
478  &args->rmt.fp_addr.ip6,
479  args->lcl_port,
480  args->rmt_port);
482  {
483  rt = session_rules_table_rule_tag (srt, ri, 0);
484  session_rules_table_del_tag (srt, rt, 1);
485  session_rules_table_add_tag (srt, args->tag, ri, 0);
486  }
487  }
488  }
489  else
490  {
491  mma_rule_40_t *rule;
492  if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
493  {
494  rule = mma_rules_table_get_rule_40 (srt6, ri_from_tag);
495  mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index);
496  session_rules_table_del_tag (srt, args->tag, 0);
497  }
498  else
499  {
500  mma_rule_40_t _rule;
501  rule = &_rule;
502  memset (rule, 0, sizeof (*rule));
503  session_rules_table_init_rule_40 (rule, &args->lcl,
504  args->lcl_port, &args->rmt,
505  args->rmt_port);
506  mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index);
507  }
508  }
509  }
510  else
511  return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE_2, 0,
512  "invalid fib proto");
513  return 0;
514 }
515 
516 void
518 {
519  mma_rules_table_16_t *srt4;
520  mma_rules_table_40_t *srt6;
521  mma_rule_16_t *rule4;
522  mma_rule_40_t *rule6;
523  fib_prefix_t null_prefix;
524 
525  memset (&null_prefix, 0, sizeof (null_prefix));
526 
527  srt4 = &srt->session_rules_tables_16;
528  rule4 = session_rules_table_alloc_rule_16 (srt4, &null_prefix, 0,
529  &null_prefix, 0);
530  rule4->action_index = SESSION_RULES_TABLE_INVALID_INDEX;
531  srt4->root_index = mma_rules_table_rule_index_16 (srt4, rule4);
532  srt4->rule_cmp_fn = rule_cmp_16;
533 
534  srt6 = &srt->session_rules_tables_40;
535  rule6 = session_rules_table_alloc_rule_40 (srt6, &null_prefix, 0,
536  &null_prefix, 0);
537  rule6->action_index = SESSION_RULES_TABLE_INVALID_INDEX;
538  srt6->root_index = mma_rules_table_rule_index_40 (srt6, rule6);
539  srt6->rule_cmp_fn = rule_cmp_40;
540 
541  srt->rules_by_tag = hash_create_vec (0, sizeof (u8), sizeof (uword));
542  srt->tags_by_rules = hash_create (0, sizeof (uword));
543 }
544 
545 void
547  ip46_address_t * lcl_ip, u16 lcl_port,
548  ip46_address_t * rmt_ip, u16 rmt_port,
549  u8 is_ip4)
550 {
551  mma_rules_table_16_t *srt4;
552  mma_rules_table_40_t *srt6;
553  mma_rule_16_t *sr4;
554  mma_rule_40_t *sr6;
555  u32 ri;
556 
557  if (is_ip4)
558  {
560  session_mask_or_match_4_t key = {
561  .lcl_ip.as_u32 = lcl_ip->ip4.as_u32,
562  .rmt_ip.as_u32 = rmt_ip->ip4.as_u32,
563  .lcl_port = lcl_port,
564  .rmt_port = rmt_port,
565  };
566  ri =
567  mma_rules_table_lookup_rule_16 (srt4,
568  (mma_mask_or_match_16_t *) & key,
569  srt4->root_index);
570  sr4 = mma_rules_table_get_rule_16 (srt4, ri);
571  vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4);
572  }
573  else
574  {
576  session_mask_or_match_6_t key = {
577  .lcl_port = lcl_port,
578  .rmt_port = rmt_port,
579  };
580  clib_memcpy (&key.lcl_ip, &lcl_ip->ip6, sizeof (lcl_ip->ip6));
581  clib_memcpy (&key.rmt_ip, &rmt_ip->ip6, sizeof (rmt_ip->ip6));
582  ri = mma_rules_table_lookup_rule_40 (srt6,
583  (mma_mask_or_match_40_t *) & key,
584  srt6->root_index);
585  sr6 = mma_rules_table_get_rule_40 (srt6, ri);
586  vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6);
587  }
588 }
589 
590 void
592  u8 fib_proto)
593 {
594  if (fib_proto == FIB_PROTOCOL_IP4)
595  {
596  mma_rules_table_16_t *srt4;
597  mma_rule_16_t *sr4;
598  srt4 = &srt->session_rules_tables_16;
599  vlib_cli_output (vm, "IP4 rules");
600 
601  /* *INDENT-OFF* */
602  pool_foreach(sr4, srt4->rules, ({
603  vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4);
604  }));
605  /* *INDENT-ON* */
606 
607  }
608  else if (fib_proto == FIB_PROTOCOL_IP6)
609  {
610  mma_rules_table_40_t *srt6;
611  mma_rule_40_t *sr6;
612  srt6 = &srt->session_rules_tables_40;
613  vlib_cli_output (vm, "IP6 rules");
614 
615  /* *INDENT-OFF* */
616  pool_foreach(sr6, srt6->rules, ({
617  vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6);
618  }));
619  /* *INDENT-ON* */
620 
621  }
622 }
623 
624 /*
625  * fd.io coding-style-patch-verification: ON
626  *
627  * Local Variables:
628  * eval: (c-set-style "gnu")
629  * End:
630  */
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
void session_rules_table_add_tag(session_rules_table_t *srt, u8 *tag, u32 rule_index, u8 is_ip4)
mma_rule_40_t * session_rules_table_alloc_rule_40(mma_rules_table_40_t *srt, fib_prefix_t *lcl, u16 lcl_port, fib_prefix_t *rmt, u16 rmt_port)
void session_rules_table_init(session_rules_table_t *srt)
void ip6_preflen_to_mask(u8 pref_len, ip6_address_t *mask)
Definition: ip.c:222
#define hash_set(h, key, value)
Definition: hash.h:255
void ip4_preflen_to_mask(u8 pref_len, ip4_address_t *ip)
Definition: ip.c:196
void session_rules_table_cli_dump(vlib_main_t *vm, session_rules_table_t *srt, u8 fib_proto)
#define hash_unset(h, key)
Definition: hash.h:261
struct _session_rules_table_t session_rules_table_t
clib_error_t * session_rules_table_add_del(session_rules_table_t *srt, session_rule_table_add_del_args_t *args)
Add/delete session rule.
int rule_cmp_16(mma_rule_16_t *rule1, mma_rule_16_t *rule2)
u8 * session_rules_table_rule_tag(session_rules_table_t *srt, u32 ri, u8 is_ip4)
static void fib_pref_normalize(fib_prefix_t *pref)
int i
#define hash_set_mem(h, key, value)
Definition: hash.h:275
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
u32 session_rules_table_lookup4(session_rules_table_t *srt, ip4_address_t *lcl_ip, ip4_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
mma_rule_16_t * session_rules_table_alloc_rule_16(mma_rules_table_16_t *srt, fib_prefix_t *lcl, u16 lcl_port, fib_prefix_t *rmt, u16 rmt_port)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
unsigned char u8
Definition: types.h:56
u32 session_rules_table_rule_for_tag(session_rules_table_t *srt, u8 *tag)
format_function_t format_ip4_address
Definition: format.h:75
memset(h->entries, 0, sizeof(h->entries[0])*entries)
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:443
void * session_rules_table_get(session_rules_table_t *srt, u8 fib_proto)
void ip6_prefix_max_address_host_order(ip6_address_t *ip, u8 plen, ip6_address_t *res)
Definition: ip.c:243
void ip4_address_normalize(ip4_address_t *ip4, u8 preflen)
Definition: ip.c:166
Aggregrate type for a prefix.
Definition: fib_types.h:203
void session_rules_table_init_rule_16(mma_rule_16_t *rule, fib_prefix_t *lcl, u16 lcl_port, fib_prefix_t *rmt, u16 rmt_port)
unsigned int u32
Definition: types.h:88
u16 fp_len
The mask length.
Definition: fib_types.h:207
#define hash_get(h, key)
Definition: hash.h:249
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
#define hash_unset_mem(h, key)
Definition: hash.h:291
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
struct _rule_tag session_rule_tag_t
unsigned short u16
Definition: types.h:57
void ip6_address_normalize(ip6_address_t *ip6, u8 preflen)
Definition: ip.c:176
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:373
u32 session_rules_table_lookup_rule4(session_rules_table_t *srt, ip4_address_t *lcl_ip, ip4_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
int rule_cmp_40(mma_rule_40_t *rule1, mma_rule_40_t *rule2)
u32 ip6_mask_to_preflen(ip6_address_t *mask)
Definition: ip.c:266
u32 session_rules_table_lookup6(session_rules_table_t *srt, ip6_address_t *lcl_ip, ip6_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
void session_rule_tag_key_index_parse(u32 rti_key, u32 *ri, u8 *is_ip4)
u8 * format_session_rule6(u8 *s, va_list *args)
format_function_t format_ip6_address
Definition: format.h:93
vlib_main_t * vm
Definition: buffer.c:294
#define SESSION_RULES_TABLE_INVALID_INDEX
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
#define clib_warning(format, args...)
Definition: error.h:59
#define clib_memcpy(a, b, c)
Definition: string.h:75
u32 ip4_mask_to_preflen(ip4_address_t *mask)
Definition: ip.c:205
u8 * format_session_rule4(u8 *s, va_list *args)
#define hash_create(elts, value_bytes)
Definition: hash.h:696
u32 session_rule_tag_key_index(u32 ri, u8 is_ip4)
#define ASSERT(truth)
u32 session_rules_table_lookup_rule6(session_rules_table_t *srt, ip6_address_t *lcl_ip, ip6_address_t *rmt_ip, u16 lcl_port, u16 rmt_port)
void session_rules_table_show_rule(vlib_main_t *vm, session_rules_table_t *srt, ip46_address_t *lcl_ip, u16 lcl_port, ip46_address_t *rmt_ip, u16 rmt_port, u8 is_ip4)
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:668
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u64 uword
Definition: types.h:112
void ip4_prefix_max_address_host_order(ip4_address_t *ip, u8 plen, ip4_address_t *res)
Definition: ip.c:213
#define hash_get_mem(h, key)
Definition: hash.h:269
struct _session_rules_table_add_del_args session_rule_table_add_del_args_t
#define clib_error_return_code(e, code, flags, args...)
Definition: error.h:93
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:725
void session_rules_table_init_rule_40(mma_rule_40_t *rule, fib_prefix_t *lcl, u16 lcl_port, fib_prefix_t *rmt, u16 rmt_port)
void session_rules_table_del_tag(session_rules_table_t *srt, u8 *tag, u8 is_ip4)