FD.io VPP  v19.01.3-6-g70449b9b9
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_fast (&match->lcl_ip, &lcl->fp_addr.ip6,
274  sizeof (match->lcl_ip));
275  clib_memcpy_fast (&match->rmt_ip, &rmt->fp_addr.ip6,
276  sizeof (match->rmt_ip));
277  match->lcl_port = lcl_port;
278  match->rmt_port = rmt_port;
279  mask = (session_mask_or_match_6_t *) & rule->mask;
280  ip6_preflen_to_mask (lcl->fp_len, &mask->lcl_ip);
281  ip6_preflen_to_mask (rmt->fp_len, &mask->rmt_ip);
282  mask->lcl_port = lcl_port == 0 ? 0 : (u16) ~ 0;
283  mask->rmt_port = rmt_port == 0 ? 0 : (u16) ~ 0;
284  max_match = (session_mask_or_match_6_t *) & rule->max_match;
286  &max_match->rmt_ip);
288  &max_match->lcl_ip);
289  max_match->lcl_port = lcl_port == 0 ? (u16) ~ 0 : lcl_port;
290  max_match->rmt_port = rmt_port == 0 ? (u16) ~ 0 : rmt_port;
291 }
292 
293 mma_rule_16_t *
294 session_rules_table_alloc_rule_16 (mma_rules_table_16_t * srt,
295  fib_prefix_t * lcl, u16 lcl_port,
296  fib_prefix_t * rmt, u16 rmt_port)
297 {
298  mma_rule_16_t *rule = 0;
299  rule = mma_rules_table_rule_alloc_16 (srt);
300  session_rules_table_init_rule_16 (rule, lcl, lcl_port, rmt, rmt_port);
301  return rule;
302 }
303 
304 mma_rule_40_t *
305 session_rules_table_alloc_rule_40 (mma_rules_table_40_t * srt,
306  fib_prefix_t * lcl, u16 lcl_port,
307  fib_prefix_t * rmt, u16 rmt_port)
308 {
309  mma_rule_40_t *rule;
310  rule = mma_rules_table_rule_alloc_40 (srt);
311  session_rules_table_init_rule_40 (rule, lcl, lcl_port, rmt, rmt_port);
312  return rule;
313 }
314 
315 u32
317  ip4_address_t * lcl_ip,
318  ip4_address_t * rmt_ip, u16 lcl_port,
319  u16 rmt_port)
320 {
321  mma_rules_table_16_t *srt4 = &srt->session_rules_tables_16;
322  session_mask_or_match_4_t key = {
323  .lcl_ip.as_u32 = lcl_ip->as_u32,
324  .rmt_ip.as_u32 = rmt_ip->as_u32,
325  .lcl_port = lcl_port,
326  .rmt_port = rmt_port,
327  };
328  return mma_rules_table_lookup_rule_16 (srt4,
329  (mma_mask_or_match_16_t *) & key,
330  srt4->root_index);
331 }
332 
333 u32
335  ip4_address_t * lcl_ip, ip4_address_t * rmt_ip,
336  u16 lcl_port, u16 rmt_port)
337 {
338  mma_rules_table_16_t *srt4 = &srt->session_rules_tables_16;
339  session_mask_or_match_4_t key = {
340  .lcl_ip.as_u32 = lcl_ip->as_u32,
341  .rmt_ip.as_u32 = rmt_ip->as_u32,
342  .lcl_port = lcl_port,
343  .rmt_port = rmt_port,
344  };
345  return mma_rules_table_lookup_16 (srt4, (mma_mask_or_match_16_t *) & key,
346  srt4->root_index);
347 }
348 
349 u32
351  ip6_address_t * lcl_ip,
352  ip6_address_t * rmt_ip, u16 lcl_port,
353  u16 rmt_port)
354 {
355  mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40;
356  session_mask_or_match_6_t key = {
357  .lcl_port = lcl_port,
358  .rmt_port = rmt_port,
359  };
360  clib_memcpy_fast (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip));
361  clib_memcpy_fast (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip));
362  return mma_rules_table_lookup_rule_40 (srt6,
363  (mma_mask_or_match_40_t *) & key,
364  srt6->root_index);
365 }
366 
367 u32
369  ip6_address_t * lcl_ip, ip6_address_t * rmt_ip,
370  u16 lcl_port, u16 rmt_port)
371 {
372  mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40;
373  session_mask_or_match_6_t key = {
374  .lcl_port = lcl_port,
375  .rmt_port = rmt_port,
376  };
377  clib_memcpy_fast (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip));
378  clib_memcpy_fast (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip));
379  return mma_rules_table_lookup_40 (srt6, (mma_mask_or_match_40_t *) & key,
380  srt6->root_index);
381 }
382 
383 /**
384  * Add/delete session rule
385  *
386  * @param srt table where rule should be added
387  * @param args rule arguments
388  *
389  * @return 0 if success, clib_error_t error otherwise
390  */
391 clib_error_t *
394 {
395  u8 fib_proto = args->rmt.fp_proto, *rt;
396  u32 ri_from_tag, ri;
397  int rv;
398 
399  ri_from_tag = session_rules_table_rule_for_tag (srt, args->tag);
400  if (args->is_add && ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
401  return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
402  "tag exists");
403 
404  if (fib_proto == FIB_PROTOCOL_IP4)
405  {
406  mma_rules_table_16_t *srt4;
407  srt4 = &srt->session_rules_tables_16;
408  if (args->is_add)
409  {
410  mma_rule_16_t *rule4;
411  rule4 = session_rules_table_alloc_rule_16 (srt4, &args->lcl,
412  args->lcl_port,
413  &args->rmt,
414  args->rmt_port);
415  rule4->action_index = args->action_index;
416  rv = mma_rules_table_add_rule_16 (srt4, rule4);
417  if (!rv)
418  {
419  ri = mma_rules_table_rule_index_16 (srt4, rule4);
420  session_rules_table_add_tag (srt, args->tag, ri, 1);
421  }
422  else
423  {
425  &args->lcl.fp_addr.ip4,
426  &args->rmt.fp_addr.ip4,
427  args->lcl_port,
428  args->rmt_port);
430  {
431  rt = session_rules_table_rule_tag (srt, ri, 1);
432  session_rules_table_del_tag (srt, rt, 1);
433  session_rules_table_add_tag (srt, args->tag, ri, 1);
434  }
435  }
436  }
437  else
438  {
439  mma_rule_16_t *rule;
440  if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
441  {
442  rule = mma_rules_table_get_rule_16 (srt4, ri_from_tag);
443  mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index);
444  session_rules_table_del_tag (srt, args->tag, 1);
445  }
446  else
447  {
448  mma_rule_16_t _rule;
449  rule = &_rule;
450  clib_memset (rule, 0, sizeof (*rule));
451  session_rules_table_init_rule_16 (rule, &args->lcl,
452  args->lcl_port, &args->rmt,
453  args->rmt_port);
454  mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index);
455  }
456  }
457  }
458  else if (fib_proto == FIB_PROTOCOL_IP6)
459  {
460  mma_rules_table_40_t *srt6;
461  mma_rule_40_t *rule6;
462  srt6 = &srt->session_rules_tables_40;
463  if (args->is_add)
464  {
465  rule6 = session_rules_table_alloc_rule_40 (srt6, &args->lcl,
466  args->lcl_port,
467  &args->rmt,
468  args->rmt_port);
469  rule6->action_index = args->action_index;
470  rv = mma_rules_table_add_rule_40 (srt6, rule6);
471  if (!rv)
472  {
473  ri = mma_rules_table_rule_index_40 (srt6, rule6);
474  session_rules_table_add_tag (srt, args->tag, ri, 0);
475  }
476  else
477  {
479  &args->lcl.fp_addr.ip6,
480  &args->rmt.fp_addr.ip6,
481  args->lcl_port,
482  args->rmt_port);
484  {
485  rt = session_rules_table_rule_tag (srt, ri, 0);
486  session_rules_table_del_tag (srt, rt, 1);
487  session_rules_table_add_tag (srt, args->tag, ri, 0);
488  }
489  }
490  }
491  else
492  {
493  mma_rule_40_t *rule;
494  if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX)
495  {
496  rule = mma_rules_table_get_rule_40 (srt6, ri_from_tag);
497  mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index);
498  session_rules_table_del_tag (srt, args->tag, 0);
499  }
500  else
501  {
502  mma_rule_40_t _rule;
503  rule = &_rule;
504  clib_memset (rule, 0, sizeof (*rule));
505  session_rules_table_init_rule_40 (rule, &args->lcl,
506  args->lcl_port, &args->rmt,
507  args->rmt_port);
508  mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index);
509  }
510  }
511  }
512  else
513  return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE_2, 0,
514  "invalid fib proto");
515  return 0;
516 }
517 
518 void
520 {
521  mma_rules_table_16_t *srt4;
522  mma_rules_table_40_t *srt6;
523  mma_rule_16_t *rule4;
524  mma_rule_40_t *rule6;
525  fib_prefix_t null_prefix;
526 
527  clib_memset (&null_prefix, 0, sizeof (null_prefix));
528 
529  srt4 = &srt->session_rules_tables_16;
530  rule4 = session_rules_table_alloc_rule_16 (srt4, &null_prefix, 0,
531  &null_prefix, 0);
532  rule4->action_index = SESSION_RULES_TABLE_INVALID_INDEX;
533  srt4->root_index = mma_rules_table_rule_index_16 (srt4, rule4);
534  srt4->rule_cmp_fn = rule_cmp_16;
535 
536  srt6 = &srt->session_rules_tables_40;
537  rule6 = session_rules_table_alloc_rule_40 (srt6, &null_prefix, 0,
538  &null_prefix, 0);
539  rule6->action_index = SESSION_RULES_TABLE_INVALID_INDEX;
540  srt6->root_index = mma_rules_table_rule_index_40 (srt6, rule6);
541  srt6->rule_cmp_fn = rule_cmp_40;
542 
543  srt->rules_by_tag = hash_create_vec (0, sizeof (u8), sizeof (uword));
544  srt->tags_by_rules = hash_create (0, sizeof (uword));
545 }
546 
547 void
549  ip46_address_t * lcl_ip, u16 lcl_port,
550  ip46_address_t * rmt_ip, u16 rmt_port,
551  u8 is_ip4)
552 {
553  mma_rules_table_16_t *srt4;
554  mma_rules_table_40_t *srt6;
555  mma_rule_16_t *sr4;
556  mma_rule_40_t *sr6;
557  u32 ri;
558 
559  if (is_ip4)
560  {
562  session_mask_or_match_4_t key = {
563  .lcl_ip.as_u32 = lcl_ip->ip4.as_u32,
564  .rmt_ip.as_u32 = rmt_ip->ip4.as_u32,
565  .lcl_port = lcl_port,
566  .rmt_port = rmt_port,
567  };
568  ri =
569  mma_rules_table_lookup_rule_16 (srt4,
570  (mma_mask_or_match_16_t *) & key,
571  srt4->root_index);
572  sr4 = mma_rules_table_get_rule_16 (srt4, ri);
573  vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4);
574  }
575  else
576  {
578  session_mask_or_match_6_t key = {
579  .lcl_port = lcl_port,
580  .rmt_port = rmt_port,
581  };
582  clib_memcpy_fast (&key.lcl_ip, &lcl_ip->ip6, sizeof (lcl_ip->ip6));
583  clib_memcpy_fast (&key.rmt_ip, &rmt_ip->ip6, sizeof (rmt_ip->ip6));
584  ri = mma_rules_table_lookup_rule_40 (srt6,
585  (mma_mask_or_match_40_t *) & key,
586  srt6->root_index);
587  sr6 = mma_rules_table_get_rule_40 (srt6, ri);
588  vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6);
589  }
590 }
591 
592 void
594  u8 fib_proto)
595 {
596  if (fib_proto == FIB_PROTOCOL_IP4)
597  {
598  mma_rules_table_16_t *srt4;
599  mma_rule_16_t *sr4;
600  srt4 = &srt->session_rules_tables_16;
601  vlib_cli_output (vm, "IP4 rules");
602 
603  /* *INDENT-OFF* */
604  pool_foreach(sr4, srt4->rules, ({
605  vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4);
606  }));
607  /* *INDENT-ON* */
608 
609  }
610  else if (fib_proto == FIB_PROTOCOL_IP6)
611  {
612  mma_rules_table_40_t *srt6;
613  mma_rule_40_t *sr6;
614  srt6 = &srt->session_rules_tables_40;
615  vlib_cli_output (vm, "IP6 rules");
616 
617  /* *INDENT-OFF* */
618  pool_foreach(sr6, srt6->rules, ({
619  vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6);
620  }));
621  /* *INDENT-ON* */
622 
623  }
624 }
625 
626 /*
627  * fd.io coding-style-patch-verification: ON
628  *
629  * Local Variables:
630  * eval: (c-set-style "gnu")
631  * End:
632  */
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:223
#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:197
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)
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
u8 * session_rules_table_rule_tag(session_rules_table_t *srt, u32 ri, u8 is_ip4)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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:236
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
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:490
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:244
void ip4_address_normalize(ip4_address_t *ip4, u8 preflen)
Definition: ip.c:167
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:511
#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:177
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:375
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:267
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:301
#define SESSION_RULES_TABLE_INVALID_INDEX
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
#define clib_warning(format, args...)
Definition: error.h:59
u32 ip4_mask_to_preflen(ip4_address_t *mask)
Definition: ip.c:206
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:214
#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:762
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)