mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-12-22 17:51:53 +00:00
623 lines
16 KiB
C
623 lines
16 KiB
C
/*
|
|
* BIRD Internet Routing Daemon -- Configuration File Handling
|
|
*
|
|
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
/**
|
|
* DOC: Configuration manager
|
|
*
|
|
* Configuration of BIRD is complex, yet straightforward. There are three
|
|
* modules taking care of the configuration: config manager (which takes care
|
|
* of storage of the config information and controls switching between configs),
|
|
* lexical analyzer and parser.
|
|
*
|
|
* The configuration manager stores each config as a &config structure
|
|
* accompanied by a linear pool from which all information associated
|
|
* with the config and pointed to by the &config structure is allocated.
|
|
*
|
|
* There can exist up to four different configurations at one time: an active
|
|
* one (pointed to by @config), configuration we are just switching from
|
|
* (@old_config), one queued for the next reconfiguration (@future_config; if
|
|
* there is one and the user wants to reconfigure once again, we just free the
|
|
* previous queued config and replace it with the new one) and finally a config
|
|
* being parsed (@new_config). The stored @old_config is also used for undo
|
|
* reconfiguration, which works in a similar way. Reconfiguration could also
|
|
* have timeout (using @config_timer) and undo is automatically called if the
|
|
* new configuration is not confirmed later. The new config (@new_config) and
|
|
* associated linear pool (@cfg_mem) is non-NULL only during parsing.
|
|
*
|
|
* Loading of new configuration is very simple: just call config_alloc() to get
|
|
* a new &config structure, then use config_parse() to parse a configuration
|
|
* file and fill all fields of the structure and finally ask the config manager
|
|
* to switch to the new config by calling config_commit().
|
|
*
|
|
* CLI commands are parsed in a very similar way -- there is also a stripped-down
|
|
* &config structure associated with them and they are lex-ed and parsed by the
|
|
* same functions, only a special fake token is prepended before the command
|
|
* text to make the parser recognize only the rules corresponding to CLI commands.
|
|
*/
|
|
|
|
#include <setjmp.h>
|
|
#include <stdarg.h>
|
|
|
|
#undef LOCAL_DEBUG
|
|
|
|
#include "nest/bird.h"
|
|
#include "nest/route.h"
|
|
#include "nest/protocol.h"
|
|
#include "nest/iface.h"
|
|
#include "nest/mpls.h"
|
|
#include "lib/resource.h"
|
|
#include "lib/string.h"
|
|
#include "lib/event.h"
|
|
#include "lib/timer.h"
|
|
#include "conf/conf.h"
|
|
#include "filter/filter.h"
|
|
#include "sysdep/unix/unix.h"
|
|
|
|
|
|
static jmp_buf conf_jmpbuf;
|
|
|
|
struct config *config;
|
|
_Thread_local struct config *new_config;
|
|
pool *config_pool;
|
|
|
|
static struct config *old_config; /* Old configuration */
|
|
static struct config *future_config; /* New config held here if recon requested during recon */
|
|
static int old_cftype; /* Type of transition old_config -> config (RECONFIG_SOFT/HARD) */
|
|
static int future_cftype; /* Type of scheduled transition, may also be RECONFIG_UNDO */
|
|
/* Note that when future_cftype is RECONFIG_UNDO, then future_config is NULL,
|
|
therefore proper check for future scheduled config checks future_cftype */
|
|
|
|
static void config_done(void *cf);
|
|
static timer *config_timer; /* Timer for scheduled configuration rollback */
|
|
|
|
/* These are public just for cmd_show_status(), should not be accessed elsewhere */
|
|
int shutting_down; /* Shutdown requested, do not accept new config changes */
|
|
int configuring; /* Reconfiguration is running */
|
|
int undo_available; /* Undo was not requested from last reconfiguration */
|
|
/* Note that both shutting_down and undo_available are related to requests, not processing */
|
|
|
|
/**
|
|
* config_alloc - allocate a new configuration
|
|
* @name: name of the config
|
|
*
|
|
* This function creates new &config structure, attaches a resource
|
|
* pool and a linear memory pool to it and makes it available for
|
|
* further use. Returns a pointer to the structure.
|
|
*/
|
|
struct config *
|
|
config_alloc(const char *name)
|
|
{
|
|
pool *p = rp_new(config_pool, the_bird_domain.the_bird, "Config");
|
|
linpool *l = lp_new_default(p);
|
|
struct config *c = lp_allocz(l, sizeof(struct config));
|
|
|
|
/* Duplication of name string in local linear pool */
|
|
uint nlen = strlen(name) + 1;
|
|
char *ndup = lp_allocu(l, nlen);
|
|
memcpy(ndup, name, nlen);
|
|
|
|
init_list(&c->tests);
|
|
init_list(&c->symbols);
|
|
c->pool = p;
|
|
c->mem = l;
|
|
c->file_name = ndup;
|
|
c->load_time = current_time();
|
|
c->tf_route = c->tf_proto = TM_ISO_SHORT_MS;
|
|
c->tf_base = c->tf_log = TM_ISO_LONG_MS;
|
|
c->gr_wait = DEFAULT_GR_WAIT;
|
|
|
|
c->done_event = (event) { .hook = config_done, .data = c, };
|
|
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* config_parse - parse a configuration
|
|
* @c: configuration
|
|
*
|
|
* config_parse() reads input by calling a hook function pointed to
|
|
* by @cf_read_hook and parses it according to the configuration
|
|
* grammar. It also calls all the preconfig and postconfig hooks
|
|
* before, resp. after parsing.
|
|
*
|
|
* Result: 1 if the config has been parsed successfully, 0 if any
|
|
* error has occurred (such as anybody calling cf_error()) and
|
|
* the @err_msg field has been set to the error message.
|
|
*/
|
|
int
|
|
config_parse(struct config *c)
|
|
{
|
|
int done = 0;
|
|
DBG("Parsing configuration file `%s'\n", c->file_name);
|
|
new_config = c;
|
|
cfg_mem = c->mem;
|
|
if (setjmp(conf_jmpbuf))
|
|
goto cleanup;
|
|
|
|
cf_lex_init(0, c);
|
|
sysdep_preconfig(c);
|
|
protos_preconfig(c);
|
|
mpls_preconfig(c);
|
|
rt_preconfig(c);
|
|
cf_parse();
|
|
rt_postconfig(c);
|
|
|
|
if (EMPTY_LIST(c->protos))
|
|
cf_error("No protocol is specified in the config file");
|
|
|
|
/*
|
|
if (!c->router_id)
|
|
cf_error("Router ID must be configured manually");
|
|
*/
|
|
|
|
done = 1;
|
|
|
|
cleanup:
|
|
new_config = NULL;
|
|
cfg_mem = NULL;
|
|
return done;
|
|
}
|
|
|
|
/**
|
|
* cli_parse - parse a CLI command
|
|
* @c: temporary config structure
|
|
*
|
|
* cli_parse() is similar to config_parse(), but instead of a configuration,
|
|
* it parses a CLI command. See the CLI module for more information.
|
|
*/
|
|
int
|
|
cli_parse(struct config *c)
|
|
{
|
|
int done = 0;
|
|
new_config = c;
|
|
cfg_mem = c->mem;
|
|
if (setjmp(conf_jmpbuf))
|
|
goto cleanup;
|
|
|
|
cf_lex_init(1, c);
|
|
cf_parse();
|
|
done = 1;
|
|
|
|
cleanup:
|
|
new_config = NULL;
|
|
cfg_mem = NULL;
|
|
return done;
|
|
}
|
|
|
|
/**
|
|
* config_free - free a configuration
|
|
* @c: configuration to be freed
|
|
*
|
|
* This function takes a &config structure and frees all resources
|
|
* associated with it.
|
|
*/
|
|
void
|
|
config_free(struct config *c)
|
|
{
|
|
if (!c)
|
|
return;
|
|
|
|
ASSERT(!atomic_load_explicit(&c->obstacle_count, memory_order_relaxed));
|
|
|
|
rp_free(c->pool);
|
|
}
|
|
|
|
/**
|
|
* config_free_old - free stored old configuration
|
|
*
|
|
* This function frees the old configuration (%old_config) that is saved for the
|
|
* purpose of undo. It is useful before parsing a new config when reconfig is
|
|
* requested, to avoid keeping three (perhaps memory-heavy) configs together.
|
|
* Configuration is not freed when it is still active during reconfiguration.
|
|
*/
|
|
void
|
|
config_free_old(void)
|
|
{
|
|
if (!old_config || atomic_load_explicit(&old_config->obstacle_count, memory_order_acquire))
|
|
return;
|
|
|
|
tm_stop(config_timer);
|
|
undo_available = 0;
|
|
|
|
config_free(old_config);
|
|
old_config = NULL;
|
|
}
|
|
|
|
void
|
|
config_add_obstacle(struct config *c)
|
|
{
|
|
UNUSED int obs = atomic_fetch_add_explicit(&c->obstacle_count, 1, memory_order_acq_rel);
|
|
DBG("+++ adding obstacle %d\n", obs);
|
|
}
|
|
|
|
void
|
|
config_del_obstacle(struct config *c)
|
|
{
|
|
int obs = atomic_fetch_sub_explicit(&c->obstacle_count, 1, memory_order_acq_rel);
|
|
DBG("+++ deleting obstacle %d\n", obs);
|
|
if (obs == 1)
|
|
ev_send_loop(&main_birdloop, &c->done_event);
|
|
}
|
|
|
|
static int
|
|
global_commit(struct config *new, struct config *old)
|
|
{
|
|
if (!old)
|
|
return 0;
|
|
|
|
if (!new->router_id)
|
|
{
|
|
new->router_id = old->router_id;
|
|
|
|
if (new->router_id_from)
|
|
{
|
|
u32 id = if_choose_router_id(new->router_id_from, old->router_id);
|
|
if (!id)
|
|
log(L_WARN "Cannot determine router ID, using old one");
|
|
else
|
|
new->router_id = id;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
config_do_commit(struct config *c, int type)
|
|
{
|
|
if (type == RECONFIG_UNDO)
|
|
{
|
|
c = old_config;
|
|
type = old_cftype;
|
|
}
|
|
else
|
|
config_free(old_config);
|
|
|
|
old_config = config;
|
|
old_cftype = type;
|
|
config = c;
|
|
|
|
if (!c->hostname)
|
|
{
|
|
c->hostname = get_hostname(c->mem);
|
|
|
|
if (!c->hostname)
|
|
log(L_WARN "Cannot determine hostname");
|
|
}
|
|
|
|
configuring = 1;
|
|
if (old_config && !config->shutdown)
|
|
log(L_INFO "Reconfiguring");
|
|
|
|
if (old_config)
|
|
config_add_obstacle(old_config);
|
|
|
|
DBG("filter_commit\n");
|
|
filter_commit(c, old_config);
|
|
DBG("sysdep_commit\n");
|
|
int force_restart = sysdep_commit(c, old_config);
|
|
DBG("global_commit\n");
|
|
force_restart |= global_commit(c, old_config);
|
|
mpls_commit(c, old_config);
|
|
DBG("rt_commit\n");
|
|
rt_commit(c, old_config);
|
|
DBG("protos_commit\n");
|
|
protos_commit(c, old_config, force_restart, type);
|
|
int obs = old_config ?
|
|
atomic_fetch_sub_explicit(&old_config->obstacle_count, 1, memory_order_acq_rel) - 1
|
|
: 0;
|
|
|
|
DBG("do_commit finished with %d obstacles remaining\n", obs);
|
|
return !obs;
|
|
}
|
|
|
|
static void
|
|
config_done(void *cf)
|
|
{
|
|
if (cf == config)
|
|
return;
|
|
|
|
if (config->shutdown)
|
|
sysdep_shutdown_done();
|
|
|
|
configuring = 0;
|
|
if (old_config)
|
|
log(L_INFO "Reconfigured");
|
|
|
|
if (future_cftype)
|
|
{
|
|
int type = future_cftype;
|
|
struct config *conf = future_config;
|
|
future_cftype = RECONFIG_NONE;
|
|
future_config = NULL;
|
|
|
|
log(L_INFO "Reconfiguring to queued configuration");
|
|
if (config_do_commit(conf, type))
|
|
config_done(NULL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* config_commit - commit a configuration
|
|
* @c: new configuration
|
|
* @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
|
|
* @timeout: timeout for undo (in seconds; or 0 for no timeout)
|
|
*
|
|
* When a configuration is parsed and prepared for use, the
|
|
* config_commit() function starts the process of reconfiguration.
|
|
* It checks whether there is already a reconfiguration in progress
|
|
* in which case it just queues the new config for later processing.
|
|
* Else it notifies all modules about the new configuration by calling
|
|
* their commit() functions which can either accept it immediately
|
|
* or call config_add_obstacle() to report that they need some time
|
|
* to complete the reconfiguration. After all such obstacles are removed
|
|
* using config_del_obstacle(), the old configuration is freed and
|
|
* everything runs according to the new one.
|
|
*
|
|
* When @timeout is nonzero, the undo timer is activated with given
|
|
* timeout. The timer is deactivated when config_commit(),
|
|
* config_confirm() or config_undo() is called.
|
|
*
|
|
* Result: %CONF_DONE if the configuration has been accepted immediately,
|
|
* %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
|
|
* if it's been queued due to another reconfiguration being in progress now
|
|
* or %CONF_SHUTDOWN if BIRD is in shutdown mode and no new configurations
|
|
* are accepted.
|
|
*/
|
|
int
|
|
config_commit(struct config *c, int type, uint timeout)
|
|
{
|
|
if (shutting_down)
|
|
{
|
|
config_free(c);
|
|
return CONF_SHUTDOWN;
|
|
}
|
|
|
|
undo_available = 1;
|
|
if (timeout)
|
|
tm_start(config_timer, timeout S);
|
|
else
|
|
tm_stop(config_timer);
|
|
|
|
if (configuring)
|
|
{
|
|
if (future_cftype)
|
|
{
|
|
log(L_INFO "Queueing new configuration, ignoring the one already queued");
|
|
config_free(future_config);
|
|
}
|
|
else
|
|
log(L_INFO "Queueing new configuration");
|
|
|
|
future_cftype = type;
|
|
future_config = c;
|
|
return CONF_QUEUED;
|
|
}
|
|
|
|
if (config_do_commit(c, type))
|
|
{
|
|
config_done(NULL);
|
|
return CONF_DONE;
|
|
}
|
|
return CONF_PROGRESS;
|
|
}
|
|
|
|
/**
|
|
* config_confirm - confirm a commited configuration
|
|
*
|
|
* When the undo timer is activated by config_commit() with nonzero timeout,
|
|
* this function can be used to deactivate it and therefore confirm
|
|
* the current configuration.
|
|
*
|
|
* Result: %CONF_CONFIRM when the current configuration is confirmed,
|
|
* %CONF_NONE when there is nothing to confirm (i.e. undo timer is not active).
|
|
*/
|
|
int
|
|
config_confirm(void)
|
|
{
|
|
if (config_timer->expires == 0)
|
|
return CONF_NOTHING;
|
|
|
|
tm_stop(config_timer);
|
|
|
|
return CONF_CONFIRM;
|
|
}
|
|
|
|
/**
|
|
* config_undo - undo a configuration
|
|
*
|
|
* Function config_undo() can be used to change the current
|
|
* configuration back to stored %old_config. If no reconfiguration is
|
|
* running, this stored configuration is commited in the same way as a
|
|
* new configuration in config_commit(). If there is already a
|
|
* reconfiguration in progress and no next reconfiguration is
|
|
* scheduled, then the undo is scheduled for later processing as
|
|
* usual, but if another reconfiguration is already scheduled, then
|
|
* such reconfiguration is removed instead (i.e. undo is applied on
|
|
* the last commit that scheduled it).
|
|
*
|
|
* Result: %CONF_DONE if the configuration has been accepted immediately,
|
|
* %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
|
|
* if it's been queued due to another reconfiguration being in progress now,
|
|
* %CONF_UNQUEUED if a scheduled reconfiguration is removed, %CONF_NOTHING
|
|
* if there is no relevant configuration to undo (the previous config request
|
|
* was config_undo() too) or %CONF_SHUTDOWN if BIRD is in shutdown mode and
|
|
* no new configuration changes are accepted.
|
|
*/
|
|
int
|
|
config_undo(void)
|
|
{
|
|
if (shutting_down)
|
|
return CONF_SHUTDOWN;
|
|
|
|
if (!undo_available || !old_config)
|
|
return CONF_NOTHING;
|
|
|
|
undo_available = 0;
|
|
tm_stop(config_timer);
|
|
|
|
if (configuring)
|
|
{
|
|
if (future_cftype)
|
|
{
|
|
config_free(future_config);
|
|
future_config = NULL;
|
|
|
|
log(L_INFO "Removing queued configuration");
|
|
future_cftype = RECONFIG_NONE;
|
|
return CONF_UNQUEUED;
|
|
}
|
|
else
|
|
{
|
|
log(L_INFO "Queueing undo configuration");
|
|
future_cftype = RECONFIG_UNDO;
|
|
return CONF_QUEUED;
|
|
}
|
|
}
|
|
|
|
if (config_do_commit(NULL, RECONFIG_UNDO))
|
|
{
|
|
config_done(NULL);
|
|
return CONF_DONE;
|
|
}
|
|
return CONF_PROGRESS;
|
|
}
|
|
|
|
int
|
|
config_status(void)
|
|
{
|
|
if (shutting_down)
|
|
return CONF_SHUTDOWN;
|
|
|
|
if (configuring)
|
|
return future_cftype ? CONF_QUEUED : CONF_PROGRESS;
|
|
|
|
return CONF_DONE;
|
|
}
|
|
|
|
btime
|
|
config_timer_status(void)
|
|
{
|
|
return tm_active(config_timer) ? tm_remains(config_timer) : -1;
|
|
}
|
|
|
|
extern void cmd_reconfig_undo_notify(void);
|
|
|
|
static void
|
|
config_timeout(timer *t UNUSED)
|
|
{
|
|
log(L_INFO "Config timeout expired, starting undo");
|
|
cmd_reconfig_undo_notify();
|
|
|
|
int r = config_undo();
|
|
if (r < 0)
|
|
log(L_ERR "Undo request failed");
|
|
}
|
|
|
|
void
|
|
config_init(void)
|
|
{
|
|
config_pool = rp_new(&root_pool, the_bird_domain.the_bird, "Configurations");
|
|
|
|
config_timer = tm_new(config_pool);
|
|
config_timer->hook = config_timeout;
|
|
}
|
|
|
|
/**
|
|
* order_shutdown - order BIRD shutdown
|
|
*
|
|
* This function initiates shutdown of BIRD. It's accomplished by asking
|
|
* for switching to an empty configuration.
|
|
*/
|
|
void
|
|
order_shutdown(int gr)
|
|
{
|
|
struct config *c;
|
|
|
|
if (shutting_down)
|
|
return;
|
|
|
|
if (!gr)
|
|
log(L_INFO "Shutting down");
|
|
else
|
|
log(L_INFO "Shutting down for graceful restart");
|
|
|
|
c = lp_alloc(config->mem, sizeof(struct config));
|
|
memcpy(c, config, sizeof(struct config));
|
|
init_list(&c->protos);
|
|
init_list(&c->tables);
|
|
init_list(&c->mpls_domains);
|
|
init_list(&c->symbols);
|
|
memset(c->def_tables, 0, sizeof(c->def_tables));
|
|
c->shutdown = 1;
|
|
c->gr_down = gr;
|
|
|
|
config_commit(c, RECONFIG_HARD, 0);
|
|
shutting_down = 1;
|
|
}
|
|
|
|
/**
|
|
* cf_error - report a configuration error
|
|
* @msg: printf-like format string
|
|
*
|
|
* cf_error() can be called during execution of config_parse(), that is
|
|
* from the parser, a preconfig hook or a postconfig hook, to report an
|
|
* error in the configuration.
|
|
*/
|
|
void
|
|
cf_error(const char *msg, ...)
|
|
{
|
|
char buf[1024];
|
|
va_list args;
|
|
|
|
va_start(args, msg);
|
|
if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
|
|
strcpy(buf, "<bug: error message too long>");
|
|
va_end(args);
|
|
new_config->err_msg = cfg_strdup(buf);
|
|
new_config->err_lino = ifs->lino;
|
|
new_config->err_chno = ifs->chno - ifs->toklen + 1;
|
|
new_config->err_file_name = ifs->file_name;
|
|
cf_lex_unwind();
|
|
longjmp(conf_jmpbuf, 1);
|
|
}
|
|
|
|
/**
|
|
* cfg_strdup - copy a string to config memory
|
|
* @c: string to copy
|
|
*
|
|
* cfg_strdup() creates a new copy of the string in the memory
|
|
* pool associated with the configuration being currently parsed.
|
|
* It's often used when a string literal occurs in the configuration
|
|
* and we want to preserve it for further use.
|
|
*/
|
|
char *
|
|
cfg_strdup(const char *c)
|
|
{
|
|
int l = strlen(c) + 1;
|
|
char *z = cfg_allocu(l);
|
|
memcpy(z, c, l);
|
|
return z;
|
|
}
|
|
|
|
|
|
void
|
|
cfg_copy_list(list *dest, list *src, unsigned node_size)
|
|
{
|
|
node *dn, *sn;
|
|
|
|
init_list(dest);
|
|
WALK_LIST(sn, *src)
|
|
{
|
|
dn = cfg_alloc(node_size);
|
|
memcpy(dn, sn, node_size);
|
|
memset(dn, 0, sizeof(node));
|
|
add_tail(dest, dn);
|
|
}
|
|
}
|