- Bird-users - Mailing Lists

[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

[RFC PATCH 03/20] add new symbol flags for typed symbols
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/conf.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/conf/conf.h b/conf/conf.h index 6029fee2..39015e62 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -156,7 +156,11 @@ struct sym_scope { #define SYM_VAL(s) ((s)->val->val) /* Symbol flags */ -#define SYM_FLAG_SAME 0x1 /* For SYM_FUNCTION and SYM_FILTER */ +#define SYM_FLAG_SAME 0x1 /* For SYM_FUNCTION and SYM_FILTER */ +#define SYM_FLAG_IS_TYPED 0x2 /* This is a net_typed symbol */ +#define SYM_FLAG_DO_ADAPT 0x4 /* Tihis symbol must be adapted */ + +#define SYM_FLAGS_TYPED (SYM_FLAG_IS_TYPED | SYM_FLAG_DO_ADAPT) struct include_file_stack { void *buffer; /* Internal lexer state */ -- 2.24.0

1 0

[RFC PATCH 02/20] make symbol types maskable
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- conf/conf.h | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/conf/conf.h b/conf/conf.h index 21dc3fa1..6029fee2 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -138,18 +138,20 @@ struct sym_scope { /* Remember to update cf_symbol_class_name() */ #define SYM_VOID 0 -#define SYM_PROTO 1 -#define SYM_TEMPLATE 2 -#define SYM_FUNCTION 3 -#define SYM_FILTER 4 -#define SYM_TABLE 5 -#define SYM_ATTRIBUTE 6 +#define SYM_PROTO 0x1 +#define SYM_TEMPLATE 0x2 +#define SYM_FUNCTION 0x4 +#define SYM_FILTER 0x8 +#define SYM_TABLE 0x10 +#define SYM_ATTRIBUTE 0x20 #define SYM_VARIABLE 0x100 /* 0x100-0x1ff are variable types */ #define SYM_VARIABLE_RANGE SYM_VARIABLE ... (SYM_VARIABLE | 0xff) #define SYM_CONSTANT 0x200 /* 0x200-0x2ff are variable types */ #define SYM_CONSTANT_RANGE SYM_CONSTANT ... (SYM_CONSTANT | 0xff) +#define SYM_TYPEABLE (SYM_CONSTANT | SYM_FUNCTION | SYM_FILTER) + #define SYM_TYPE(s) ((s)->val->type) #define SYM_VAL(s) ((s)->val->val) -- 2.24.0

1 0

[RFC PATCH 01/20] add NET_ANY
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- lib/net.c | 1 + lib/net.h | 1 + 2 files changed, 2 insertions(+) diff --git a/lib/net.c b/lib/net.c index 976ddbcc..2440506e 100644 --- a/lib/net.c +++ b/lib/net.c @@ -6,6 +6,7 @@ const char * const net_label[] = { + [NET_ANY] = "any", [NET_IP4] = "ipv4", [NET_IP6] = "ipv6", [NET_VPN4] = "vpn4", diff --git a/lib/net.h b/lib/net.h index 0cd5f735..fe55d1b5 100644 --- a/lib/net.h +++ b/lib/net.h @@ -13,6 +13,7 @@ #include "lib/ip.h" +#define NET_ANY 0 #define NET_IP4 1 #define NET_IP6 2 #define NET_VPN4 3 -- 2.24.0

1 0

[PATCH] use net_*_match consistently
by Asbjørn Sloth Tønnesen 30 Dec '19

30 Dec '19

--- lib/net.h | 9 +++++---- nest/rt-table.c | 2 +- proto/mrt/mrt.c | 3 +-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/net.h b/lib/net.h index 0cd5f735..102cbfb0 100644 --- a/lib/net.h +++ b/lib/net.h @@ -38,6 +38,7 @@ #define NB_IP (NB_IP4 | NB_IP6) #define NB_VPN (NB_VPN4 | NB_VPN6) +#define NB_ROA (NB_ROA4 | NB_ROA6) #define NB_FLOW (NB_FLOW4 | NB_FLOW6) #define NB_DEST (NB_IP | NB_IP6_SADR | NB_VPN | NB_MPLS) #define NB_ANY 0xffffffff @@ -257,16 +258,16 @@ static inline int net_type_match(const net_addr *a, u32 mask) { return net_val_match(a->type, mask); } static inline int net_is_ip(const net_addr *a) -{ return (a->type == NET_IP4) || (a->type == NET_IP6); } +{ return net_type_match(a, NB_IP); } static inline int net_is_vpn(const net_addr *a) -{ return (a->type == NET_VPN4) || (a->type == NET_VPN6); } +{ return net_type_match(a, NB_VPN); } static inline int net_is_roa(const net_addr *a) -{ return (a->type == NET_ROA4) || (a->type == NET_ROA6); } +{ return net_type_match(a, NB_ROA); } static inline int net_is_flow(const net_addr *a) -{ return (a->type == NET_FLOW4) || (a->type == NET_FLOW6); } +{ return net_type_match(a, NB_FLOW); } static inline int net_is_sadr(const net_addr *a) { return (a->type == NET_IP6_SADR); } diff --git a/nest/rt-table.c b/nest/rt-table.c index 4adc278e..d2800584 100644 --- a/nest/rt-table.c +++ b/nest/rt-table.c @@ -2186,7 +2186,7 @@ rt_new_table(struct symbol *s, uint addr_type) /* Hack that allows to 'redefine' the master table */ if ((s->class == SYM_TABLE) && (s->table == new_config->def_tables[addr_type]) && - ((addr_type == NET_IP4) || (addr_type == NET_IP6))) + net_val_match(addr_type, NB_IP)) return s->table; struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config)); diff --git a/proto/mrt/mrt.c b/proto/mrt/mrt.c index 7a396a84..258f8470 100644 --- a/proto/mrt/mrt.c +++ b/proto/mrt/mrt.c @@ -227,8 +227,7 @@ mrt_next_table_(rtable *tab, rtable *tab_ptr, const char *pattern) for (tab = !tab ? HEAD(routing_tables) : NODE_NEXT(tab); NODE_VALID(tab); tab = NODE_NEXT(tab)) - if (patmatch(pattern, tab->name) && - ((tab->addr_type == NET_IP4) || (tab->addr_type == NET_IP6))) + if (patmatch(pattern, tab->name) && net_val_match(tab->addr_type, NB_IP)) return tab; return NULL; -- 2.24.0

1 0

Redistribution of BGP path via OSPF
by Nico Schottelius 29 Dec '19

29 Dec '19

Good morning, we have setup OSPF internally to redistribute all of our routes and it seems that we lose the as path on the way: BGP OSPF BGP upstream1 -- router1.place6 --- router2.place5 --- upstream2 | | BGP internal peer The routes that are announced by router2.place5 do not contain the AS path of the "internal peer" anymore, as shows the output of router2.place5: bird> show route all XX::/48 Table master6: XX::/48 unicast [ospf_v6 12:01:06.457] E2 (150/5/10000) [147.78.195.251] via fe80::21b:21ff:febc:7c80 on bond0.8 Type: OSPF-E2 univ OSPF.metric1: 5 OSPF.metric2: 10000 OSPF.tag: 0x00000000 OSPF.router_id: 147.78.195.251 This way, when we re-announce XX::/48 to upstream2, it looks like as if we announce that from our ASN, instead of the ASN from the internal peer. At the moment we export all routes via OSPF, internal and external. How do I tell ospf to forward (tag?) the externally received bgp routes and use that information on the other site? Best regards, Nico -- Modern, affordable, Swiss Virtual Machines. Visit www.datacenterlight.ch

2 2