conf/conf.c

   1 /*
   2  *      BIRD Internet Routing Daemon -- Configuration File Handling
   3  *
   4  *      (c) 1998--2000 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 /**
  10  * DOC: Configuration manager
  11  *
  12  * Configuration of BIRD is complex, yet straightforward. There are three
  13  * modules taking care of the configuration: config manager (which takes care
  14  * of storage of the config information and controls switching between configs),
  15  * lexical analyzer and parser.
  16  *
  17  * The configuration manager stores each config as a &config structure
  18  * accompanied by a linear pool from which all information associated
  19  * with the config and pointed to by the &config structure is allocated.
  20  *
  21  * There can exist up to four different configurations at one time: an active
  22  * one (pointed to by @config), configuration we are just switching from
  23  * (@old_config), one queued for the next reconfiguration (@future_config;
  24  * if it's non-%NULL and the user wants to reconfigure once again, we just
  25  * free the previous queued config and replace it with the new one) and
  26  * finally a config being parsed (@new_config).
  27  *
  28  * Loading of new configuration is very simple: just call config_alloc()
  29  * to get a new &config structure, then use config_parse() to parse a
  30  * configuration file and fill all fields of the structure
  31  * and finally ask the config manager to switch to the new
  32  * config by calling config_commit().
  33  *
  34  * CLI commands are parsed in a very similar way -- there is also a stripped-down
  35  * &config structure associated with them and they are lex-ed and parsed by the
  36  * same functions, only a special fake token is prepended before the command
  37  * text to make the parser recognize only the rules corresponding to CLI commands.
  38  */
  39
  40 #include <setjmp.h>
  41 #include <stdarg.h>
  42
  43 #undef LOCAL_DEBUG
  44
  45 #include "nest/bird.h"
  46 #include "nest/route.h"
  47 #include "nest/protocol.h"
  48 #include "nest/iface.h"
  49 #include "lib/resource.h"
  50 #include "lib/string.h"
  51 #include "lib/event.h"
  52 #include "lib/timer.h"
  53 #include "conf/conf.h"
  54 #include "filter/filter.h"
  55
  56 static jmp_buf conf_jmpbuf;
  57
  58 struct config *config, *new_config, *old_config, *future_config;
  59 static event *config_event;
  60 int shutting_down, future_type;
  61 bird_clock_t boot_time;
  62
  63 /**
  64  * config_alloc - allocate a new configuration
  65  * @name: name of the config
  66  *
  67  * This function creates new &config structure, attaches a resource
  68  * pool and a linear memory pool to it and makes it available for
  69  * further use. Returns a pointer to the structure.
  70  */
  71 struct config *
  72 config_alloc(byte *name)
  73 {
  74   pool *p = rp_new(&root_pool, "Config");
  75   linpool *l = lp_new(p, 4080);
  76   struct config *c = lp_allocz(l, sizeof(struct config));
  77
  78   c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
  79   c->pool = p;
  80   cfg_mem = c->mem = l;
  81   c->file_name = cfg_strdup(name);
  82   c->load_time = now;
  83   c->tf_base.fmt1 = c->tf_log.fmt1 = "%d-%m-%Y %T";
  84
  85   if (!boot_time)
  86     boot_time = now;
  87   return c;
  88 }
  89
  90 /**
  91  * config_parse - parse a configuration
  92  * @c: configuration
  93  *
  94  * config_parse() reads input by calling a hook function pointed to
  95  * by @cf_read_hook and parses it according to the configuration
  96  * grammar. It also calls all the preconfig and postconfig hooks
  97  * before, resp. after parsing.
  98  *
  99  * Result: 1 if the config has been parsed successfully, 0 if any
 100  * error has occurred (such as anybody calling cf_error()) and
 101  * the @err_msg field has been set to the error message.
 102  */
 103 int
 104 config_parse(struct config *c)
 105 {
 106   DBG("Parsing configuration file `%s'\n", c->file_name);
 107   new_config = c;
 108   cfg_mem = c->mem;
 109   if (setjmp(conf_jmpbuf))
 110     return 0;
 111   cf_lex_init(0, c);
 112   sysdep_preconfig(c);
 113   protos_preconfig(c);
 114   rt_preconfig(c);
 115   roa_preconfig(c);
 116   cf_parse();
 117   protos_postconfig(c);
 118   if (EMPTY_LIST(c->protos))
 119     cf_error("No protocol is specified in the config file");
 120 #ifdef IPV6
 121   if (!c->router_id)
 122     cf_error("Router ID must be configured manually on IPv6 routers");
 123 #endif
 124   return 1;
 125 }
 126
 127 /**
 128  * cli_parse - parse a CLI command
 129  * @c: temporary config structure
 130  *
 131  * cli_parse() is similar to config_parse(), but instead of a configuration,
 132  * it parses a CLI command. See the CLI module for more information.
 133  */
 134 int
 135 cli_parse(struct config *c)
 136 {
 137   new_config = c;
 138   c->sym_fallback = config->sym_hash;
 139   cfg_mem = c->mem;
 140   if (setjmp(conf_jmpbuf))
 141     return 0;
 142   cf_lex_init(1, c);
 143   cf_parse();
 144   return 1;
 145 }
 146
 147 /**
 148  * config_free - free a configuration
 149  * @c: configuration to be freed
 150  *
 151  * This function takes a &config structure and frees all resources
 152  * associated with it.
 153  */
 154 void
 155 config_free(struct config *c)
 156 {
 157   rfree(c->pool);
 158 }
 159
 160 void
 161 config_add_obstacle(struct config *c)
 162 {
 163   DBG("+++ adding obstacle %d\n", c->obstacle_count);
 164   c->obstacle_count++;
 165 }
 166
 167 void
 168 config_del_obstacle(struct config *c)
 169 {
 170   DBG("+++ deleting obstacle %d\n", c->obstacle_count);
 171   c->obstacle_count--;
 172   if (!c->obstacle_count)
 173     {
 174       ASSERT(config_event);
 175       ev_schedule(config_event);
 176     }
 177 }
 178
 179 static int
 180 global_commit(struct config *new, struct config *old)
 181 {
 182   if (!old)
 183     return 0;
 184
 185   if (!ipa_equal(old->listen_bgp_addr, new->listen_bgp_addr) ||
 186       (old->listen_bgp_port != new->listen_bgp_port) ||
 187       (old->listen_bgp_flags != new->listen_bgp_flags))
 188     log(L_WARN "Reconfiguration of BGP listening socket not implemented, please restart BIRD.");
 189
 190   if (!new->router_id)
 191     new->router_id = old->router_id;
 192   if (new->router_id != old->router_id)
 193     return 1;
 194   return 0;
 195 }
 196
 197 static int
 198 config_do_commit(struct config *c, int type)
 199 {
 200   int force_restart, nobs;
 201
 202   DBG("do_commit\n");
 203   old_config = config;
 204   config = new_config = c;
 205   if (old_config)
 206     old_config->obstacle_count++;
 207
 208   DBG("sysdep_commit\n");
 209   force_restart = sysdep_commit(c, old_config);
 210   DBG("global_commit\n");
 211   force_restart |= global_commit(c, old_config);
 212   DBG("rt_commit\n");
 213   rt_commit(c, old_config);
 214   roa_commit(c, old_config);
 215   DBG("protos_commit\n");
 216   protos_commit(c, old_config, force_restart, type);
 217   new_config = NULL;                    /* Just to be sure nobody uses that now */
 218   if (old_config)
 219     nobs = --old_config->obstacle_count;
 220   else
 221     nobs = 0;
 222   DBG("do_commit finished with %d obstacles remaining\n", nobs);
 223   return !nobs;
 224 }
 225
 226 static void
 227 config_done(void *unused UNUSED)
 228 {
 229   struct config *c;
 230
 231   DBG("config_done\n");
 232   for(;;)
 233     {
 234       if (config->shutdown)
 235         sysdep_shutdown_done();
 236       log(L_INFO "Reconfigured");
 237       if (old_config)
 238         {
 239           config_free(old_config);
 240           old_config = NULL;
 241         }
 242       if (!future_config)
 243         break;
 244       c = future_config;
 245       future_config = NULL;
 246       log(L_INFO "Reconfiguring to queued configuration");
 247       if (!config_do_commit(c, future_type))
 248         break;
 249     }
 250 }
 251
 252 /**
 253  * config_commit - commit a configuration
 254  * @c: new configuration
 255  * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
 256  *
 257  * When a configuration is parsed and prepared for use, the
 258  * config_commit() function starts the process of reconfiguration.
 259  * It checks whether there is already a reconfiguration in progress
 260  * in which case it just queues the new config for later processing.
 261  * Else it notifies all modules about the new configuration by calling
 262  * their commit() functions which can either accept it immediately
 263  * or call config_add_obstacle() to report that they need some time
 264  * to complete the reconfiguration. After all such obstacles are removed
 265  * using config_del_obstacle(), the old configuration is freed and
 266  * everything runs according to the new one.
 267  *
 268  * Result: %CONF_DONE if the configuration has been accepted immediately,
 269  * %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
 270  * if it's been queued due to another reconfiguration being in progress now
 271  * or %CONF_SHUTDOWN if BIRD is in shutdown mode and no new configurations
 272  * are accepted.
 273  */
 274 int
 275 config_commit(struct config *c, int type)
 276 {
 277   if (!config)                          /* First-time configuration */
 278     {
 279       config_do_commit(c, RECONFIG_HARD);
 280       return CONF_DONE;
 281     }
 282   if (old_config)                       /* Reconfiguration already in progress */
 283     {
 284       if (shutting_down == 2)
 285         {
 286           log(L_INFO "New configuration discarded due to shutdown");
 287           config_free(c);
 288           return CONF_SHUTDOWN;
 289         }
 290       if (future_config)
 291         {
 292           log(L_INFO "Queueing new configuration, ignoring the one already queued");
 293           config_free(future_config);
 294         }
 295       else
 296         log(L_INFO "Queued new configuration");
 297       future_config = c;
 298       future_type = type;
 299       return CONF_QUEUED;
 300     }
 301
 302   if (!shutting_down)
 303     log(L_INFO "Reconfiguring");
 304
 305   if (config_do_commit(c, type))
 306     {
 307       config_done(NULL);
 308       return CONF_DONE;
 309     }
 310   if (!config_event)
 311     {
 312       config_event = ev_new(&root_pool);
 313       config_event->hook = config_done;
 314     }
 315   return CONF_PROGRESS;
 316 }
 317
 318 /**
 319  * order_shutdown - order BIRD shutdown
 320  *
 321  * This function initiates shutdown of BIRD. It's accomplished by asking
 322  * for switching to an empty configuration.
 323  */
 324 void
 325 order_shutdown(void)
 326 {
 327   struct config *c;
 328
 329   if (shutting_down)
 330     return;
 331   log(L_INFO "Shutting down");
 332   c = lp_alloc(config->mem, sizeof(struct config));
 333   memcpy(c, config, sizeof(struct config));
 334   init_list(&c->protos);
 335   init_list(&c->tables);
 336   c->shutdown = 1;
 337   shutting_down = 1;
 338   config_commit(c, RECONFIG_HARD);
 339   shutting_down = 2;
 340 }
 341
 342 /**
 343  * cf_error - report a configuration error
 344  * @msg: printf-like format string
 345  *
 346  * cf_error() can be called during execution of config_parse(), that is
 347  * from the parser, a preconfig hook or a postconfig hook, to report an
 348  * error in the configuration.
 349  */
 350 void
 351 cf_error(char *msg, ...)
 352 {
 353   char buf[1024];
 354   va_list args;
 355
 356   va_start(args, msg);
 357   if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
 358     strcpy(buf, "<bug: error message too long>");
 359   new_config->err_msg = cfg_strdup(buf);
 360   new_config->err_lino = ifs->lino;
 361   new_config->err_file_name = ifs->file_name;
 362   longjmp(conf_jmpbuf, 1);
 363 }
 364
 365 /**
 366  * cfg_strdup - copy a string to config memory
 367  * @c: string to copy
 368  *
 369  * cfg_strdup() creates a new copy of the string in the memory
 370  * pool associated with the configuration being currently parsed.
 371  * It's often used when a string literal occurs in the configuration
 372  * and we want to preserve it for further use.
 373  */
 374 char *
 375 cfg_strdup(char *c)
 376 {
 377   int l = strlen(c) + 1;
 378   char *z = cfg_allocu(l);
 379   memcpy(z, c, l);
 380   return z;
 381 }
 382
 383
 384 void
 385 cfg_copy_list(list *dest, list *src, unsigned node_size)
 386 {
 387   node *dn, *sn;
 388
 389   init_list(dest);
 390   WALK_LIST(sn, *src)
 391   {
 392     dn = cfg_alloc(node_size);
 393     memcpy(dn, sn, node_size);
 394     add_tail(dest, dn);
 395   }
 396 }