bird/conf/conf.c

371 lines
9.8 KiB
C
Raw Normal View History

/*
* 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.
*/
2000-06-04 02:23:00 +08:00
/**
* DOC: Configuration manager
*
2000-06-08 20:37:21 +08:00
* Configuration of BIRD is complex, yet straightforward. There are three
2000-06-04 02:23:00 +08:00
* modules taking care of the configuration: config manager (which takes care
2000-06-07 21:25:53 +08:00
* of storage of the config information and controls switching between configs),
2000-06-07 20:29:08 +08:00
* lexical analyzer and parser.
2000-06-04 02:23:00 +08:00
*
* 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.
*
2000-06-08 20:37:21 +08:00
* There can exist up to four different configurations at one time: an active
2000-06-04 02:23:00 +08:00
* one (pointed to by @config), configuration we are just switching from
* (@old_config), one queued for the next reconfiguration (@future_config;
* if it's non-%NULL 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).
*
* Loading of new configuration is very simple: just call config_alloc()
* to get a new &config structure, then use config_parse() to parse a
2000-06-07 21:25:53 +08:00
* configuration file and fill all fields of the structure
2000-06-04 02:23:00 +08:00
* 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
2000-06-07 20:29:08 +08:00
* &config structure associated with them and they are lex-ed and parsed by the
2000-06-04 02:23:00 +08:00
* 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 "lib/resource.h"
#include "lib/string.h"
#include "lib/event.h"
#include "lib/timer.h"
#include "conf/conf.h"
#include "filter/filter.h"
static jmp_buf conf_jmpbuf;
struct config *config, *new_config, *old_config, *future_config;
static event *config_event;
int shutting_down;
bird_clock_t boot_time;
2000-06-04 02:23:00 +08:00
/**
* 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(byte *name)
{
pool *p = rp_new(&root_pool, "Config");
linpool *l = lp_new(p, 4080);
struct config *c = lp_allocz(l, sizeof(struct config));
2010-01-03 19:17:52 +08:00
c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
c->pool = p;
cfg_mem = c->mem = l;
c->file_name = cfg_strdup(name);
c->load_time = now;
2010-02-03 07:19:24 +08:00
c->tf_base.fmt1 = c->tf_log.fmt1 = "%d-%m-%Y %T";
if (!boot_time)
boot_time = now;
return c;
}
2000-06-04 02:23:00 +08:00
/**
* 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
2000-06-07 20:29:08 +08:00
* before, resp. after parsing.
2000-06-04 02:23:00 +08:00
*
* Result: 1 if the config has been parsed successfully, 0 if any
2000-06-07 20:29:08 +08:00
* error has occurred (such as anybody calling cf_error()) and
2000-06-04 02:23:00 +08:00
* the @err_msg field has been set to the error message.
*/
int
config_parse(struct config *c)
{
DBG("Parsing configuration file `%s'\n", c->file_name);
new_config = c;
cfg_mem = c->mem;
if (setjmp(conf_jmpbuf))
return 0;
cf_lex_init(0);
sysdep_preconfig(c);
protos_preconfig(c);
rt_preconfig(c);
cf_parse();
protos_postconfig(c);
#ifdef IPV6
if (!c->router_id)
cf_error("Router ID must be configured manually on IPv6 routers");
#endif
return 1;
}
2000-06-04 02:23:00 +08:00
/**
* 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)
{
new_config = c;
c->sym_fallback = config->sym_hash;
cfg_mem = c->mem;
if (setjmp(conf_jmpbuf))
return 0;
cf_lex_init(1);
cf_parse();
return 1;
}
2000-06-04 02:23:00 +08:00
/**
* 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)
{
rfree(c->pool);
}
void
config_add_obstacle(struct config *c)
{
DBG("+++ adding obstacle %d\n", c->obstacle_count);
c->obstacle_count++;
}
void
config_del_obstacle(struct config *c)
{
DBG("+++ deleting obstacle %d\n", c->obstacle_count);
c->obstacle_count--;
if (!c->obstacle_count)
{
ASSERT(config_event);
ev_schedule(config_event);
}
}
static int
global_commit(struct config *new, struct config *old)
{
if (!old)
return 0;
if (!ipa_equal(old->listen_bgp_addr, new->listen_bgp_addr) ||
(old->listen_bgp_port != new->listen_bgp_port) ||
(old->listen_bgp_flags != new->listen_bgp_flags))
log(L_WARN "Reconfiguration of BGP listening socket not implemented, please restart BIRD.");
if (!new->router_id)
new->router_id = old->router_id;
if (new->router_id != old->router_id)
return 1;
return 0;
}
static int
2009-06-20 05:49:34 +08:00
config_do_commit(struct config *c, int type)
{
int force_restart, nobs;
DBG("do_commit\n");
old_config = config;
config = new_config = c;
if (old_config)
old_config->obstacle_count++;
DBG("sysdep_commit\n");
force_restart = sysdep_commit(c, old_config);
DBG("global_commit\n");
force_restart |= global_commit(c, old_config);
DBG("rt_commit\n");
rt_commit(c, old_config);
DBG("protos_commit\n");
2009-06-20 05:49:34 +08:00
protos_commit(c, old_config, force_restart, type);
new_config = NULL; /* Just to be sure nobody uses that now */
if (old_config)
nobs = --old_config->obstacle_count;
else
nobs = 0;
DBG("do_commit finished with %d obstacles remaining\n", nobs);
return !nobs;
}
static void
config_done(void *unused UNUSED)
{
struct config *c;
DBG("config_done\n");
for(;;)
{
if (config->shutdown)
sysdep_shutdown_done();
log(L_INFO "Reconfigured");
if (old_config)
{
config_free(old_config);
old_config = NULL;
}
if (!future_config)
break;
c = future_config;
future_config = NULL;
log(L_INFO "Switching to queued configuration...");
2009-06-20 05:49:34 +08:00
if (!config_do_commit(c, RECONFIG_HARD))
break;
}
}
2000-06-04 02:23:00 +08:00
/**
* config_commit - commit a configuration
* @c: new configuration
2009-06-20 05:49:34 +08:00
* @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
2000-06-04 02:23:00 +08:00
*
* 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.
*
* 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
2009-06-20 05:49:34 +08:00
config_commit(struct config *c, int type)
{
if (!config) /* First-time configuration */
{
2009-06-20 05:49:34 +08:00
config_do_commit(c, RECONFIG_HARD);
return CONF_DONE;
}
if (old_config) /* Reconfiguration already in progress */
{
if (shutting_down == 2)
{
log(L_INFO "New configuration discarded due to shutdown");
config_free(c);
return CONF_SHUTDOWN;
}
if (future_config)
{
log(L_INFO "Queueing new configuration, ignoring the one already queued");
config_free(future_config);
}
else
log(L_INFO "Queued new configuration");
future_config = c;
return CONF_QUEUED;
}
2009-06-20 05:49:34 +08:00
if (config_do_commit(c, type))
{
config_done(NULL);
return CONF_DONE;
}
if (!config_event)
{
config_event = ev_new(&root_pool);
config_event->hook = config_done;
}
return CONF_PROGRESS;
}
2000-06-04 02:23:00 +08:00
/**
* 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(void)
{
struct config *c;
if (shutting_down)
return;
log(L_INFO "Shutting down");
c = lp_alloc(config->mem, sizeof(struct config));
memcpy(c, config, sizeof(struct config));
init_list(&c->protos);
init_list(&c->tables);
c->shutdown = 1;
shutting_down = 1;
2009-06-20 05:49:34 +08:00
config_commit(c, RECONFIG_HARD);
shutting_down = 2;
}
2000-06-04 02:23:00 +08:00
/**
* 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(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>");
new_config->err_msg = cfg_strdup(buf);
new_config->err_lino = conf_lino;
longjmp(conf_jmpbuf, 1);
}
2000-06-04 02:23:00 +08:00
/**
* 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(char *c)
{
int l = strlen(c) + 1;
char *z = cfg_allocu(l);
memcpy(z, c, l);
return z;
}