zebra: include zebra nexthop debug in show runn

[mirror_frr.git] / zebra / zebra_pbr.c

diff --git a/zebra/zebra_pbr.c b/zebra/zebra_pbr.c
index 73db567eace35a52a1e6427f120504060025ae27..0c3adcdfa1f332c7d4d453ab155fe702b410fdf5 100644 (file)
--- a/zebra/zebra_pbr.c
+++ b/zebra/zebra_pbr.c
@@ -135,26 +135,21 @@ void zebra_pbr_rules_free(void *arg)
        XFREE(MTYPE_TMP, rule);
 }
 
-uint32_t zebra_pbr_rules_hash_key(void *arg)
+uint32_t zebra_pbr_rules_hash_key(const void *arg)
 {
-       struct zebra_pbr_rule *rule;
+       const struct zebra_pbr_rule *rule;
        uint32_t key;
 
-       rule = (struct zebra_pbr_rule *)arg;
+       rule = arg;
        key = jhash_3words(rule->rule.seq, rule->rule.priority,
                           rule->rule.action.table,
                           prefix_hash_key(&rule->rule.filter.src_ip));
-       if (rule->ifp)
-               key = jhash_1word(rule->ifp->ifindex, key);
-       else
-               key = jhash_1word(0, key);
 
        if (rule->rule.filter.fwmark)
-               key = jhash_1word(rule->rule.filter.fwmark, key);
+               key = jhash_3words(rule->rule.filter.fwmark, rule->vrf_id,
+                                  rule->rule.ifindex, key);
        else
-               key = jhash_1word(0, key);
-
-       key = jhash_1word(rule->vrf_id, key);
+               key = jhash_2words(rule->vrf_id, rule->rule.ifindex, key);
 
        return jhash_3words(rule->rule.filter.src_port,
                            rule->rule.filter.dst_port,
@@ -196,7 +191,7 @@ bool zebra_pbr_rules_hash_equal(const void *arg1, const void *arg2)
        if (!prefix_same(&r1->rule.filter.dst_ip, &r2->rule.filter.dst_ip))
                return false;
 
-       if (r1->ifp != r2->ifp)
+       if (r1->rule.ifindex != r2->rule.ifindex)
                return false;
 
        if (r1->vrf_id != r2->vrf_id)
@@ -208,7 +203,7 @@ bool zebra_pbr_rules_hash_equal(const void *arg1, const void *arg2)
 struct pbr_rule_unique_lookup {
        struct zebra_pbr_rule *rule;
        uint32_t unique;
-       struct interface *ifp;
+       ifindex_t ifindex;
        vrf_id_t vrf_id;
 };
 
@@ -218,7 +213,7 @@ static int pbr_rule_lookup_unique_walker(struct hash_bucket *b, void *data)
        struct zebra_pbr_rule *rule = b->data;
 
        if (pul->unique == rule->rule.unique
-           && pul->ifp == rule->ifp
+           && pul->ifindex == rule->rule.ifindex
            && pul->vrf_id == rule->vrf_id) {
                pul->rule = rule;
                return HASHWALK_ABORT;
@@ -233,7 +228,7 @@ pbr_rule_lookup_unique(struct zebra_pbr_rule *zrule)
        struct pbr_rule_unique_lookup pul;
 
        pul.unique = zrule->rule.unique;
-       pul.ifp = zrule->ifp;
+       pul.ifindex = zrule->rule.ifindex;
        pul.rule = NULL;
        pul.vrf_id = zrule->vrf_id;
        hash_walk(zrouter.rules_hash, &pbr_rule_lookup_unique_walker, &pul);
@@ -250,9 +245,9 @@ void zebra_pbr_ipset_free(void *arg)
        XFREE(MTYPE_TMP, ipset);
 }
 
-uint32_t zebra_pbr_ipset_hash_key(void *arg)
+uint32_t zebra_pbr_ipset_hash_key(const void *arg)
 {
-       struct zebra_pbr_ipset *ipset = (struct zebra_pbr_ipset *)arg;
+       const struct zebra_pbr_ipset *ipset = arg;
        uint32_t *pnt = (uint32_t *)&ipset->ipset_name;
        uint32_t key = jhash_1word(ipset->vrf_id, 0x63ab42de);
 
@@ -290,12 +285,12 @@ void zebra_pbr_ipset_entry_free(void *arg)
        XFREE(MTYPE_TMP, ipset);
 }
 
-uint32_t zebra_pbr_ipset_entry_hash_key(void *arg)
+uint32_t zebra_pbr_ipset_entry_hash_key(const void *arg)
 {
-       struct zebra_pbr_ipset_entry *ipset;
+       const struct zebra_pbr_ipset_entry *ipset;
        uint32_t key;
 
-       ipset = (struct zebra_pbr_ipset_entry *)arg;
+       ipset = arg;
        key = prefix_hash_key(&ipset->src);
        key = jhash_1word(ipset->unique, key);
        key = jhash_1word(prefix_hash_key(&ipset->dst), key);
@@ -350,18 +345,20 @@ void zebra_pbr_iptable_free(void *arg)
        iptable = (struct zebra_pbr_iptable *)arg;
        hook_call(zebra_pbr_iptable_update, 0, iptable);
 
-       for (ALL_LIST_ELEMENTS(iptable->interface_name_list,
-                                       node, nnode, name)) {
-               XFREE(MTYPE_PBR_IPTABLE_IFNAME, name);
-               list_delete_node(iptable->interface_name_list,
-                                node);
+       if (iptable->interface_name_list) {
+               for (ALL_LIST_ELEMENTS(iptable->interface_name_list, node,
+                                      nnode, name)) {
+                       XFREE(MTYPE_PBR_IPTABLE_IFNAME, name);
+                       list_delete_node(iptable->interface_name_list, node);
+               }
+               list_delete(&iptable->interface_name_list);
        }
        XFREE(MTYPE_TMP, iptable);
 }
 
-uint32_t zebra_pbr_iptable_hash_key(void *arg)
+uint32_t zebra_pbr_iptable_hash_key(const void *arg)
 {
-       struct zebra_pbr_iptable *iptable = (struct zebra_pbr_iptable *)arg;
+       const struct zebra_pbr_iptable *iptable = arg;
        uint32_t *pnt = (uint32_t *)&(iptable->ipset_name);
        uint32_t key;
 
@@ -373,6 +370,7 @@ uint32_t zebra_pbr_iptable_hash_key(void *arg)
        key = jhash_1word(iptable->tcp_flags, key);
        key = jhash_1word(iptable->tcp_mask_flags, key);
        key = jhash_1word(iptable->dscp_value, key);
+       key = jhash_1word(iptable->protocol, key);
        key = jhash_1word(iptable->fragment, key);
        key = jhash_1word(iptable->vrf_id, key);
 
@@ -414,6 +412,8 @@ bool zebra_pbr_iptable_hash_equal(const void *arg1, const void *arg2)
                return false;
        if (r1->fragment != r2->fragment)
                return false;
+       if (r1->protocol != r2->protocol)
+               return false;
        return true;
 }
 
@@ -468,8 +468,12 @@ static void zebra_pbr_cleanup_rules(struct hash_bucket *b, void *data)
 
        if (rule->sock == *sock) {
                (void)kernel_del_pbr_rule(rule);
-               hash_release(zrouter.rules_hash, rule);
-               XFREE(MTYPE_TMP, rule);
+               if (hash_release(zrouter.rules_hash, rule))
+                       XFREE(MTYPE_TMP, rule);
+               else
+                       zlog_debug(
+                               "%s: Rule seq: %u is being cleaned but we can't find it in our tables",
+                               __func__, rule->rule.seq);
        }
 }
 
@@ -686,6 +690,7 @@ void zebra_pbr_del_iptable(struct zebra_pbr_iptable *iptable)
                        list_delete_node(iptable->interface_name_list,
                                         node);
                }
+               list_delete(&iptable->interface_name_list);
                XFREE(MTYPE_TMP, lookup);
        } else
                zlog_debug("%s: IPTable being deleted we know nothing about",
@@ -1095,6 +1100,10 @@ static void zebra_pbr_show_iptable_unit(struct zebra_pbr_iptable *iptable,
                        " not" : "", lookup_msg(fragment_value_str,
                                               iptable->fragment, val_str));
        }
+       if (iptable->protocol) {
+               vty_out(vty, "\t protocol %d\n",
+                       iptable->protocol);
+       }
        ret = hook_call(zebra_pbr_iptable_get_stat, iptable, &pkts,
                        &bytes);
        if (ret && pkts > 0)