December 2019 - Bird-users

[RFC PATCH 14/20] adapt infrastructure
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/adapt.c | 107 ++++++++++++++++++++++++++++++++++++++++++++++++ filter/decl.m4 | 33 +++++++++++++++ filter/f-inst.c | 24 ++++++++++- filter/filter.h | 11 +++++ 4 files changed, 173 insertions(+), 2 deletions(-) diff --git a/filter/adapt.c b/filter/adapt.c index 13c090da..76367521 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -41,3 +41,110 @@ filter_validate_function(struct symbol *sym) if (f_has_typed_symbols(sym->function)) sym->flags |= SYM_FLAG_DO_ADAPT; } + +struct f_tree * +filter_tree_adapt(struct f_tree *t, const struct f_context ctx) +{ + if (!filter_tree_has_typed_symbols(t)) + return t; + + struct f_tree *rt = cfg_allocz(sizeof(struct f_tree)); + memcpy(rt, t, sizeof(struct f_tree)); + + if (filter_tree_has_typed_symbols(t->left)) + rt->left = filter_tree_adapt(t->left, ctx); + + if (filter_tree_has_typed_symbols(t->right)) + rt->right = filter_tree_adapt(t->right, ctx); + + if (t->data && f_has_typed_symbols(t->data)) + rt->data = filter_adapt_line(t->data, ctx); + + return rt; +} + +struct symbol * +filter_adapt_function(struct symbol *sym, const struct f_context ctx) +{ + const struct f_line *line; + struct symbol *tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (tsym) { + if (tsym->flags & SYM_FLAG_DO_ADAPT) { + line = tsym->function; + } else { + return tsym; + } + } else if (sym->flags & SYM_FLAG_IS_TYPED && !(sym->flags & SYM_FLAG_DO_ADAPT)) { + cf_error("function %s is not defined for %s", sym->name, net_label[ctx.net_type]); + } else if (new_config) { + tsym = cf_define_typed_symbol(sym, SYM_FUNCTION, function, NULL, ctx.net_type); + line = sym->function; + } else { + tsym = cfg_allocz(sizeof(struct symbol)); + tsym->class = SYM_FUNCTION; + tsym->scope = sym->scope; + tsym->net_type = ctx.net_type; + line = sym->function; + } + tsym->function = filter_adapt_line(line, ctx); + tsym->flags &= ~SYM_FLAG_DO_ADAPT; + return tsym; +} + +const struct filter * +filter_adapt(const struct filter *filter, const struct f_context ctx) +{ + if (is_pseudo_filter(filter)) + return filter; + + const struct f_line *line = filter->root; + struct symbol *sym = filter->sym; + struct symbol *tsym; + + if (line && !f_has_typed_symbols(line)) + return filter; + + if (sym) { + tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (tsym) { + line = tsym->filter->root; + if (!f_has_typed_symbols(line)) + return tsym->filter; + sym = tsym; + } else if (sym->flags & SYM_FLAG_IS_TYPED && !(sym->flags & SYM_FLAG_DO_ADAPT)) { + cf_error("filter %s is not defined for %s", sym->name, net_label[ctx.net_type]); + } else { + sym->flags |= SYM_FLAG_DO_ADAPT; + } + } + + struct filter *f = cfg_allocz(sizeof(struct filter)); + f->root = filter_adapt_line(line, ctx); + + if (f_has_typed_symbols(f->root)) + cf_error("failed to adapt the filter properly"); + + if (sym) { + if (tsym) + tsym->filter = f; + else if (new_config) + f->sym = cf_define_typed_symbol(sym, SYM_FILTER, filter, + f, ctx.net_type); + } + + return f; +} + +void +filters_adapt(const struct filter *(*filters)[NET_MAX], const struct filter *f, const u32 mask, const struct config *cfg) +{ + for (int net_type=1; net_type<NET_MAX; net_type++) { + if (net_val_match(net_type, mask)) { + struct f_context f_ctx = { + .net_type = net_type, + .cfg = cfg, + }; + (*filters)[net_type] = filter_adapt(f, f_ctx); + } + } +} diff --git a/filter/decl.m4 b/filter/decl.m4 index 23024d35..81b07bbe 100644 --- a/filter/decl.m4 +++ b/filter/decl.m4 @@ -41,6 +41,7 @@ m4_divert(-1)m4_dnl # 107 struct f_line_item content # 108 interpreter body # 109 f_has_typed_symbls +# 110 filter_adapt_line # # Here are macros to allow you to _divert to the right directions. m4_define(FID_STRUCT_IN, `m4_divert(101)') @@ -52,6 +53,7 @@ m4_define(FID_SAME_BODY, `m4_divert(106)') m4_define(FID_LINE_IN, `m4_divert(107)') m4_define(FID_INTERPRET_BODY, `m4_divert(108)') m4_define(FID_HAS_TYPED_BODY, `m4_divert(109)') +m4_define(FID_ADAPT_BODY, `m4_divert(110)') # Sometimes you want slightly different code versions in different # outputs. @@ -210,6 +212,9 @@ FID_SAME_BODY()m4_dnl if (!f_same(f1->fl$1, f2->fl$1)) return 0; FID_HAS_TYPED_BODY()m4_dnl if (f_has_typed_symbols(item->fl$1)) return 1; +FID_ADAPT_BODY()m4_dnl +if (f_has_typed_symbols(item->fl$1)) + item->fl$1 = filter_adapt_line(item->fl$1, ctx); FID_INTERPRET_EXEC()m4_dnl do { if (whati->fl$1) { LINEX_(whati->fl$1); @@ -265,6 +270,7 @@ m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access # 8 linearize # 9 same (filter comparator) # 10 f_has_typed_symbols +# 11 filter_adapt_line # 1 union in struct f_inst # 3 constructors + interpreter # @@ -286,6 +292,7 @@ m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)') m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)') m4_define(FID_SAME, `FID_ZONE(9, Comparison)') m4_define(FID_HAS_TYPED, `FID_ZONE(10, Has typed symbol)') +m4_define(FID_ADAPT, `FID_ZONE(11, Adapt filter line)') # This macro does all the code wrapping. See inline comments. m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[ @@ -380,6 +387,13 @@ m4_undivert(109)m4_dnl #undef item break; +FID_ADAPT()m4_dnl This code checks if a f_line used typed symbols +case INST_NAME(): +#define item (&(fl_item->i_]]INST_NAME()[[)) +m4_undivert(110)m4_dnl +#undef item +break; + m4_divert(-1)FID_FLUSH(101,200)m4_dnl And finally this flushes all the unused diversions ]])') @@ -605,6 +619,25 @@ FID_WR_PUT(10) return 0; } +/* adapt f_line to a specific context */ +struct f_line * +filter_adapt_line(const struct f_line *in, const struct f_context ctx) +{ + size_t sz = sizeof(struct f_line) + sizeof(struct f_line_item)*in->len; + struct f_line *out = cfg_allocz(sz); + memcpy(out, in, sz); + for (uint i=0; i<out->len; i++) { + struct f_line_item *fl_item = &out->items[i]; + struct symbol *sym; + struct symbol *tsym; + + switch (fl_item->fi_code) { +FID_WR_PUT(11) + } + } + return out; +} + #if defined(__GNUC__) && __GNUC__ >= 6 #pragma GCC diagnostic pop #endif diff --git a/filter/f-inst.c b/filter/f-inst.c index 46354aa2..7e4043d3 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -27,13 +27,18 @@ * stack; e.g. the + operation just takes two arguments from the value * stack and puts the result on there. * - * 3 Interpret + * 3 Adaptation + * The filter is adapted to the context in which it's being attached. + * In this step we make sure that all symbols involved is typed + * appropriately. + * + * 4 Interpret * The given line is put on a custom execution stack. If needed (FI_CALL, * FI_SWITCH, FI_AND, FI_OR, FI_CONDITION, ...), another line is put on top * of the stack; when that line finishes, the execution continues on the * older lines on the stack where it stopped before. * - * 4 Same + * 5 Same * On config reload, the filters have to be compared whether channel * reload is needed or not. The comparison is done by comparing the * struct f_line's recursively. @@ -445,6 +450,15 @@ FID_HAS_TYPED_BODY() return 1; + FID_ADAPT_BODY() + sym = item->sym; + tsym = cf_find_typed_symbol(adapt_config, sym->name, ctx.net_type); + if (!tsym) + cf_error("constant %s is not defined for %s", sym->name, net_label[ctx.net_type]); + fl_item->fi_code = FI_CONSTANT; + #define new_item (&(fl_item->i_FI_CONSTANT)) + new_item->val = *(tsym->val); + #undef new_item FID_INTERPRET_BODY() runtime("FI_TYPED_CONSTANT can't be interpreted", sym); } @@ -940,6 +954,9 @@ FID_HAS_TYPED_BODY() if (item->sym->flags & SYM_FLAGS_TYPED) return 1; + FID_ADAPT_BODY() + if (item->sym->flags & SYM_FLAGS_TYPED) + item->sym = filter_adapt_function(item->sym, ctx); FID_INTERPRET_BODY() /* Push the body on stack */ @@ -971,6 +988,9 @@ FID_HAS_TYPED_BODY() if (filter_tree_has_typed_symbols(item->tree)) return 1; + FID_ADAPT_BODY() + if (filter_tree_has_typed_symbols(item->tree)) + item->tree = filter_tree_adapt(item->tree, ctx); FID_INTERPRET_BODY() const struct f_tree *t = find_tree(tree, &v1); diff --git a/filter/filter.h b/filter/filter.h index 33c452e8..fcd12a3d 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -51,6 +51,11 @@ struct filter { const struct f_line *root; }; +struct f_context { + const u8 net_type; + const struct config *cfg; +}; + struct rte; enum filter_return f_run(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, int flags); @@ -66,6 +71,12 @@ int f_same(const struct f_line *f1, const struct f_line *f2); int f_has_typed_symbols(const struct f_line *line); int filter_tree_has_typed_symbols(const struct f_tree *t); void filter_validate_function(struct symbol *sym); +const struct filter *filter_adapt(const struct filter *filter, const struct f_context ctx); +void filters_adapt(const struct filter *(*filters)[NET_MAX], const struct filter *f, const u32 mask, const struct config *cfg); +struct f_tree *filter_tree_adapt(struct f_tree *t, const struct f_context ctx); +struct symbol *filter_adapt_function(struct symbol *sym, const struct f_context ctx); +struct f_line *filter_adapt_line(const struct f_line *in, const struct f_context ctx); +#define adapt_config (ctx.cfg ? ctx.cfg : new_config) void filter_commit(struct config *new, struct config *old); -- 2.24.0

1 0

[RFC PATCH 13/20] use FI_TYPED_CONSTANT for typed constants
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/config.Y | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/filter/config.Y b/filter/config.Y index caca0d2b..a7d1dd9b 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -881,8 +881,11 @@ symbol_value: CF_SYM_KNOWN { switch ($1->class) { case SYM_CONSTANT_RANGE: - $$ = f_new_inst(FI_CONSTANT, *($1->val)); - break; + if ($1->flags & SYM_FLAG_IS_TYPED) + $$ = f_new_inst(FI_TYPED_CONSTANT, $1); + else + $$ = f_new_inst(FI_CONSTANT, *($1->val)); + break; case SYM_VARIABLE_RANGE: $$ = f_new_inst(FI_VAR_GET, $1); break; -- 2.24.0

1 0

[RFC PATCH 12/20] force consistent number of function arguments
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/cf-lex.l | 1 + conf/conf.h | 1 + filter/adapt.c | 5 +++++ filter/config.Y | 2 ++ 4 files changed, 9 insertions(+) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index 9b7df0b2..ab984dca 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -677,6 +677,7 @@ cf_type_symbol(struct symbol *sym, const int class, const u8 net_type) sym->class = class; sym->flags |= SYM_FLAG_IS_TYPED; + typed->parent = sym; cf_assert(typed->scope == new_config->root_scope, "wrong scope for typed symbol"); diff --git a/conf/conf.h b/conf/conf.h index 0104d070..c3031a65 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -112,6 +112,7 @@ extern int (*cf_read_hook)(byte *buf, uint max, int fd); struct symbol { node n; /* In list of symbols in config */ struct symbol *next; + struct symbol *parent; /* for parent of typed symbol */ struct sym_scope *scope; int class; /* SYM_* */ u8 net_type; /* Routing table network type (NET_*), 0 for undefined */ diff --git a/filter/adapt.c b/filter/adapt.c index cb43177d..13c090da 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -33,6 +33,11 @@ filter_tree_has_typed_symbols(const struct f_tree *t) void filter_validate_function(struct symbol *sym) { + const struct symbol *parent = sym->parent; + if (parent && parent->function->args != sym->function->args) + cf_error("Incorrent amount of arguments in definition of %s:%s", + sym->name, net_label[sym->net_type]); + if (f_has_typed_symbols(sym->function)) sym->flags |= SYM_FLAG_DO_ADAPT; } diff --git a/filter/config.Y b/filter/config.Y index 1caef0fc..caca0d2b 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -615,6 +615,8 @@ function_def: $5->args = $4; $2->function = $5; cf_pop_scope(); + if ($2->parent && !$2->parent->function) + $2->parent->function = $5; filter_validate_function($2); } ; -- 2.24.0

1 0

[RFC PATCH 11/20] check if functions need to be adapted
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/adapt.c | 7 +++++++ filter/config.Y | 1 + filter/filter.h | 1 + 3 files changed, 9 insertions(+) diff --git a/filter/adapt.c b/filter/adapt.c index b1223169..cb43177d 100644 --- a/filter/adapt.c +++ b/filter/adapt.c @@ -29,3 +29,10 @@ filter_tree_has_typed_symbols(const struct f_tree *t) return 0; } + +void +filter_validate_function(struct symbol *sym) +{ + if (f_has_typed_symbols(sym->function)) + sym->flags |= SYM_FLAG_DO_ADAPT; +} diff --git a/filter/config.Y b/filter/config.Y index c8b868af..1caef0fc 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -615,6 +615,7 @@ function_def: $5->args = $4; $2->function = $5; cf_pop_scope(); + filter_validate_function($2); } ; diff --git a/filter/filter.h b/filter/filter.h index 7c4b0ae9..33c452e8 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -65,6 +65,7 @@ int f_same(const struct f_line *f1, const struct f_line *f2); int f_has_typed_symbols(const struct f_line *line); int filter_tree_has_typed_symbols(const struct f_tree *t); +void filter_validate_function(struct symbol *sym); void filter_commit(struct config *new, struct config *old); -- 2.24.0

1 0

[RFC PATCH 10/20] show symbol flags in dump filter all
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index 2e3ae8ba..3e9660f8 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -486,13 +486,17 @@ void filters_dump_all(void) WALK_LIST(sym, config->symbols) { switch (sym->class) { case SYM_FILTER: - debug("Named filter %s:\n", sym->name); - f_dump_line(sym->filter->root, 1); - break; + debug("Named filter %s<%s>:\n", sym->name, net_label[sym->net_type]); + if (sym->flags & SYM_FLAG_IS_TYPED) debug(" Flag: IS TYPED\n"); + if (sym->flags & SYM_FLAG_DO_ADAPT) debug(" Flag: DO ADAPT\n"); + f_dump_line(sym->filter->root, 1); + break; case SYM_FUNCTION: - debug("Function %s:\n", sym->name); - f_dump_line(sym->function, 1); - break; + debug("Function %s<%s>:\n", sym->name, net_label[sym->net_type]); + if (sym->flags & SYM_FLAG_IS_TYPED) debug(" Flag: IS TYPED\n"); + if (sym->flags & SYM_FLAG_DO_ADAPT) debug(" Flag: DO ADAPT\n"); + f_dump_line(sym->function, 1); + break; case SYM_PROTO: { debug("Protocol %s:\n", sym->name); -- 2.24.0

1 0

[RFC PATCH 09/20] use net_type when looking up symbols in SYM_FLAG_SAME check
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index b8147662..2e3ae8ba 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -461,7 +461,7 @@ filter_commit(struct config *new, struct config *old) WALK_LIST(sym, new->symbols) switch (sym->class) { case SYM_FUNCTION: - if ((osym = cf_find_symbol(old, sym->name)) && + if ((osym = cf_find_typed_symbol(old, sym->name, sym->net_type)) && (osym->class == SYM_FUNCTION) && f_same(sym->function, osym->function)) sym->flags |= SYM_FLAG_SAME; @@ -470,7 +470,7 @@ filter_commit(struct config *new, struct config *old) break; case SYM_FILTER: - if ((osym = cf_find_symbol(old, sym->name)) && + if ((osym = cf_find_typed_symbol(old, sym->name, sym->net_type)) && (osym->class == SYM_FILTER) && f_same(sym->filter->root, osym->filter->root)) sym->flags |= SYM_FLAG_SAME; -- 2.24.0

1 0

[RFC PATCH 08/20] add f_has_typed_symbols helper function
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/Makefile | 2 +- filter/adapt.c | 31 +++++++++++++++++++++++++++++++ filter/decl.m4 | 44 ++++++++++++++++++++++++++++++++++++-------- filter/f-inst.c | 9 +++++++++ filter/filter.h | 3 +++ 5 files changed, 80 insertions(+), 9 deletions(-) create mode 100644 filter/adapt.c diff --git a/filter/Makefile b/filter/Makefile index c2062534..633960b2 100644 --- a/filter/Makefile +++ b/filter/Makefile @@ -1,4 +1,4 @@ -src := filter.c data.c f-util.c tree.c trie.c inst-gen.c +src := filter.c data.c f-util.c tree.c trie.c inst-gen.c adapt.c obj := $(src-o-files) $(all-daemon) $(cf-local) diff --git a/filter/adapt.c b/filter/adapt.c new file mode 100644 index 00000000..b1223169 --- /dev/null +++ b/filter/adapt.c @@ -0,0 +1,31 @@ +/* + * Filters: adaptation functions + * + * Copyright 1998 Pavel Machek <pavel(a)ucw.cz> + * + * Can be freely distributed and used under the terms of the GNU GPL. + */ + +#undef LOCAL_DEBUG + +#include "lib/net.h" +#include "filter/filter.h" +#include "filter/f-inst.h" + +int +filter_tree_has_typed_symbols(const struct f_tree *t) +{ + if (t == NULL) + return 0; + + if (filter_tree_has_typed_symbols(t->left)) + return 1; + + if (filter_tree_has_typed_symbols(t->right)) + return 1; + + if (t->data && f_has_typed_symbols(t->data)) + return 1; + + return 0; +} diff --git a/filter/decl.m4 b/filter/decl.m4 index a78450a3..23024d35 100644 --- a/filter/decl.m4 +++ b/filter/decl.m4 @@ -40,6 +40,7 @@ m4_divert(-1)m4_dnl # 106 comparator body # 107 struct f_line_item content # 108 interpreter body +# 109 f_has_typed_symbls # # Here are macros to allow you to _divert to the right directions. m4_define(FID_STRUCT_IN, `m4_divert(101)') @@ -50,6 +51,7 @@ m4_define(FID_LINEARIZE_BODY, `m4_divert(105)') m4_define(FID_SAME_BODY, `m4_divert(106)') m4_define(FID_LINE_IN, `m4_divert(107)') m4_define(FID_INTERPRET_BODY, `m4_divert(108)') +m4_define(FID_HAS_TYPED_BODY, `m4_divert(109)') # Sometimes you want slightly different code versions in different # outputs. @@ -206,6 +208,8 @@ FID_LINEARIZE_BODY()m4_dnl item->fl$1 = f_linearize(whati->f$1); FID_SAME_BODY()m4_dnl if (!f_same(f1->fl$1, f2->fl$1)) return 0; +FID_HAS_TYPED_BODY()m4_dnl +if (f_has_typed_symbols(item->fl$1)) return 1; FID_INTERPRET_EXEC()m4_dnl do { if (whati->fl$1) { LINEX_(whati->fl$1); @@ -254,14 +258,15 @@ m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access # into appropriate headers and structures and saves them into global # diversions listed: # -# 4 enum fi_code -# 5 enum fi_code to string -# 6 dump line item -# 7 dump line item callers -# 8 linearize -# 9 same (filter comparator) -# 1 union in struct f_inst -# 3 constructors + interpreter +# 4 enum fi_code +# 5 enum fi_code to string +# 6 dump line item +# 7 dump line item callers +# 8 linearize +# 9 same (filter comparator) +# 10 f_has_typed_symbols +# 1 union in struct f_inst +# 3 constructors + interpreter # # These global diversions contain blocks of code that can be directly # put into the final file, yet it still can't be written out now as @@ -280,6 +285,7 @@ m4_define(FID_DUMP, `FID_ZONE(6, Dump line)') m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)') m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)') m4_define(FID_SAME, `FID_ZONE(9, Comparison)') +m4_define(FID_HAS_TYPED, `FID_ZONE(10, Has typed symbol)') # This macro does all the code wrapping. See inline comments. m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[ @@ -367,6 +373,13 @@ m4_undivert(106)m4_dnl #undef f2 break; +FID_HAS_TYPED()m4_dnl This code checks if a f_line used typed symbols +case INST_NAME(): +#define item (&(fl_item->i_]]INST_NAME()[[)) +m4_undivert(109)m4_dnl +#undef item +break; + m4_divert(-1)FID_FLUSH(101,200)m4_dnl And finally this flushes all the unused diversions ]])') @@ -577,6 +590,21 @@ FID_WR_PUT(9) return 1; } +/* Does this line refer to any typed symbols? */ +int +f_has_typed_symbols(const struct f_line *fl) +{ + if (fl == NULL) return 0; + + for (uint i=0; i<fl->len; i++) { + const struct f_line_item *fl_item = &fl->items[i]; + switch (fl_item->fi_code) { +FID_WR_PUT(10) + } + } + return 0; +} + #if defined(__GNUC__) && __GNUC__ >= 6 #pragma GCC diagnostic pop #endif diff --git a/filter/f-inst.c b/filter/f-inst.c index 37fa0f39..46354aa2 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -443,6 +443,8 @@ NEVER_CONSTANT; RESULT_TYPE(sym->class & 0xff); + FID_HAS_TYPED_BODY() + return 1; FID_INTERPRET_BODY() runtime("FI_TYPED_CONSTANT can't be interpreted", sym); } @@ -935,6 +937,9 @@ FID_SAME_BODY() if (!(f1->sym->flags & SYM_FLAG_SAME)) return 0; + FID_HAS_TYPED_BODY() + if (item->sym->flags & SYM_FLAGS_TYPED) + return 1; FID_INTERPRET_BODY() /* Push the body on stack */ @@ -963,6 +968,10 @@ ARG_ANY(1); FID_MEMBER(struct f_tree *, tree, [[!same_tree(f1->tree, f2->tree)]], "tree %p", item->tree); + FID_HAS_TYPED_BODY() + if (filter_tree_has_typed_symbols(item->tree)) + return 1; + FID_INTERPRET_BODY() const struct f_tree *t = find_tree(tree, &v1); if (!t) { diff --git a/filter/filter.h b/filter/filter.h index 84b6b0be..7c4b0ae9 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -63,6 +63,9 @@ const char *filter_name(const struct filter *filter); int filter_same(const struct filter *new, const struct filter *old); int f_same(const struct f_line *f1, const struct f_line *f2); +int f_has_typed_symbols(const struct f_line *line); +int filter_tree_has_typed_symbols(const struct f_tree *t); + void filter_commit(struct config *new, struct config *old); void filters_dump_all(void); -- 2.24.0

1 0

[RFC PATCH 07/20] add generic pseudo filter check function
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- filter/filter.c | 9 +++++++-- filter/filter.h | 1 + 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/filter/filter.c b/filter/filter.c index e505d570..b8147662 100644 --- a/filter/filter.c +++ b/filter/filter.c @@ -413,6 +413,12 @@ f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf) return fret; } +int +is_pseudo_filter(const struct filter *f) +{ + return f == FILTER_ACCEPT || f == FILTER_REJECT || f == FILTER_UNDEF; +} + /** * filter_same - compare two filters * @new: first filter to be compared @@ -427,8 +433,7 @@ filter_same(const struct filter *new, const struct filter *old) { if (old == new) /* Handle FILTER_ACCEPT and FILTER_REJECT */ return 1; - if (old == FILTER_ACCEPT || old == FILTER_REJECT || - new == FILTER_ACCEPT || new == FILTER_REJECT) + if (is_pseudo_filter(old) || is_pseudo_filter(new)) return 0; if ((!old->sym) && (!new->sym)) diff --git a/filter/filter.h b/filter/filter.h index 9d997efb..84b6b0be 100644 --- a/filter/filter.h +++ b/filter/filter.h @@ -58,6 +58,7 @@ enum filter_return f_eval_rte(const struct f_line *expr, struct rte **rte, struc uint f_eval_int(const struct f_line *expr); enum filter_return f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf); +int is_pseudo_filter(const struct filter *f); const char *filter_name(const struct filter *filter); int filter_same(const struct filter *new, const struct filter *old); int f_same(const struct f_line *f1, const struct f_line *f2); -- 2.24.0

1 0

[RFC PATCH 06/20] add initial FI_TYPED_CONSTANT instruction
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

This instruction will eventually be replaced by FI_CONSTANT. --- filter/f-inst.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/filter/f-inst.c b/filter/f-inst.c index 51a35350..37fa0f39 100644 --- a/filter/f-inst.c +++ b/filter/f-inst.c @@ -438,6 +438,15 @@ RESULT_VAL(fstk->vstk[curline.vbase + sym->offset]); } + INST(FI_TYPED_CONSTANT, 0, 1) { + SYMBOL; + NEVER_CONSTANT; + RESULT_TYPE(sym->class & 0xff); + + FID_INTERPRET_BODY() + runtime("FI_TYPED_CONSTANT can't be interpreted", sym); + } + INST(FI_CONSTANT, 0, 1) { FID_MEMBER( struct f_val, -- 2.24.0

1 0

[RFC PATCH 04/20] add support for defining typed symbols
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/cf-lex.l | 74 +++++++++++++++++++++++++++++++++++++++++-------- conf/conf.h | 37 ++++++++++++++++++++----- conf/confbase.Y | 1 - 3 files changed, 93 insertions(+), 19 deletions(-) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index 1d6cae2c..9b7df0b2 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -73,10 +73,10 @@ static uint cf_hash(const byte *c); #define KW_FN(k) cf_hash(k) #define KW_ORDER 8 /* Fixed */ -#define SYM_KEY(n) n->name, n->scope->active +#define SYM_KEY(n) n->name, n->scope->active, n->net_type #define SYM_NEXT(n) n->next -#define SYM_EQ(a,s1,b,s2) !strcmp(a,b) && s1 == s2 -#define SYM_FN(k,s) cf_hash(k) +#define SYM_EQ(a,s1,t1,b,s2,t2) !strcmp(a,b) && s1 == s2 && t1 == t2 +#define SYM_FN(k,s,t) cf_hash(k) #define SYM_ORDER 6 /* Initial */ #define SYM_REHASH sym_rehash @@ -544,7 +544,7 @@ check_eof(void) } static struct symbol * -cf_new_symbol(const byte *c) +cf_new_symbol(const byte *c, const u8 net_type) { struct symbol *s; @@ -553,7 +553,11 @@ cf_new_symbol(const byte *c) cf_error("Symbol too long"); s = cfg_allocz(sizeof(struct symbol) + l + 1); - *s = (struct symbol) { .scope = conf_this_scope, .class = SYM_VOID, }; + *s = (struct symbol) { + .scope = conf_this_scope, + .class = SYM_VOID, + .net_type = net_type + }; strcpy(s->name, c); if (!new_config->sym_hash.data) @@ -566,6 +570,21 @@ cf_new_symbol(const byte *c) return s; } +struct symbol * +cf_find_typed_symbol(const struct config *cfg, const byte *c, const u8 net_type) +{ + struct symbol *s, *typed; + s = HASH_FIND(cfg->sym_hash, SYM, c, 1, NET_ANY); + if (!s) return NULL; + if (net_type == NET_ANY) return s; + if (!(s->flags & SYM_FLAG_IS_TYPED)) return NULL; + + typed = HASH_FIND(cfg->sym_hash, SYM, c, 1, net_type); + if (!typed) return NULL; + cf_assert(s->scope == typed->scope, "bug: wrong scope"); + return typed; +} + /** * cf_find_symbol - find a symbol by name * @cfg: specificed config @@ -583,13 +602,13 @@ cf_find_symbol(const struct config *cfg, const byte *c) struct symbol *s; if (cfg->sym_hash.data && - (s = HASH_FIND(cfg->sym_hash, SYM, c, 1))) + (s = HASH_FIND(cfg->sym_hash, SYM, c, 1, NET_ANY))) return s; /* In CLI command parsing, fallback points to the current config, otherwise it is NULL. */ if (cfg->fallback && cfg->fallback->sym_hash.data && - (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1))) + (s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1, NET_ANY))) return s; return NULL; @@ -607,7 +626,7 @@ cf_find_symbol(const struct config *cfg, const byte *c) struct symbol * cf_get_symbol(const byte *c) { - return cf_find_symbol(new_config, c) ?: cf_new_symbol(c); + return cf_find_symbol(new_config, c) ?: cf_new_symbol(c, NET_ANY); } /** @@ -625,13 +644,46 @@ cf_localize_symbol(struct symbol *sym) return sym; /* If the scope is the current, it is already defined in this scope. */ - if (sym->scope == conf_this_scope) - cf_error("Symbol already defined"); + if (sym->scope == conf_this_scope) { + if (sym->flags & SYM_FLAGS_TYPED) + return sym; + else + cf_error("Symbol already defined"); + } /* Not allocated here yet, doing it now. */ - return cf_new_symbol(sym->name); + return cf_new_symbol(sym->name, NET_ANY); } +struct symbol * +cf_type_symbol(struct symbol *sym, const int class, const u8 net_type) +{ + if (net_type == NET_ANY) { + if (sym->flags & SYM_FLAG_IS_TYPED) + cf_error("generic definitions not allowed for typed symbol"); + else + return sym; + } + + cf_assert(class & SYM_TYPEABLE, "Symbol not typeable"); + + if (sym->flags & SYM_FLAG_IS_TYPED && sym->class != class) + cf_error("Mixed symbol classes"); + + if (HASH_FIND(new_config->sym_hash, SYM, sym->name, 1, net_type)) + cf_error("Symbol already defined for this channel type"); + + struct symbol *typed = cf_new_symbol(sym->name, net_type); + + sym->class = class; + sym->flags |= SYM_FLAG_IS_TYPED; + + cf_assert(typed->scope == new_config->root_scope, "wrong scope for typed symbol"); + + return typed; +} + + struct symbol * cf_default_name(char *template, int *counter) { diff --git a/conf/conf.h b/conf/conf.h index 39015e62..0104d070 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -15,6 +15,8 @@ #include "lib/resource.h" #include "lib/timer.h" +#define cf_assert(cond, ...) do { if (!(cond)) cf_error(__VA_ARGS__); } while (0) + /* Configuration structure */ struct config { @@ -112,6 +114,7 @@ struct symbol { struct symbol *next; struct sym_scope *scope; int class; /* SYM_* */ + u8 net_type; /* Routing table network type (NET_*), 0 for undefined */ uint flags; /* SYM_FLAG_* */ union { @@ -184,31 +187,51 @@ void cf_lex_init(int is_cli, struct config *c); void cf_lex_unwind(void); struct symbol *cf_find_symbol(const struct config *cfg, const byte *c); +struct symbol *cf_find_typed_symbol(const struct config *cfg, const byte *c, const u8 net_type); struct symbol *cf_get_symbol(const byte *c); struct symbol *cf_default_name(char *template, int *counter); struct symbol *cf_localize_symbol(struct symbol *sym); +struct symbol *cf_type_symbol(struct symbol *sym, const int class, const u8 net_type); /** - * cf_define_symbol - define meaning of a symbol + * cf_define_typed_symbol - define meaning of a symbol * @sym: symbol to be defined * @type: symbol class to assign * @def: class dependent data + * @net_type: NET_* network type * * Defines new meaning of a symbol. If the symbol is an undefined * one (%SYM_VOID), it's just re-defined to the new type. If it's defined * in different scope, a new symbol in current scope is created and the * meaning is assigned to it. If it's already defined in the current scope, - * an error is reported via cf_error(). + * an error is reported via cf_error(). If net_type is not %NET_ANY, a the + * typed version of the symbol will be returned. + * + * Result: Pointer to the newly defined symbol. If we are in the top-level + * scope, it's the same @sym as passed to the function. + */ +#define cf_define_typed_symbol(sym_, type_, var_, def_, net_type_) ({ \ + struct symbol *main_sym = cf_localize_symbol(sym_); \ + struct symbol *typed = cf_type_symbol(main_sym, type_, net_type_); \ + typed->class = type_; \ + typed->var_ = def_; \ + typed; }) + +/** + * cf_define_symbol - define meaning of a symbol + * @sym: symbol to be defined + * @type: symbol class to assign + * @def: class dependent data + * + * This is a simple wrapper around %cf_define_typed_symbol, with + * net_type always passed as %NET_ANY. * * Result: Pointer to the newly defined symbol. If we are in the top-level * scope, it's the same @sym as passed to the function. */ -#define cf_define_symbol(sym_, type_, var_, def_) ({ \ - struct symbol *sym = cf_localize_symbol(sym_); \ - sym->class = type_; \ - sym->var_ = def_; \ - sym; }) +#define cf_define_symbol(sym_, type_, var_, def_) \ + cf_define_typed_symbol(sym_, type_, var_, def_, NET_ANY) void cf_push_scope(struct symbol *); void cf_pop_scope(void); diff --git a/conf/confbase.Y b/conf/confbase.Y index 75158927..eda5b9c1 100644 --- a/conf/confbase.Y +++ b/conf/confbase.Y @@ -33,7 +33,6 @@ check_u16(uint val) cf_error("Value %u out of range (0-65535)", val); } -#define cf_assert(cond, ...) do { if (!(cond)) cf_error(__VA_ARGS__); } while (0) static inline void cf_assert_symbol(const struct symbol *sym, uint class) { switch (class) { case SYM_PROTO: cf_assert(sym->class == SYM_PROTO, "Protocol name required"); break; -- 2.24.0

1 0