From 51f2e7afaf069508685281e8c1b8bb1ceda79d8f Mon Sep 17 00:00:00 2001 From: Maria Matejka Date: Tue, 13 Jun 2023 10:51:03 +0200 Subject: [PATCH] Conf: Symbol manipulation gets its context explicitly --- conf/cf-lex.l | 105 +++++++++++++++++++++------------------------ conf/conf.h | 33 +++++++------- conf/confbase.Y | 2 +- filter/config.Y | 38 ++++++++-------- nest/config.Y | 8 ++-- nest/proto.c | 4 +- nest/rt-table.c | 6 +-- proto/bgp/bgp.c | 4 +- sysdep/unix/main.c | 20 ++++----- 9 files changed, 107 insertions(+), 113 deletions(-) diff --git a/conf/cf-lex.l b/conf/cf-lex.l index fb2ffb32..95237215 100644 --- a/conf/cf-lex.l +++ b/conf/cf-lex.l @@ -78,7 +78,6 @@ static uint cf_hash(const byte *c); HASH_DEFINE_REHASH_FN(SYM, struct symbol) -struct sym_scope *conf_this_scope; struct sym_scope *global_root_scope; static pool *global_root_scope_pool; @@ -555,10 +554,10 @@ check_eof(void) return 0; } -static inline void cf_swap_soft_scope(void); +static inline void cf_swap_soft_scope(struct config *conf); static struct symbol * -cf_new_symbol(const byte *c) +cf_new_symbol(struct sym_scope *scope, pool *p, struct linpool *lp, const byte *c) { struct symbol *s; @@ -566,32 +565,21 @@ cf_new_symbol(const byte *c) if (l > SYM_MAX_LEN) cf_error("Symbol too long"); - cf_swap_soft_scope(); - - pool *p = new_config->pool; - - if (conf_this_scope == global_root_scope) - s = mb_allocz(p = global_root_scope_pool, sizeof(struct symbol) + l + 1); - else - s = cfg_allocz(sizeof(struct symbol) + l + 1); - *s = (struct symbol) { .scope = conf_this_scope, .class = SYM_VOID, }; + s = lp_alloc(lp, sizeof(struct symbol) + l + 1); + *s = (struct symbol) { .scope = scope, .class = SYM_VOID, }; strcpy(s->name, c); - if (!conf_this_scope->hash.data) - HASH_INIT(conf_this_scope->hash, p, SYM_ORDER); + if (!scope->hash.data) + HASH_INIT(scope->hash, p, SYM_ORDER); - HASH_INSERT2(conf_this_scope->hash, SYM, p, s); + HASH_INSERT2(scope->hash, SYM, p, s); - if (conf_this_scope == new_config->root_scope) + if (new_config && (scope == new_config->root_scope)) add_tail(&(new_config->symbols), &(s->n)); return s; } -struct symbol * -cf_symbol_from_keyword(const struct keyword *kw) -{ return cf_new_symbol(kw->name); } - /** * cf_find_symbol_scope - find a symbol by name * @scope: config scope @@ -628,9 +616,12 @@ cf_find_symbol_scope(const struct sym_scope *scope, const byte *c) * existing symbol is found. */ struct symbol * -cf_get_symbol(const byte *c) +cf_get_symbol(struct config *conf, const byte *c) { - return cf_find_symbol_scope(conf_this_scope, c) ?: cf_new_symbol(c); + return cf_find_symbol_scope(conf->current_scope, c) ?: ( + cf_swap_soft_scope(conf), + cf_new_symbol(conf->current_scope, conf->pool, conf->mem, c) + ); } /** @@ -641,22 +632,23 @@ cf_get_symbol(const byte *c) * for purposes of cf_define_symbol(). */ struct symbol * -cf_localize_symbol(struct symbol *sym) +cf_localize_symbol(struct config *conf, struct symbol *sym) { /* If the symbol type is void, it has been recently allocated just in this scope. */ if (!sym->class) return sym; /* If the scope is the current, it is already defined in this scope. */ - if (cf_symbol_is_local(sym)) + if (cf_symbol_is_local(conf, sym)) cf_error("Symbol '%s' already defined", sym->name); /* Not allocated here yet, doing it now. */ - return cf_new_symbol(sym->name); + cf_swap_soft_scope(conf); + return cf_new_symbol(conf->current_scope, conf->pool, conf->mem, sym->name); } struct symbol * -cf_default_name(char *template, int *counter) +cf_default_name(struct config *conf, char *template, int *counter) { char buf[SYM_MAX_LEN]; struct symbol *s; @@ -665,7 +657,7 @@ cf_default_name(char *template, int *counter) for(;;) { bsprintf(buf, template, ++(*counter)); - s = cf_get_symbol(buf); + s = cf_get_symbol(conf, buf); if (s->class == SYM_VOID) return s; if (!perc) @@ -678,7 +670,7 @@ static enum yytokentype cf_lex_symbol(const char *data) { /* Have we defined such a symbol? */ - struct symbol *sym = cf_get_symbol(data); + struct symbol *sym = cf_get_symbol(new_config, data); cf_lval.s = sym; switch (sym->class) @@ -711,10 +703,15 @@ cf_lex_init(int is_cli, struct config *c) if (!global_root_scope_pool) { global_root_scope_pool = rp_new(&root_pool, "Keywords pool"); - conf_this_scope = global_root_scope = mb_allocz(global_root_scope_pool, sizeof(*global_root_scope)); + linpool *kwlp = lp_new(global_root_scope_pool); + global_root_scope = lp_allocz(kwlp, sizeof(*global_root_scope)); for (const struct keyword *k = keyword_list; k->name; k++) - cf_define_symbol(cf_get_symbol(k->name), SYM_KEYWORD, keyword, k); + { + struct symbol *sym = cf_new_symbol(global_root_scope, global_root_scope_pool, kwlp, k->name); + sym->class = SYM_KEYWORD; + sym->keyword = k; + } } ifs_head = ifs = push_ifs(NULL); @@ -733,14 +730,12 @@ cf_lex_init(int is_cli, struct config *c) else BEGIN(INITIAL); - c->root_scope = cfg_allocz(sizeof(struct sym_scope)); - conf_this_scope = c->root_scope; - conf_this_scope->active = 1; + c->root_scope = c->current_scope = cfg_allocz(sizeof(struct sym_scope)); if (is_cli) - conf_this_scope->next = config->root_scope; + c->current_scope->next = config->root_scope; else - conf_this_scope->next = global_root_scope; + c->current_scope->next = global_root_scope; } /** @@ -754,12 +749,12 @@ cf_lex_init(int is_cli, struct config *c) * in all scopes stored on the stack. */ void -cf_push_scope(struct symbol *sym) +cf_push_scope(struct config *conf, struct symbol *sym) { struct sym_scope *s = cfg_allocz(sizeof(struct sym_scope)); - s->next = conf_this_scope; - conf_this_scope = s; + s->next = conf->current_scope; + conf->current_scope = s; s->active = 1; s->name = sym; s->slots = 0; @@ -773,14 +768,14 @@ cf_push_scope(struct symbol *sym) * invisible to the rest of the config. */ void -cf_pop_scope(void) +cf_pop_scope(struct config *conf) { - ASSERT(!conf_this_scope->soft_scopes); + ASSERT(!conf->current_scope->soft_scopes); - conf_this_scope->active = 0; - conf_this_scope = conf_this_scope->next; + conf->current_scope->active = 0; + conf->current_scope = conf->current_scope->next; - ASSERT(conf_this_scope); + ASSERT(conf->current_scope); } /** @@ -791,12 +786,12 @@ cf_pop_scope(void) * Such scope will be converted to a regular scope on first use. */ void -cf_push_soft_scope(void) +cf_push_soft_scope(struct config *conf) { - if (conf_this_scope->soft_scopes < 0xfe) - conf_this_scope->soft_scopes++; + if (conf->current_scope->soft_scopes < 0xfe) + conf->current_scope->soft_scopes++; else - cf_push_block_scope(); + cf_push_block_scope(conf); } /** @@ -805,12 +800,12 @@ cf_push_soft_scope(void) * Leave a soft scope entered by cf_push_soft_scope(). */ void -cf_pop_soft_scope(void) +cf_pop_soft_scope(struct config *conf) { - if (conf_this_scope->soft_scopes) - conf_this_scope->soft_scopes--; + if (conf->current_scope->soft_scopes) + conf->current_scope->soft_scopes--; else - cf_pop_block_scope(); + cf_pop_block_scope(conf); } /** @@ -820,12 +815,12 @@ cf_pop_soft_scope(void) * on first use. It is done automatically by cf_new_symbol(). */ static inline void -cf_swap_soft_scope(void) +cf_swap_soft_scope(struct config *conf) { - if (conf_this_scope->soft_scopes) + if (conf->current_scope->soft_scopes) { - conf_this_scope->soft_scopes--; - cf_push_block_scope(); + conf->current_scope->soft_scopes--; + cf_push_block_scope(conf); } } diff --git a/conf/conf.h b/conf/conf.h index 12f1a6b3..ec8c97e8 100644 --- a/conf/conf.h +++ b/conf/conf.h @@ -54,6 +54,7 @@ struct config { int file_fd; /* File descriptor of main configuration file */ struct sym_scope *root_scope; /* Scope for root symbols */ + struct sym_scope *current_scope; /* Current scope where we are actually in while parsing */ int obstacle_count; /* Number of items blocking freeing of this config */ int shutdown; /* This is a pseudo-config for daemon shutdown */ int gr_down; /* This is a pseudo-config for graceful restart */ @@ -186,8 +187,6 @@ struct include_file_stack { extern struct include_file_stack *ifs; -extern struct sym_scope *conf_this_scope; - int cf_lex(void); void cf_lex_init(int is_cli, struct config *c); void cf_lex_unwind(void); @@ -201,12 +200,12 @@ static inline struct symbol *cf_find_symbol_cfg(const struct config *cfg, const struct sym_scope: cf_find_symbol_scope \ )((where), (what)) -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_get_symbol(struct config *conf, const byte *c); +struct symbol *cf_default_name(struct config *conf, char *template, int *counter); +struct symbol *cf_localize_symbol(struct config *conf, struct symbol *sym); -static inline int cf_symbol_is_local(struct symbol *sym) -{ return (sym->scope == conf_this_scope) && !conf_this_scope->soft_scopes; } +static inline int cf_symbol_is_local(struct config *conf, struct symbol *sym) +{ return (sym->scope == conf->current_scope) && !conf->current_scope->soft_scopes; } /** * cf_define_symbol - define meaning of a symbol @@ -223,22 +222,22 @@ static inline int cf_symbol_is_local(struct symbol *sym) * 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(osym_, type_, var_, def_) ({ \ - struct symbol *sym_ = cf_localize_symbol(osym_); \ +#define cf_define_symbol(conf_, osym_, type_, var_, def_) ({ \ + struct symbol *sym_ = cf_localize_symbol(conf_, osym_); \ sym_->class = type_; \ sym_->var_ = def_; \ sym_; }) -void cf_push_scope(struct symbol *); -void cf_pop_scope(void); -void cf_push_soft_scope(void); -void cf_pop_soft_scope(void); +void cf_push_scope(struct config *, struct symbol *); +void cf_pop_scope(struct config *); +void cf_push_soft_scope(struct config *); +void cf_pop_soft_scope(struct config *); -static inline void cf_push_block_scope(void) -{ cf_push_scope(NULL); conf_this_scope->block = 1; } +static inline void cf_push_block_scope(struct config *conf) +{ cf_push_scope(conf, NULL); conf->current_scope->block = 1; } -static inline void cf_pop_block_scope(void) -{ ASSERT(conf_this_scope->block); cf_pop_scope(); } +static inline void cf_pop_block_scope(struct config *conf) +{ ASSERT(conf->current_scope->block); cf_pop_scope(conf); } char *cf_symbol_class_name(struct symbol *sym); diff --git a/conf/confbase.Y b/conf/confbase.Y index 0c2807dc..df1e038b 100644 --- a/conf/confbase.Y +++ b/conf/confbase.Y @@ -159,7 +159,7 @@ definition: DEFINE symbol '=' term ';' { struct f_val *val = cfg_allocz(sizeof(struct f_val)); *val = cf_eval($4, T_VOID); - cf_define_symbol($2, SYM_CONSTANT | val->type, val, val); + cf_define_symbol(new_config, $2, SYM_CONSTANT | val->type, val, val); } ; diff --git a/filter/config.Y b/filter/config.Y index 58c0c16b..e1eca9a5 100644 --- a/filter/config.Y +++ b/filter/config.Y @@ -377,13 +377,13 @@ CF_GRAMMAR conf: filter_def ; filter_def: - FILTER symbol { $2 = cf_define_symbol($2, SYM_FILTER, filter, NULL); cf_push_scope( $2 ); } + FILTER symbol { $2 = cf_define_symbol(new_config, $2, SYM_FILTER, filter, NULL); cf_push_scope( new_config, $2 ); } filter_body { struct filter *f = cfg_alloc(sizeof(struct filter)); *f = (struct filter) { .sym = $2, .root = $4 }; $2->filter = f; - cf_pop_scope(); + cf_pop_scope(new_config); } ; @@ -394,7 +394,7 @@ filter_eval: conf: custom_attr ; custom_attr: ATTRIBUTE type symbol ';' { - cf_define_symbol($3, SYM_ATTRIBUTE, attribute, ca_lookup(new_config->pool, $3->name, $2)->fda); + cf_define_symbol(new_config, $3, SYM_ATTRIBUTE, attribute, ca_lookup(new_config->pool, $3->name, $2)->fda); }; conf: bt_test_suite ; @@ -469,7 +469,7 @@ function_argsn: | function_argsn type symbol ';' { if ($3->scope->slots >= 0xfe) cf_error("Too many declarations, at most 255 allowed"); $$ = cfg_alloc(sizeof(struct f_arg)); - $$->arg = cf_define_symbol($3, SYM_VARIABLE | $2, offset, sym_->scope->slots++); + $$->arg = cf_define_symbol(new_config, $3, SYM_VARIABLE | $2, offset, sym_->scope->slots++); $$->next = $1; } ; @@ -478,7 +478,7 @@ function_args: '(' ')' { $$ = NULL; } | '(' function_argsn type symbol ')' { $$ = cfg_alloc(sizeof(struct f_arg)); - $$->arg = cf_define_symbol($4, SYM_VARIABLE | $3, offset, sym_->scope->slots++); + $$->arg = cf_define_symbol(new_config, $4, SYM_VARIABLE | $3, offset, sym_->scope->slots++); $$->next = $2; } ; @@ -486,7 +486,7 @@ function_args: function_vars: /* EMPTY */ { $$ = 0; } | function_vars type symbol ';' { - cf_define_symbol($3, SYM_VARIABLE | $2, offset, f_new_var(sym_->scope)); + cf_define_symbol(new_config, $3, SYM_VARIABLE | $2, offset, f_new_var(sym_->scope)); $$ = $1 + 1; } ; @@ -498,12 +498,12 @@ filter: cf_assert_symbol($1, SYM_FILTER); $$ = $1->filter; } - | { cf_push_scope(NULL); } filter_body { + | { cf_push_scope(new_config, NULL); } filter_body { struct filter *f = cfg_alloc(sizeof(struct filter)); *f = (struct filter) { .root = $2 }; $$ = f; - cf_pop_scope(); + cf_pop_scope(new_config); } ; @@ -525,8 +525,8 @@ conf: function_def ; function_def: FUNCTION symbol { DBG( "Beginning of function %s\n", $2->name ); - $2 = cf_define_symbol($2, SYM_FUNCTION, function, NULL); - cf_push_scope($2); + $2 = cf_define_symbol(new_config, $2, SYM_FUNCTION, function, NULL); + cf_push_scope(new_config, $2); } function_args { /* Make dummy f_line for storing function prototype */ struct f_line *dummy = cfg_allocz(sizeof(struct f_line)); @@ -545,7 +545,7 @@ function_def: $6->args = $2->function->args; $6->arg_list = $2->function->arg_list; $2->function = $6; - cf_pop_scope(); + cf_pop_scope(new_config); } ; @@ -555,7 +555,7 @@ cmds: /* EMPTY */ { $$ = NULL; } | cmds_int { $$ = $1.begin; } ; -cmds_scoped: { cf_push_soft_scope(); } cmds { cf_pop_soft_scope(); $$ = $2; } ; +cmds_scoped: { cf_push_soft_scope(new_config); } cmds { cf_pop_soft_scope(new_config); $$ = $2; } ; cmd_var: var | cmd ; @@ -935,17 +935,17 @@ print_list: /* EMPTY */ { $$ = NULL; } var: type symbol '=' term ';' { - struct symbol *sym = cf_define_symbol($2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); + struct symbol *sym = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); $$ = f_new_inst(FI_VAR_INIT, $4, sym); } | type symbol ';' { - struct symbol *sym = cf_define_symbol($2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); + struct symbol *sym = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); $$ = f_new_inst(FI_VAR_INIT0, sym); } ; for_var: - type symbol { $$ = cf_define_symbol($2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); } + type symbol { $$ = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); } | CF_SYM_KNOWN { $$ = $1; cf_assert_symbol($1, SYM_VARIABLE); } ; @@ -961,13 +961,13 @@ cmd: } | FOR { /* Reserve space for walk data on stack */ - cf_push_block_scope(); - conf_this_scope->slots += 2; + cf_push_block_scope(new_config); + new_config->current_scope->slots += 2; } for_var IN /* Parse term in the parent scope */ - { conf_this_scope->active = 0; } term { conf_this_scope->active = 1; } + { new_config->current_scope->active = 0; } term { new_config->current_scope->active = 1; } DO cmd { - cf_pop_block_scope(); + cf_pop_block_scope(new_config); $$ = f_new_inst(FI_FOR_INIT, $6, $3); $$->next = f_new_inst(FI_FOR_NEXT, $3, $9); } diff --git a/nest/config.Y b/nest/config.Y index 8aaf0128..82f63783 100644 --- a/nest/config.Y +++ b/nest/config.Y @@ -255,19 +255,19 @@ proto_start: proto_name: /* EMPTY */ { - struct symbol *s = cf_default_name(this_proto->protocol->template, &this_proto->protocol->name_counter); + struct symbol *s = cf_default_name(new_config, this_proto->protocol->template, &this_proto->protocol->name_counter); s->class = this_proto->class; s->proto = this_proto; this_proto->name = s->name; } | symbol { - cf_define_symbol($1, this_proto->class, proto, this_proto); + cf_define_symbol(new_config, $1, this_proto->class, proto, this_proto); this_proto->name = $1->name; } | FROM CF_SYM_KNOWN { if (($2->class != SYM_TEMPLATE) && ($2->class != SYM_PROTO)) cf_error("Template or protocol name expected"); - struct symbol *s = cf_default_name(this_proto->protocol->template, &this_proto->protocol->name_counter); + struct symbol *s = cf_default_name(new_config, this_proto->protocol->template, &this_proto->protocol->name_counter); s->class = this_proto->class; s->proto = this_proto; this_proto->name = s->name; @@ -277,7 +277,7 @@ proto_name: | symbol FROM CF_SYM_KNOWN { if (($3->class != SYM_TEMPLATE) && ($3->class != SYM_PROTO)) cf_error("Template or protocol name expected"); - cf_define_symbol($1, this_proto->class, proto, this_proto); + cf_define_symbol(new_config, $1, this_proto->class, proto, this_proto); this_proto->name = $1->name; proto_copy_config(this_proto, $3->proto); diff --git a/nest/proto.c b/nest/proto.c index a5325705..bc7b7cc8 100644 --- a/nest/proto.c +++ b/nest/proto.c @@ -1269,8 +1269,8 @@ protos_commit(struct config *new, struct config *old, int force_reconfig, int ty /* This is hack, we would like to share config, but we need to copy it now */ new_config = new; cfg_mem = new->mem; - conf_this_scope = new->root_scope; - sym = cf_get_symbol(oc->name); + new->current_scope = new->root_scope; + sym = cf_get_symbol(new, oc->name); proto_clone_config(sym, parsym->proto); new_config = NULL; cfg_mem = NULL; diff --git a/nest/rt-table.c b/nest/rt-table.c index 23c4bbb2..742e2f05 100644 --- a/nest/rt-table.c +++ b/nest/rt-table.c @@ -2409,8 +2409,8 @@ rt_preconfig(struct config *c) { init_list(&c->tables); - rt_new_table(cf_get_symbol("master4"), NET_IP4); - rt_new_table(cf_get_symbol("master6"), NET_IP6); + rt_new_table(cf_get_symbol(c, "master4"), NET_IP4); + rt_new_table(cf_get_symbol(c, "master6"), NET_IP6); } void @@ -2838,7 +2838,7 @@ rt_new_table(struct symbol *s, uint addr_type) struct rtable_config *c = cfg_allocz(sizeof(struct rtable_config)); - cf_define_symbol(s, SYM_TABLE, table, c); + cf_define_symbol(new_config, s, SYM_TABLE, table, c); c->name = s->name; c->addr_type = addr_type; c->gc_threshold = 1000; diff --git a/proto/bgp/bgp.c b/proto/bgp/bgp.c index 0a2e8f5a..f668b371 100644 --- a/proto/bgp/bgp.c +++ b/proto/bgp/bgp.c @@ -507,8 +507,8 @@ bgp_spawn(struct bgp_proto *pp, ip_addr remote_ip) /* This is hack, we would like to share config, but we need to copy it now */ new_config = config; cfg_mem = config->mem; - conf_this_scope = config->root_scope; - sym = cf_default_name(fmt, &(pp->dynamic_name_counter)); + config->current_scope = config->root_scope; + sym = cf_default_name(config, fmt, &(pp->dynamic_name_counter)); proto_clone_config(sym, pp->p.cf); new_config = NULL; cfg_mem = NULL; diff --git a/sysdep/unix/main.c b/sysdep/unix/main.c index 0d3ec0c0..23cadb14 100644 --- a/sysdep/unix/main.c +++ b/sysdep/unix/main.c @@ -111,21 +111,21 @@ get_hostname(linpool *lp) #ifdef PATH_IPROUTE_DIR static inline void -add_num_const(char *name, int val, const char *file, const uint line) +add_num_const(struct config *conf, char *name, int val, const char *file, const uint line) { struct f_val *v = cfg_alloc(sizeof(struct f_val)); *v = (struct f_val) { .type = T_INT, .val.i = val }; - struct symbol *sym = cf_get_symbol(name); - if (sym->class && cf_symbol_is_local(sym)) + struct symbol *sym = cf_get_symbol(conf, name); + if (sym->class && cf_symbol_is_local(conf, sym)) cf_error("Error reading value for %s from %s:%d: already defined", name, file, line); - cf_define_symbol(sym, SYM_CONSTANT | T_INT, val, v); + cf_define_symbol(conf, sym, SYM_CONSTANT | T_INT, val, v); } /* the code of read_iproute_table() is based on rtnl_tab_initialize() from iproute2 package */ static void -read_iproute_table(char *file, char *prefix, uint max) +read_iproute_table(struct config *conf, char *file, char *prefix, uint max) { char buf[512], namebuf[512]; char *name; @@ -162,7 +162,7 @@ read_iproute_table(char *file, char *prefix, uint max) if ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && (*p != '_')) *p = '_'; - add_num_const(namebuf, val, file, line); + add_num_const(conf, namebuf, val, file, line); } fclose(fp); @@ -191,10 +191,10 @@ sysdep_preconfig(struct config *c) c->watchdog_warning = UNIX_DEFAULT_WATCHDOG_WARNING; #ifdef PATH_IPROUTE_DIR - read_iproute_table(PATH_IPROUTE_DIR "/rt_protos", "ipp_", 255); - read_iproute_table(PATH_IPROUTE_DIR "/rt_realms", "ipr_", 0xffffffff); - read_iproute_table(PATH_IPROUTE_DIR "/rt_scopes", "ips_", 255); - read_iproute_table(PATH_IPROUTE_DIR "/rt_tables", "ipt_", 0xffffffff); + read_iproute_table(c, PATH_IPROUTE_DIR "/rt_protos", "ipp_", 255); + read_iproute_table(c, PATH_IPROUTE_DIR "/rt_realms", "ipr_", 0xffffffff); + read_iproute_table(c, PATH_IPROUTE_DIR "/rt_scopes", "ips_", 255); + read_iproute_table(c, PATH_IPROUTE_DIR "/rt_tables", "ipt_", 0xffffffff); #endif }