summaryrefslogtreecommitdiffstats
path: root/src/vnet/gre
AgeCommit message (Expand)AuthorFilesLines
2022-07-06gre: fix returning the flags in the APIIvan Shvedunov1-0/+1
2022-01-18vnet: distinguish between max_frame_size and MTUDamjan Marion1-4/+4
2022-01-11misc: fix the uninitialization errorMohsin Kazmi1-1/+1
2022-01-07ethernet: new interface registration functionDamjan Marion1-9/+7
2021-11-19fib: Don't use [midchain] adjacencies to change an interface's feature arcNeale Ranns2-4/+8
2021-10-18api: remove legacy pd msg handlersKlement Sekera1-1/+0
2021-09-13interface: fix init fib_index_by_sw_if_indexNathan Skrzypczak1-4/+0
2021-07-28gre: set proper fib index for unnumbered interfaces, unset fib index before f...Stanislav Zaikin1-0/+5
2021-05-20gre: Walk IPv6 adjacencies during restackMatthew Smith1-2/+4
2021-05-13tests: move test source to vpp/testDave Wallace1-1296/+0
2021-04-27gre: Remove the debugging logging from the mGRE testsNeale Ranns1-6/+1
2021-03-21gre: Multipoint GRE fixesNeale Ranns2-3/+79
2021-02-15ip: Path MTUNeale Ranns1-2/+7
2021-02-15fib: Always honour flow hash flagNeale Ranns1-8/+17
2021-02-11tests: tag the tests that do not work with multi-worker configurationAndrew Yourtchenko1-0/+2
2021-02-08tunnel: support copying TTL and flow label from inner to outerNeale Ranns1-1/+1
2020-12-14misc: move to new pool_foreach macrosDamjan Marion2-6/+6
2020-12-09fib: supporting inner flow hash on tunnelsMohammed Hawari2-3/+13
2020-12-08tunnel: add cli support for encap_decap flagsMohammed Hawari1-0/+7
2020-11-26gre: Move to new API generated types/messagesNeale Ranns2-66/+31
2020-11-17tests: move gre tests to src/vnet/gre/testDave Wallace1-0/+1275
2020-10-21ipsec: support for multipoint on ipsec interfacesNeale Ranns1-1/+1
2020-10-19ip: Move the IP6 fib into ip6_[m]fib.cNeale Ranns1-6/+4
2020-10-08gre: MPLS over GRE does not select correct fixup functionNeale Ranns1-2/+2
2020-10-07misc: Purge unused pg includesNeale Ranns2-2/+0
2020-09-22ipip: Add option to tunnel create help stringNeale Ranns1-1/+2
2020-09-17teib: Use ip_address_t not ip46_address_tNeale Ranns2-8/+10
2020-09-17teib: Add adj-fibs for peers/adjacencies on p2mp interfaceNeale Ranns1-1/+2
2020-07-16gre: fix outer ip6 lengthAloys Augustin1-5/+5
2020-04-22gre: Optimise encap node for tunnel typesNeale Ranns3-9/+45
2020-02-04teib: Rename NHRP to TEIBNeale Ranns3-32/+32
2020-02-03gre: improve .api descriptionsVratko Polak1-8/+28
2020-02-03gre: add missing .api editsVratko Polak1-2/+2
2020-01-30gre: Tunnel encap/decap flagsNeale Ranns5-17/+123
2020-01-27ipip: Multi-point interfaceNeale Ranns3-15/+80
2020-01-27tunnel: Common types for IP tunnelsNeale Ranns5-98/+28
2020-01-10docs: Edit FEATURE.yaml files so they can be publishedJohn DeNisco1-1/+1
2020-01-06gre: fix feature.yaml errorOle Troan1-2/+2
2020-01-06gre: Add FEATURE.yamlNeale Ranns1-0/+13
2019-12-19gre: multipoint ingress lookup fixNeale Ranns3-59/+176
2019-12-10api: multiple connections per processDave Barach1-1/+1
2019-12-04gre: Multi-point interfacesNeale Ranns5-119/+239
2019-12-03fib: constify the adjacency in the rewrite nodesNeale Ranns1-2/+2
2019-06-18ipsec: ipsec-tun protectNeale Ranns1-0/+24
2019-06-07gre: update gre.api with explicit typesOle Troan1-6/+5
2019-05-28gre: don't register gre input nodes unless a gre tunnel is createdJakub Grajciar2-3/+4
2019-04-22GRE: set gre_tunnel_type init value to zero in APIAlexander Chernavin1-1/+1
2019-04-18GRE: API updateNeale Ranns4-88/+136
2019-04-08fixing typosJim Thompson1-1/+1
2019-03-26ADJ: midchain delegate to performing stackingNeale Ranns2-94/+7
f"><vnet/session/session_rules_table.h> #include <vnet/session/transport.h> u32 session_rule_tag_key_index (u32 ri, u8 is_ip4) { return ((ri << 1) | is_ip4); } void session_rule_tag_key_index_parse (u32 rti_key, u32 * ri, u8 * is_ip4) { *is_ip4 = rti_key & 1; *ri = rti_key >> 1; } u8 * session_rules_table_rule_tag (session_rules_table_t * srt, u32 ri, u8 is_ip4) { uword *tip; session_rule_tag_t *rt; tip = hash_get (srt->tags_by_rules, session_rule_tag_key_index (ri, is_ip4)); if (tip) { rt = pool_elt_at_index (srt->rule_tags, *tip); return rt->tag; } return 0; } void session_rules_table_del_tag (session_rules_table_t * srt, u8 * tag, u8 is_ip4) { uword *rip, *rtip; session_rule_tag_t *rt; u32 rti_key; if (tag == 0) return; rip = hash_get_mem (srt->rules_by_tag, tag); if (!rip) { clib_warning ("tag has no rule associated"); return; } rti_key = session_rule_tag_key_index (*rip, is_ip4); rtip = hash_get (srt->tags_by_rules, rti_key); if (!rtip) { clib_warning ("rule has no tag associated"); return; } rt = pool_elt_at_index (srt->rule_tags, *rtip); ASSERT (rt); hash_unset_mem (srt->rules_by_tag, tag); hash_unset (srt->tags_by_rules, rti_key); pool_put (srt->rule_tags, rt); } void session_rules_table_add_tag (session_rules_table_t * srt, u8 * tag, u32 rule_index, u8 is_ip4) { uword *rip; session_rule_tag_t *rt; u32 rti_key; if (tag == 0) return; rip = hash_get_mem (srt->rules_by_tag, tag); if (rip) session_rules_table_del_tag (srt, tag, is_ip4); pool_get (srt->rule_tags, rt); rt->tag = vec_dup (tag); hash_set_mem (srt->rules_by_tag, rt->tag, rule_index); rti_key = session_rule_tag_key_index (rule_index, is_ip4); hash_set (srt->tags_by_rules, rti_key, rt - srt->rule_tags); } u32 session_rules_table_rule_for_tag (session_rules_table_t * srt, u8 * tag) { uword *rp; if (tag == 0) return SESSION_RULES_TABLE_INVALID_INDEX; rp = hash_get_mem (srt->rules_by_tag, tag); return (rp == 0 ? SESSION_RULES_TABLE_INVALID_INDEX : *rp); } static void fib_pref_normalize (fib_prefix_t * pref) { if (pref->fp_proto == FIB_PROTOCOL_IP4) ip4_address_normalize (&pref->fp_addr.ip4, pref->fp_len); else ip6_address_normalize (&pref->fp_addr.ip6, pref->fp_len); } u8 * format_session_rule4 (u8 * s, va_list * args) { session_rules_table_t *srt = va_arg (*args, session_rules_table_t *); mma_rule_16_t *sr = va_arg (*args, mma_rule_16_t *); session_mask_or_match_4_t *mask, *match; mma_rules_table_16_t *srt4; u8 *tag = 0, *null_tag = format (0, "none"); u32 ri; int i; srt4 = &srt->session_rules_tables_16; ri = mma_rules_table_rule_index_16 (srt4, sr); tag = session_rules_table_rule_tag (srt, ri, 1); match = (session_mask_or_match_4_t *) & sr->match; mask = (session_mask_or_match_4_t *) & sr->mask; s = format (s, "[%d] rule: %U/%d %d %U/%d %d action: %d tag: %v", ri, format_ip4_address, &match->lcl_ip, ip4_mask_to_preflen (&mask->lcl_ip), clib_net_to_host_u16 (match->lcl_port), format_ip4_address, &match->rmt_ip, ip4_mask_to_preflen (&mask->rmt_ip), clib_net_to_host_u16 (match->rmt_port), sr->action_index, tag ? tag : null_tag); if (vec_len (sr->next_indices)) { s = format (s, "\n children: "); for (i = 0; i < vec_len (sr->next_indices); i++) s = format (s, "%d ", sr->next_indices[i]); } vec_free (null_tag); return s; } u8 * format_session_rule6 (u8 * s, va_list * args) { session_rules_table_t *srt = va_arg (*args, session_rules_table_t *); mma_rule_40_t *sr = va_arg (*args, mma_rule_40_t *); session_mask_or_match_6_t *mask, *match; mma_rules_table_40_t *srt6; u8 *tag = 0, *null_tag = format (0, "none"); u32 ri; int i; srt6 = &srt->session_rules_tables_40; ri = mma_rules_table_rule_index_40 (srt6, sr); tag = session_rules_table_rule_tag (srt, ri, 0); match = (session_mask_or_match_6_t *) & sr->match; mask = (session_mask_or_match_6_t *) & sr->mask; s = format (s, "[%d] rule: %U/%d %d %U/%d %d action: %d tag: %v", ri, format_ip6_address, &match->lcl_ip, ip6_mask_to_preflen (&mask->lcl_ip), clib_net_to_host_u16 (match->lcl_port), format_ip6_address, &match->rmt_ip, ip6_mask_to_preflen (&mask->rmt_ip), clib_net_to_host_u16 (match->rmt_port), sr->action_index, tag ? tag : null_tag); if (vec_len (sr->next_indices)) { s = format (s, "\n children: "); for (i = 0; i < vec_len (sr->next_indices); i++) s = format (s, "%d ", sr->next_indices[i]); } vec_free (null_tag); return s; } void * session_rules_table_get (session_rules_table_t * srt, u8 fib_proto) { if (fib_proto == FIB_PROTOCOL_IP4) return &srt->session_rules_tables_16; else if (fib_proto == FIB_PROTOCOL_IP6) return &srt->session_rules_tables_40; return 0; } int rule_cmp_16 (mma_rule_16_t * rule1, mma_rule_16_t * rule2) { session_mask_or_match_4_t *m1, *m2; m1 = (session_mask_or_match_4_t *) & rule1->max_match; m2 = (session_mask_or_match_4_t *) & rule2->max_match; if (m1->rmt_ip.as_u32 != m2->rmt_ip.as_u32) return (m1->rmt_ip.as_u32 < m2->rmt_ip.as_u32 ? -1 : 1); if (m1->lcl_ip.as_u32 != m2->lcl_ip.as_u32) return (m1->lcl_ip.as_u32 < m2->lcl_ip.as_u32 ? -1 : 1); if (m1->rmt_port != m2->rmt_port) return (m1->rmt_port < m2->rmt_port ? -1 : 1); if (m1->lcl_port != m2->lcl_port) return (m1->lcl_port < m2->lcl_port ? -1 : 1); return 0; } int rule_cmp_40 (mma_rule_40_t * rule1, mma_rule_40_t * rule2) { session_mask_or_match_6_t *r1, *r2; r1 = (session_mask_or_match_6_t *) & rule1->max_match; r2 = (session_mask_or_match_6_t *) & rule2->max_match; if (r1->rmt_ip.as_u64[0] != r2->rmt_ip.as_u64[0]) return (r1->rmt_ip.as_u64[0] < r2->rmt_ip.as_u64[0] ? -1 : 1); if (r1->rmt_ip.as_u64[1] != r2->rmt_ip.as_u64[1]) return (r1->rmt_ip.as_u64[1] < r2->rmt_ip.as_u64[1] ? -1 : 1); if (r1->lcl_ip.as_u64[0] != r2->lcl_ip.as_u64[0]) return (r1->lcl_ip.as_u64[0] < r2->lcl_ip.as_u64[0] ? -1 : 1); if (r1->lcl_ip.as_u64[1] != r2->lcl_ip.as_u64[1]) return (r1->lcl_ip.as_u64[1] < r2->lcl_ip.as_u64[1]) ? -1 : 1; if (r1->rmt_port != r2->rmt_port) return (r1->rmt_port < r2->rmt_port ? -1 : 1); if (r1->lcl_port != r2->lcl_port) return (r1->lcl_port < r2->lcl_port ? -1 : 1); return 0; } 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) { session_mask_or_match_4_t *match, *mask, *max_match; fib_pref_normalize (lcl); fib_pref_normalize (rmt); match = (session_mask_or_match_4_t *) & rule->match; match->lcl_ip.as_u32 = lcl->fp_addr.ip4.as_u32; match->rmt_ip.as_u32 = rmt->fp_addr.ip4.as_u32; match->lcl_port = lcl_port; match->rmt_port = rmt_port; mask = (session_mask_or_match_4_t *) & rule->mask; ip4_preflen_to_mask (lcl->fp_len, &mask->lcl_ip); ip4_preflen_to_mask (rmt->fp_len, &mask->rmt_ip); mask->lcl_port = lcl_port == 0 ? 0 : (u16) ~ 0; mask->rmt_port = rmt_port == 0 ? 0 : (u16) ~ 0; max_match = (session_mask_or_match_4_t *) & rule->max_match; ip4_prefix_max_address_host_order (&rmt->fp_addr.ip4, rmt->fp_len, &max_match->rmt_ip); ip4_prefix_max_address_host_order (&lcl->fp_addr.ip4, lcl->fp_len, &max_match->lcl_ip); max_match->lcl_port = lcl_port == 0 ? (u16) ~ 0 : lcl_port; max_match->rmt_port = rmt_port == 0 ? (u16) ~ 0 : rmt_port; } 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) { session_mask_or_match_6_t *match, *mask, *max_match; fib_pref_normalize (lcl); fib_pref_normalize (rmt); match = (session_mask_or_match_6_t *) & rule->match; clib_memcpy_fast (&match->lcl_ip, &lcl->fp_addr.ip6, sizeof (match->lcl_ip)); clib_memcpy_fast (&match->rmt_ip, &rmt->fp_addr.ip6, sizeof (match->rmt_ip)); match->lcl_port = lcl_port; match->rmt_port = rmt_port; mask = (session_mask_or_match_6_t *) & rule->mask; ip6_preflen_to_mask (lcl->fp_len, &mask->lcl_ip); ip6_preflen_to_mask (rmt->fp_len, &mask->rmt_ip); mask->lcl_port = lcl_port == 0 ? 0 : (u16) ~ 0; mask->rmt_port = rmt_port == 0 ? 0 : (u16) ~ 0; max_match = (session_mask_or_match_6_t *) & rule->max_match; ip6_prefix_max_address_host_order (&rmt->fp_addr.ip6, rmt->fp_len, &max_match->rmt_ip); ip6_prefix_max_address_host_order (&lcl->fp_addr.ip6, lcl->fp_len, &max_match->lcl_ip); max_match->lcl_port = lcl_port == 0 ? (u16) ~ 0 : lcl_port; max_match->rmt_port = rmt_port == 0 ? (u16) ~ 0 : 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) { mma_rule_16_t *rule = 0; rule = mma_rules_table_rule_alloc_16 (srt); session_rules_table_init_rule_16 (rule, lcl, lcl_port, rmt, rmt_port); return rule; } 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) { mma_rule_40_t *rule; rule = mma_rules_table_rule_alloc_40 (srt); session_rules_table_init_rule_40 (rule, lcl, lcl_port, rmt, rmt_port); return rule; } 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) { mma_rules_table_16_t *srt4 = &srt->session_rules_tables_16; session_mask_or_match_4_t key = { .lcl_ip.as_u32 = lcl_ip->as_u32, .rmt_ip.as_u32 = rmt_ip->as_u32, .lcl_port = lcl_port, .rmt_port = rmt_port, }; return mma_rules_table_lookup_rule_16 (srt4, (mma_mask_or_match_16_t *) & key, srt4->root_index); } 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_rules_table_16_t *srt4 = &srt->session_rules_tables_16; session_mask_or_match_4_t key = { .lcl_ip.as_u32 = lcl_ip->as_u32, .rmt_ip.as_u32 = rmt_ip->as_u32, .lcl_port = lcl_port, .rmt_port = rmt_port, }; return mma_rules_table_lookup_16 (srt4, (mma_mask_or_match_16_t *) & key, srt4->root_index); } 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) { mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40; session_mask_or_match_6_t key = { .lcl_port = lcl_port, .rmt_port = rmt_port, }; clib_memcpy_fast (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip)); clib_memcpy_fast (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip)); return mma_rules_table_lookup_rule_40 (srt6, (mma_mask_or_match_40_t *) & key, srt6->root_index); } 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) { mma_rules_table_40_t *srt6 = &srt->session_rules_tables_40; session_mask_or_match_6_t key = { .lcl_port = lcl_port, .rmt_port = rmt_port, }; clib_memcpy_fast (&key.lcl_ip, lcl_ip, sizeof (*lcl_ip)); clib_memcpy_fast (&key.rmt_ip, rmt_ip, sizeof (*rmt_ip)); return mma_rules_table_lookup_40 (srt6, (mma_mask_or_match_40_t *) & key, srt6->root_index); } /** * Add/delete session rule * * @param srt table where rule should be added * @param args rule arguments * * @return 0 if success, clib_error_t error otherwise */ int session_rules_table_add_del (session_rules_table_t * srt, session_rule_table_add_del_args_t * args) { u8 fib_proto = args->rmt.fp_proto, *rt; u32 ri_from_tag, ri; int rv; ri_from_tag = session_rules_table_rule_for_tag (srt, args->tag); if (args->is_add && ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX) return VNET_API_ERROR_INVALID_VALUE; if (fib_proto == FIB_PROTOCOL_IP4) { mma_rules_table_16_t *srt4; srt4 = &srt->session_rules_tables_16; if (args->is_add) { mma_rule_16_t *rule4; rule4 = session_rules_table_alloc_rule_16 (srt4, &args->lcl, args->lcl_port, &args->rmt, args->rmt_port); rule4->action_index = args->action_index; rv = mma_rules_table_add_rule_16 (srt4, rule4); if (!rv) { ri = mma_rules_table_rule_index_16 (srt4, rule4); session_rules_table_add_tag (srt, args->tag, ri, 1); } else { ri = session_rules_table_lookup_rule4 (srt, &args->lcl.fp_addr.ip4, &args->rmt.fp_addr.ip4, args->lcl_port, args->rmt_port); if (ri != SESSION_RULES_TABLE_INVALID_INDEX) { rt = session_rules_table_rule_tag (srt, ri, 1); session_rules_table_del_tag (srt, rt, 1); session_rules_table_add_tag (srt, args->tag, ri, 1); } } } else { mma_rule_16_t *rule; if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX) { rule = mma_rules_table_get_rule_16 (srt4, ri_from_tag); mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index); session_rules_table_del_tag (srt, args->tag, 1); } else { mma_rule_16_t _rule; rule = &_rule; clib_memset (rule, 0, sizeof (*rule)); session_rules_table_init_rule_16 (rule, &args->lcl, args->lcl_port, &args->rmt, args->rmt_port); mma_rules_table_del_rule_16 (srt4, rule, srt4->root_index); } } } else if (fib_proto == FIB_PROTOCOL_IP6) { mma_rules_table_40_t *srt6; mma_rule_40_t *rule6; srt6 = &srt->session_rules_tables_40; if (args->is_add) { rule6 = session_rules_table_alloc_rule_40 (srt6, &args->lcl, args->lcl_port, &args->rmt, args->rmt_port); rule6->action_index = args->action_index; rv = mma_rules_table_add_rule_40 (srt6, rule6); if (!rv) { ri = mma_rules_table_rule_index_40 (srt6, rule6); session_rules_table_add_tag (srt, args->tag, ri, 0); } else { ri = session_rules_table_lookup_rule6 (srt, &args->lcl.fp_addr.ip6, &args->rmt.fp_addr.ip6, args->lcl_port, args->rmt_port); if (ri != SESSION_RULES_TABLE_INVALID_INDEX) { rt = session_rules_table_rule_tag (srt, ri, 0); session_rules_table_del_tag (srt, rt, 1); session_rules_table_add_tag (srt, args->tag, ri, 0); } } } else { mma_rule_40_t *rule; if (ri_from_tag != SESSION_RULES_TABLE_INVALID_INDEX) { rule = mma_rules_table_get_rule_40 (srt6, ri_from_tag); mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index); session_rules_table_del_tag (srt, args->tag, 0); } else { mma_rule_40_t _rule; rule = &_rule; clib_memset (rule, 0, sizeof (*rule)); session_rules_table_init_rule_40 (rule, &args->lcl, args->lcl_port, &args->rmt, args->rmt_port); mma_rules_table_del_rule_40 (srt6, rule, srt6->root_index); } } } else return VNET_API_ERROR_INVALID_VALUE_2; return 0; } void session_rules_table_init (session_rules_table_t * srt) { mma_rules_table_16_t *srt4; mma_rules_table_40_t *srt6; mma_rule_16_t *rule4; mma_rule_40_t *rule6; fib_prefix_t null_prefix; clib_memset (&null_prefix, 0, sizeof (null_prefix)); srt4 = &srt->session_rules_tables_16; rule4 = session_rules_table_alloc_rule_16 (srt4, &null_prefix, 0, &null_prefix, 0); rule4->action_index = SESSION_RULES_TABLE_INVALID_INDEX; srt4->root_index = mma_rules_table_rule_index_16 (srt4, rule4); srt4->rule_cmp_fn = rule_cmp_16; srt6 = &srt->session_rules_tables_40; rule6 = session_rules_table_alloc_rule_40 (srt6, &null_prefix, 0, &null_prefix, 0); rule6->action_index = SESSION_RULES_TABLE_INVALID_INDEX; srt6->root_index = mma_rules_table_rule_index_40 (srt6, rule6); srt6->rule_cmp_fn = rule_cmp_40; srt->rules_by_tag = hash_create_vec (0, sizeof (u8), sizeof (uword)); srt->tags_by_rules = hash_create (0, sizeof (uword)); } 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) { mma_rules_table_16_t *srt4; mma_rules_table_40_t *srt6; mma_rule_16_t *sr4; mma_rule_40_t *sr6; u32 ri; if (is_ip4) { srt4 = session_rules_table_get (srt, FIB_PROTOCOL_IP4); session_mask_or_match_4_t key = { .lcl_ip.as_u32 = lcl_ip->ip4.as_u32, .rmt_ip.as_u32 = rmt_ip->ip4.as_u32, .lcl_port = lcl_port, .rmt_port = rmt_port, }; ri = mma_rules_table_lookup_rule_16 (srt4, (mma_mask_or_match_16_t *) & key, srt4->root_index); sr4 = mma_rules_table_get_rule_16 (srt4, ri); vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4); } else { srt6 = session_rules_table_get (srt, FIB_PROTOCOL_IP6); session_mask_or_match_6_t key = { .lcl_port = lcl_port, .rmt_port = rmt_port, }; clib_memcpy_fast (&key.lcl_ip, &lcl_ip->ip6, sizeof (lcl_ip->ip6)); clib_memcpy_fast (&key.rmt_ip, &rmt_ip->ip6, sizeof (rmt_ip->ip6)); ri = mma_rules_table_lookup_rule_40 (srt6, (mma_mask_or_match_40_t *) & key, srt6->root_index); sr6 = mma_rules_table_get_rule_40 (srt6, ri); vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6); } } void session_rules_table_cli_dump (vlib_main_t * vm, session_rules_table_t * srt, u8 fib_proto) { if (fib_proto == FIB_PROTOCOL_IP4) { mma_rules_table_16_t *srt4; mma_rule_16_t *sr4; srt4 = &srt->session_rules_tables_16; vlib_cli_output (vm, "IP4 rules"); /* *INDENT-OFF* */ pool_foreach(sr4, srt4->rules, ({ vlib_cli_output (vm, "%U", format_session_rule4, srt, sr4); })); /* *INDENT-ON* */ } else if (fib_proto == FIB_PROTOCOL_IP6) { mma_rules_table_40_t *srt6; mma_rule_40_t *sr6; srt6 = &srt->session_rules_tables_40; vlib_cli_output (vm, "IP6 rules"); /* *INDENT-OFF* */ pool_foreach(sr6, srt6->rules, ({ vlib_cli_output (vm, "%U", format_session_rule6, srt, sr6); })); /* *INDENT-ON* */ } } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */