src: replace compound_expr_add() by type safe set_expr_add()

Replace compound_expr_add() by set_expr_add() to validate type.

Add __set_expr_add() to skip size updates in src/intervals.c

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/include/expression.h b/include/expression.h
index acd0fd3d14fa931a9997535d56fde218207e5c16..4dc6c1926f95c32a7b99d3b4235169baa75316c7 100644 (file)
--- a/include/expression.h
+++ b/include/expression.h
@@ -537,6 +537,9 @@ struct expr *list_expr_to_binop(struct expr *expr);
 
 extern struct expr *set_expr_alloc(const struct location *loc,
                                   const struct set *set);
+void __set_expr_add(struct expr *set, struct expr *elem);
+void set_expr_add(struct expr *set, struct expr *elem);
+
 extern void concat_range_aggregate(struct expr *set);
 extern void interval_map_decompose(struct expr *set);
 

diff --git a/src/expression.c b/src/expression.c
index e3c27a13f8dba49e157e49cd8f3b1a0d2c3e2326..8c5b5176fe8b1a6ce9d309366d9c527a5fd2a69d 100644 (file)
--- a/src/expression.c
+++ b/src/expression.c
@@ -1392,6 +1392,19 @@ struct expr *set_expr_alloc(const struct location *loc, const struct set *set)
        return set_expr;
 }
 
+void __set_expr_add(struct expr *set, struct expr *elem)
+{
+       list_add_tail(&elem->list, &expr_set(set)->expressions);
+}
+
+void set_expr_add(struct expr *set, struct expr *elem)
+{
+       struct expr_set *expr_set = expr_set(set);
+
+       list_add_tail(&elem->list, &expr_set->expressions);
+       expr_set->size++;
+}
+
 static void mapping_expr_print(const struct expr *expr, struct output_ctx *octx)
 {
        expr_print(expr->left, octx);

diff --git a/src/intervals.c b/src/intervals.c
index d5afffd2120aea7c3cb573065ee48c772b732125..a63c58ac96066c36295f6e150b19ea71e28993bb 100644 (file)
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -278,7 +278,7 @@ int set_automerge(struct list_head *msgs, struct cmd *cmd, struct set *set,
                        }
                        clone = expr_clone(i);
                        clone->flags |= EXPR_F_KERNEL;
-                       list_add_tail(&clone->list, &expr_set(existing_set->init)->expressions);
+                       __set_expr_add(existing_set->init, clone);
                }
        }
 
@@ -359,7 +359,7 @@ static void split_range(struct set *set, struct expr *prev, struct expr *i,
        clone = expr_clone(prev);
        mpz_set(clone->key->range.low, i->key->range.high);
        mpz_add_ui(clone->key->range.low, i->key->range.high, 1);
-       list_add_tail(&clone->list, &expr_set(set->existing_set->init)->expressions);
+       __set_expr_add(set->existing_set->init, clone);
 
        mpz_set(prev->key->range.high, i->key->range.low);
        mpz_sub_ui(prev->key->range.high, i->key->range.low, 1);
@@ -527,7 +527,7 @@ int set_delete(struct list_head *msgs, struct cmd *cmd, struct set *set,
        list_for_each_entry(i, &expr_set(existing_set->init)->expressions, list) {
                if (!(i->flags & EXPR_F_KERNEL)) {
                        clone = expr_clone(i);
-                       list_add_tail(&clone->list, &expr_set(add)->expressions);
+                       __set_expr_add(add, clone);
                        i->flags |= EXPR_F_KERNEL;
                }
        }
@@ -646,7 +646,7 @@ int set_overlap(struct list_head *msgs, struct set *set, struct expr *init)
                else if (existing_set) {
                        clone = expr_clone(i);
                        clone->flags |= EXPR_F_KERNEL;
-                       list_add_tail(&clone->list, &expr_set(existing_set->init)->expressions);
+                       __set_expr_add(existing_set->init, clone);
                }
        }
 

diff --git a/src/monitor.c b/src/monitor.c
index da1ad880f0c83af8bcc8aecc6038cef79e8c2325..e58f62252ca2d27906dce9e7a24aad029c1dd37d 100644 (file)
--- a/src/monitor.c
+++ b/src/monitor.c
@@ -400,7 +400,7 @@ static bool netlink_event_range_cache(struct set *cached_set,
 
        /* if cache exists, dummyset must contain the other end of the range */
        if (cached_set->rg_cache) {
-               compound_expr_add(dummyset->init, cached_set->rg_cache);
+               set_expr_add(dummyset->init, cached_set->rg_cache);
                cached_set->rg_cache = NULL;
                goto out_decompose;
        }

diff --git a/src/netlink.c b/src/netlink.c
index 5bae3b82997443639b1f786f78f2a19752ad555b..0fa8d1f3ff686122b7a68e3e2ea99aa281447966 100644 (file)
--- a/src/netlink.c
+++ b/src/netlink.c
@@ -1591,7 +1591,7 @@ key_end:
                expr = mapping_expr_alloc(&netlink_location, expr, data);
        }
 out:
-       compound_expr_add(set->init, expr);
+       set_expr_add(set->init, expr);
 
        if (!(flags & NFT_SET_ELEM_INTERVAL_END) &&
            nftnl_set_elem_is_set(nlse, NFTNL_SET_ELEM_KEY_END)) {

diff --git a/src/optimize.c b/src/optimize.c
index 40756cecbbc338878d72cf01f7d2c2b2ec4fc43f..b2fd9e829f006811e451adbd5d6f74226f9624c1 100644 (file)
--- a/src/optimize.c
+++ b/src/optimize.c
@@ -569,13 +569,13 @@ static void merge_expr_stmts(const struct optimize_ctx *ctx,
 
        expr_a = stmt_a->expr->right;
        elem = set_elem_expr_alloc(&internal_location, expr_get(expr_a));
-       compound_expr_add(set, elem);
+       set_expr_add(set, elem);
 
        for (i = from + 1; i <= to; i++) {
                stmt_b = ctx->stmt_matrix[i][merge->stmt[0]];
                expr_b = stmt_b->expr->right;
                elem = set_elem_expr_alloc(&internal_location, expr_get(expr_b));
-               compound_expr_add(set, elem);
+               set_expr_add(set, elem);
        }
 
        expr_free(stmt_a->expr->right);
@@ -590,7 +590,7 @@ static void merge_vmap(const struct optimize_ctx *ctx,
        mappings = stmt_b->expr->mappings;
        list_for_each_entry(expr, &expr_set(mappings)->expressions, list) {
                mapping = expr_clone(expr);
-               compound_expr_add(stmt_a->expr->mappings, mapping);
+               set_expr_add(stmt_a->expr->mappings, mapping);
        }
 }
 
@@ -702,7 +702,7 @@ static void __merge_concat_stmts(const struct optimize_ctx *ctx, uint32_t i,
        list_for_each_entry_safe(concat, next, &concat_list, list) {
                list_del(&concat->list);
                elem = set_elem_expr_alloc(&internal_location, concat);
-               compound_expr_add(set, elem);
+               set_expr_add(set, elem);
        }
 }
 
@@ -759,7 +759,7 @@ static void build_verdict_map(struct expr *expr, struct stmt *verdict,
 
                        mapping = mapping_expr_alloc(&internal_location, elem,
                                                     expr_get(verdict->expr));
-                       compound_expr_add(set, mapping);
+                       set_expr_add(set, mapping);
                }
                stmt_free(counter);
                break;
@@ -773,7 +773,7 @@ static void build_verdict_map(struct expr *expr, struct stmt *verdict,
 
                        mapping = mapping_expr_alloc(&internal_location, elem,
                                                     expr_get(verdict->expr));
-                       compound_expr_add(set, mapping);
+                       set_expr_add(set, mapping);
                }
                stmt_free(counter);
                break;
@@ -790,7 +790,7 @@ static void build_verdict_map(struct expr *expr, struct stmt *verdict,
 
                mapping = mapping_expr_alloc(&internal_location, elem,
                                             expr_get(verdict->expr));
-               compound_expr_add(set, mapping);
+               set_expr_add(set, mapping);
                break;
        default:
                assert(0);
@@ -898,7 +898,7 @@ static void __merge_concat_stmts_vmap(const struct optimize_ctx *ctx,
 
                mapping = mapping_expr_alloc(&internal_location, elem,
                                             expr_get(verdict->expr));
-               compound_expr_add(set, mapping);
+               set_expr_add(set, mapping);
        }
        stmt_free(counter);
 }
@@ -1061,7 +1061,7 @@ static void merge_nat(const struct optimize_ctx *ctx,
 
                elem = set_elem_expr_alloc(&internal_location, expr_get(expr));
                mapping = mapping_expr_alloc(&internal_location, elem, nat_expr);
-               compound_expr_add(set, mapping);
+               set_expr_add(set, mapping);
        }
 
        stmt = ctx->stmt_matrix[from][merge->stmt[0]];
@@ -1118,7 +1118,7 @@ static void merge_concat_nat(const struct optimize_ctx *ctx,
 
                elem = set_elem_expr_alloc(&internal_location, concat);
                mapping = mapping_expr_alloc(&internal_location, elem, nat_expr);
-               compound_expr_add(set, mapping);
+               set_expr_add(set, mapping);
        }
 
        concat = concat_expr_alloc(&internal_location);

diff --git a/src/parser_bison.y b/src/parser_bison.y
index 13eb6027b8e8a2d429f15c35da1f24fda83872a6..75db4171b2e2572c0156a865243734207e35885a 100644 (file)
--- a/src/parser_bison.y
+++ b/src/parser_bison.y
@@ -3325,11 +3325,11 @@ verdict_map_expr        :       '{'     verdict_map_list_expr   '}'
 verdict_map_list_expr  :       verdict_map_list_member_expr
                        {
                                $$ = set_expr_alloc(&@$, NULL);
-                               compound_expr_add($$, $1);
+                               set_expr_add($$, $1);
                        }
                        |       verdict_map_list_expr   COMMA   verdict_map_list_member_expr
                        {
-                               compound_expr_add($1, $3);
+                               set_expr_add($1, $3);
                                $$ = $1;
                        }
                        |       verdict_map_list_expr   COMMA   opt_newline
@@ -4584,11 +4584,11 @@ set_expr                :       '{'     set_list_expr           '}'
 set_list_expr          :       set_list_member_expr
                        {
                                $$ = set_expr_alloc(&@$, NULL);
-                               compound_expr_add($$, $1);
+                               set_expr_add($$, $1);
                        }
                        |       set_list_expr           COMMA   set_list_member_expr
                        {
-                               compound_expr_add($1, $3);
+                               set_expr_add($1, $3);
                                $$ = $1;
                        }
                        |       set_list_expr           COMMA   opt_newline

diff --git a/src/parser_json.c b/src/parser_json.c
index 8bca6a596222185607e895aae3a5abfe509afbde..cd6744f96268e1731eda79ff5e3f19bff1056a1a 100644 (file)
--- a/src/parser_json.c
+++ b/src/parser_json.c
@@ -1471,7 +1471,7 @@ static struct expr *json_parse_set_expr(struct json_ctx *ctx,
 
                expr = set_elem_expr_alloc(int_loc, expr);
                set_expr = set_expr_alloc(int_loc, NULL);
-               compound_expr_add(set_expr, expr);
+               set_expr_add(set_expr, expr);
                return set_expr;
        }
 
@@ -1515,7 +1515,7 @@ static struct expr *json_parse_set_expr(struct json_ctx *ctx,
 
                if (!set_expr)
                        set_expr = set_expr_alloc(int_loc, NULL);
-               compound_expr_add(set_expr, expr);
+               set_expr_add(set_expr, expr);
        }
        return set_expr;
 }

diff --git a/src/payload.c b/src/payload.c
index a38f5bf730d156ec2a4c51fa26f3a16f0b5b46c8..162367eb7fd0df075ef8fc8a602faa7ad1340030 100644 (file)
--- a/src/payload.c
+++ b/src/payload.c
@@ -1534,13 +1534,13 @@ __payload_gen_icmp_echo_dependency(struct eval_ctx *ctx, const struct expr *expr
                                    BYTEORDER_BIG_ENDIAN, BITS_PER_BYTE,
                                    constant_data_ptr(echo, BITS_PER_BYTE));
        right = set_elem_expr_alloc(&expr->location, right);
-       compound_expr_add(set, right);
+       set_expr_add(set, right);
 
        right = constant_expr_alloc(&expr->location, icmp_type,
                                    BYTEORDER_BIG_ENDIAN, BITS_PER_BYTE,
                                    constant_data_ptr(reply, BITS_PER_BYTE));
        right = set_elem_expr_alloc(&expr->location, right);
-       compound_expr_add(set, right);
+       set_expr_add(set, right);
 
        dep = relational_expr_alloc(&expr->location, OP_IMPLICIT, left, set);
        return expr_stmt_alloc(&dep->location, dep);
@@ -1571,7 +1571,7 @@ __payload_gen_icmp6_addr_dependency(struct eval_ctx *ctx, const struct expr *exp
                                            constant_data_ptr(icmp_addr_types[i],
                                                              BITS_PER_BYTE));
                right = set_elem_expr_alloc(&expr->location, right);
-               compound_expr_add(set, right);
+               set_expr_add(set, right);
        }
 
        dep = relational_expr_alloc(&expr->location, OP_IMPLICIT, left, set);

diff --git a/src/segtree.c b/src/segtree.c
index 607f002f181ec10513df41aa7d79f034837c070f..9395b5388507afb60e4898d54affad0b465b1772 100644 (file)
--- a/src/segtree.c
+++ b/src/segtree.c
@@ -64,7 +64,7 @@ static void set_elem_add(const struct set *set, struct expr *init, mpz_t value,
        expr = set_elem_expr_alloc(&internal_location, expr);
        expr->flags = flags;
 
-       compound_expr_add(init, expr);
+       set_expr_add(init, expr);
 }
 
 struct expr *get_set_intervals(const struct set *set, const struct expr *init)
@@ -86,12 +86,12 @@ struct expr *get_set_intervals(const struct set *set, const struct expr *init)
                                     i->flags, byteorder);
                        break;
                case EXPR_CONCAT:
-                       compound_expr_add(new_init, expr_clone(i));
+                       set_expr_add(new_init, expr_clone(i));
                        i->flags |= EXPR_F_INTERVAL_END;
-                       compound_expr_add(new_init, expr_clone(i));
+                       set_expr_add(new_init, expr_clone(i));
                        break;
                case EXPR_SET_ELEM_CATCHALL:
-                       compound_expr_add(new_init, expr_clone(i));
+                       set_expr_add(new_init, expr_clone(i));
                        break;
                default:
                        range_expr_value_low(low, i);
@@ -214,16 +214,16 @@ static void set_compound_expr_add(struct expr *compound, struct expr *expr, stru
        switch (expr->etype) {
        case EXPR_SET_ELEM:
                list_splice_init(&orig->stmt_list, &expr->stmt_list);
-               compound_expr_add(compound, expr);
+               set_expr_add(compound, expr);
                break;
        case EXPR_MAPPING:
                list_splice_init(&orig->left->stmt_list, &expr->left->stmt_list);
-               compound_expr_add(compound, expr);
+               set_expr_add(compound, expr);
                break;
        default:
                elem = set_elem_expr_alloc(&orig->location, expr);
                list_splice_init(&orig->stmt_list, &elem->stmt_list);
-               compound_expr_add(compound, elem);
+               set_expr_add(compound, elem);
                break;
        }
 }
@@ -551,7 +551,7 @@ add_interval(struct expr *set, struct expr *low, struct expr *i)
        } else
                expr = interval_to_range(low, i, range);
 
-       compound_expr_add(set, expr);
+       set_expr_add(set, expr);
 
        mpz_clear(range);
        mpz_clear(p);
@@ -645,7 +645,7 @@ void interval_map_decompose(struct expr *set)
        mpz_bitmask(i->value, i->len);
 
        if (!mpz_cmp(i->value, expr_value(low)->value)) {
-               compound_expr_add(set, low);
+               set_expr_add(set, low);
        } else {
                add_interval(set, low, i);
                expr_free(low);
@@ -656,7 +656,7 @@ void interval_map_decompose(struct expr *set)
 out:
        if (catchall) {
                catchall->flags |= EXPR_F_KERNEL;
-               compound_expr_add(set, catchall);
+               set_expr_add(set, catchall);
        }
 
        free(ranges);