Annotation of embedaddon/bird2/conf/conf.c, revision 1.1
1.1 ! misho 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; if
! 24: * there is one and the user wants to reconfigure once again, we just free the
! 25: * previous queued config and replace it with the new one) and finally a config
! 26: * being parsed (@new_config). The stored @old_config is also used for undo
! 27: * reconfiguration, which works in a similar way. Reconfiguration could also
! 28: * have timeout (using @config_timer) and undo is automatically called if the
! 29: * new configuration is not confirmed later. The new config (@new_config) and
! 30: * associated linear pool (@cfg_mem) is non-NULL only during parsing.
! 31: *
! 32: * Loading of new configuration is very simple: just call config_alloc() to get
! 33: * a new &config structure, then use config_parse() to parse a configuration
! 34: * file and fill all fields of the structure and finally ask the config manager
! 35: * to switch to the new config by calling config_commit().
! 36: *
! 37: * CLI commands are parsed in a very similar way -- there is also a stripped-down
! 38: * &config structure associated with them and they are lex-ed and parsed by the
! 39: * same functions, only a special fake token is prepended before the command
! 40: * text to make the parser recognize only the rules corresponding to CLI commands.
! 41: */
! 42:
! 43: #include <setjmp.h>
! 44: #include <stdarg.h>
! 45:
! 46: #undef LOCAL_DEBUG
! 47:
! 48: #include "nest/bird.h"
! 49: #include "nest/route.h"
! 50: #include "nest/protocol.h"
! 51: #include "nest/iface.h"
! 52: #include "lib/resource.h"
! 53: #include "lib/string.h"
! 54: #include "lib/event.h"
! 55: #include "lib/timer.h"
! 56: #include "conf/conf.h"
! 57: #include "filter/filter.h"
! 58:
! 59:
! 60: static jmp_buf conf_jmpbuf;
! 61:
! 62: struct config *config, *new_config;
! 63:
! 64: static struct config *old_config; /* Old configuration */
! 65: static struct config *future_config; /* New config held here if recon requested during recon */
! 66: static int old_cftype; /* Type of transition old_config -> config (RECONFIG_SOFT/HARD) */
! 67: static int future_cftype; /* Type of scheduled transition, may also be RECONFIG_UNDO */
! 68: /* Note that when future_cftype is RECONFIG_UNDO, then future_config is NULL,
! 69: therefore proper check for future scheduled config checks future_cftype */
! 70:
! 71: static event *config_event; /* Event for finalizing reconfiguration */
! 72: static timer *config_timer; /* Timer for scheduled configuration rollback */
! 73:
! 74: /* These are public just for cmd_show_status(), should not be accessed elsewhere */
! 75: int shutting_down; /* Shutdown requested, do not accept new config changes */
! 76: int configuring; /* Reconfiguration is running */
! 77: int undo_available; /* Undo was not requested from last reconfiguration */
! 78: /* Note that both shutting_down and undo_available are related to requests, not processing */
! 79:
! 80: /**
! 81: * config_alloc - allocate a new configuration
! 82: * @name: name of the config
! 83: *
! 84: * This function creates new &config structure, attaches a resource
! 85: * pool and a linear memory pool to it and makes it available for
! 86: * further use. Returns a pointer to the structure.
! 87: */
! 88: struct config *
! 89: config_alloc(const char *name)
! 90: {
! 91: pool *p = rp_new(&root_pool, "Config");
! 92: linpool *l = lp_new_default(p);
! 93: struct config *c = lp_allocz(l, sizeof(struct config));
! 94:
! 95: /* Duplication of name string in local linear pool */
! 96: uint nlen = strlen(name) + 1;
! 97: char *ndup = lp_allocu(l, nlen);
! 98: memcpy(ndup, name, nlen);
! 99:
! 100: init_list(&c->tests);
! 101: init_list(&c->symbols);
! 102: c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
! 103: c->pool = p;
! 104: c->mem = l;
! 105: c->file_name = ndup;
! 106: c->load_time = current_time();
! 107: c->tf_route = c->tf_proto = TM_ISO_SHORT_MS;
! 108: c->tf_base = c->tf_log = TM_ISO_LONG_MS;
! 109: c->gr_wait = DEFAULT_GR_WAIT;
! 110:
! 111: return c;
! 112: }
! 113:
! 114: /**
! 115: * config_parse - parse a configuration
! 116: * @c: configuration
! 117: *
! 118: * config_parse() reads input by calling a hook function pointed to
! 119: * by @cf_read_hook and parses it according to the configuration
! 120: * grammar. It also calls all the preconfig and postconfig hooks
! 121: * before, resp. after parsing.
! 122: *
! 123: * Result: 1 if the config has been parsed successfully, 0 if any
! 124: * error has occurred (such as anybody calling cf_error()) and
! 125: * the @err_msg field has been set to the error message.
! 126: */
! 127: int
! 128: config_parse(struct config *c)
! 129: {
! 130: int done = 0;
! 131: DBG("Parsing configuration file `%s'\n", c->file_name);
! 132: new_config = c;
! 133: cfg_mem = c->mem;
! 134: if (setjmp(conf_jmpbuf))
! 135: goto cleanup;
! 136:
! 137: cf_lex_init(0, c);
! 138: sysdep_preconfig(c);
! 139: protos_preconfig(c);
! 140: rt_preconfig(c);
! 141: cf_parse();
! 142:
! 143: if (EMPTY_LIST(c->protos))
! 144: cf_error("No protocol is specified in the config file");
! 145:
! 146: /*
! 147: if (!c->router_id)
! 148: cf_error("Router ID must be configured manually");
! 149: */
! 150:
! 151: done = 1;
! 152:
! 153: cleanup:
! 154: new_config = NULL;
! 155: cfg_mem = NULL;
! 156: return done;
! 157: }
! 158:
! 159: /**
! 160: * cli_parse - parse a CLI command
! 161: * @c: temporary config structure
! 162: *
! 163: * cli_parse() is similar to config_parse(), but instead of a configuration,
! 164: * it parses a CLI command. See the CLI module for more information.
! 165: */
! 166: int
! 167: cli_parse(struct config *c)
! 168: {
! 169: int done = 0;
! 170: c->fallback = config;
! 171: new_config = c;
! 172: cfg_mem = c->mem;
! 173: if (setjmp(conf_jmpbuf))
! 174: goto cleanup;
! 175:
! 176: cf_lex_init(1, c);
! 177: cf_parse();
! 178: done = 1;
! 179:
! 180: cleanup:
! 181: c->fallback = NULL;
! 182: new_config = NULL;
! 183: cfg_mem = NULL;
! 184: return done;
! 185: }
! 186:
! 187: /**
! 188: * config_free - free a configuration
! 189: * @c: configuration to be freed
! 190: *
! 191: * This function takes a &config structure and frees all resources
! 192: * associated with it.
! 193: */
! 194: void
! 195: config_free(struct config *c)
! 196: {
! 197: if (c)
! 198: rfree(c->pool);
! 199: }
! 200:
! 201: void
! 202: config_add_obstacle(struct config *c)
! 203: {
! 204: DBG("+++ adding obstacle %d\n", c->obstacle_count);
! 205: c->obstacle_count++;
! 206: }
! 207:
! 208: void
! 209: config_del_obstacle(struct config *c)
! 210: {
! 211: DBG("+++ deleting obstacle %d\n", c->obstacle_count);
! 212: c->obstacle_count--;
! 213: if (!c->obstacle_count && (c != config))
! 214: ev_schedule(config_event);
! 215: }
! 216:
! 217: static int
! 218: global_commit(struct config *new, struct config *old)
! 219: {
! 220: if (!old)
! 221: return 0;
! 222:
! 223: if (!new->router_id)
! 224: {
! 225: new->router_id = old->router_id;
! 226:
! 227: if (new->router_id_from)
! 228: {
! 229: u32 id = if_choose_router_id(new->router_id_from, old->router_id);
! 230: if (!id)
! 231: log(L_WARN "Cannot determine router ID, using old one");
! 232: else
! 233: new->router_id = id;
! 234: }
! 235: }
! 236:
! 237: return 0;
! 238: }
! 239:
! 240: static int
! 241: config_do_commit(struct config *c, int type)
! 242: {
! 243: if (type == RECONFIG_UNDO)
! 244: {
! 245: c = old_config;
! 246: type = old_cftype;
! 247: }
! 248: else
! 249: config_free(old_config);
! 250:
! 251: old_config = config;
! 252: old_cftype = type;
! 253: config = c;
! 254:
! 255: configuring = 1;
! 256: if (old_config && !config->shutdown)
! 257: log(L_INFO "Reconfiguring");
! 258:
! 259: if (old_config)
! 260: old_config->obstacle_count++;
! 261:
! 262: DBG("filter_commit\n");
! 263: filter_commit(c, old_config);
! 264: DBG("sysdep_commit\n");
! 265: int force_restart = sysdep_commit(c, old_config);
! 266: DBG("global_commit\n");
! 267: force_restart |= global_commit(c, old_config);
! 268: DBG("rt_commit\n");
! 269: rt_commit(c, old_config);
! 270: DBG("protos_commit\n");
! 271: protos_commit(c, old_config, force_restart, type);
! 272:
! 273: int obs = 0;
! 274: if (old_config)
! 275: obs = --old_config->obstacle_count;
! 276:
! 277: DBG("do_commit finished with %d obstacles remaining\n", obs);
! 278: return !obs;
! 279: }
! 280:
! 281: static void
! 282: config_done(void *unused UNUSED)
! 283: {
! 284: if (config->shutdown)
! 285: sysdep_shutdown_done();
! 286:
! 287: configuring = 0;
! 288: if (old_config)
! 289: log(L_INFO "Reconfigured");
! 290:
! 291: if (future_cftype)
! 292: {
! 293: int type = future_cftype;
! 294: struct config *conf = future_config;
! 295: future_cftype = RECONFIG_NONE;
! 296: future_config = NULL;
! 297:
! 298: log(L_INFO "Reconfiguring to queued configuration");
! 299: if (config_do_commit(conf, type))
! 300: config_done(NULL);
! 301: }
! 302: }
! 303:
! 304: /**
! 305: * config_commit - commit a configuration
! 306: * @c: new configuration
! 307: * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
! 308: * @timeout: timeout for undo (in seconds; or 0 for no timeout)
! 309: *
! 310: * When a configuration is parsed and prepared for use, the
! 311: * config_commit() function starts the process of reconfiguration.
! 312: * It checks whether there is already a reconfiguration in progress
! 313: * in which case it just queues the new config for later processing.
! 314: * Else it notifies all modules about the new configuration by calling
! 315: * their commit() functions which can either accept it immediately
! 316: * or call config_add_obstacle() to report that they need some time
! 317: * to complete the reconfiguration. After all such obstacles are removed
! 318: * using config_del_obstacle(), the old configuration is freed and
! 319: * everything runs according to the new one.
! 320: *
! 321: * When @timeout is nonzero, the undo timer is activated with given
! 322: * timeout. The timer is deactivated when config_commit(),
! 323: * config_confirm() or config_undo() is called.
! 324: *
! 325: * Result: %CONF_DONE if the configuration has been accepted immediately,
! 326: * %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
! 327: * if it's been queued due to another reconfiguration being in progress now
! 328: * or %CONF_SHUTDOWN if BIRD is in shutdown mode and no new configurations
! 329: * are accepted.
! 330: */
! 331: int
! 332: config_commit(struct config *c, int type, uint timeout)
! 333: {
! 334: if (shutting_down)
! 335: {
! 336: config_free(c);
! 337: return CONF_SHUTDOWN;
! 338: }
! 339:
! 340: undo_available = 1;
! 341: if (timeout)
! 342: tm_start(config_timer, timeout S);
! 343: else
! 344: tm_stop(config_timer);
! 345:
! 346: if (configuring)
! 347: {
! 348: if (future_cftype)
! 349: {
! 350: log(L_INFO "Queueing new configuration, ignoring the one already queued");
! 351: config_free(future_config);
! 352: }
! 353: else
! 354: log(L_INFO "Queueing new configuration");
! 355:
! 356: future_cftype = type;
! 357: future_config = c;
! 358: return CONF_QUEUED;
! 359: }
! 360:
! 361: if (config_do_commit(c, type))
! 362: {
! 363: config_done(NULL);
! 364: return CONF_DONE;
! 365: }
! 366: return CONF_PROGRESS;
! 367: }
! 368:
! 369: /**
! 370: * config_confirm - confirm a commited configuration
! 371: *
! 372: * When the undo timer is activated by config_commit() with nonzero timeout,
! 373: * this function can be used to deactivate it and therefore confirm
! 374: * the current configuration.
! 375: *
! 376: * Result: %CONF_CONFIRM when the current configuration is confirmed,
! 377: * %CONF_NONE when there is nothing to confirm (i.e. undo timer is not active).
! 378: */
! 379: int
! 380: config_confirm(void)
! 381: {
! 382: if (config_timer->expires == 0)
! 383: return CONF_NOTHING;
! 384:
! 385: tm_stop(config_timer);
! 386:
! 387: return CONF_CONFIRM;
! 388: }
! 389:
! 390: /**
! 391: * config_undo - undo a configuration
! 392: *
! 393: * Function config_undo() can be used to change the current
! 394: * configuration back to stored %old_config. If no reconfiguration is
! 395: * running, this stored configuration is commited in the same way as a
! 396: * new configuration in config_commit(). If there is already a
! 397: * reconfiguration in progress and no next reconfiguration is
! 398: * scheduled, then the undo is scheduled for later processing as
! 399: * usual, but if another reconfiguration is already scheduled, then
! 400: * such reconfiguration is removed instead (i.e. undo is applied on
! 401: * the last commit that scheduled it).
! 402: *
! 403: * Result: %CONF_DONE if the configuration has been accepted immediately,
! 404: * %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
! 405: * if it's been queued due to another reconfiguration being in progress now,
! 406: * %CONF_UNQUEUED if a scheduled reconfiguration is removed, %CONF_NOTHING
! 407: * if there is no relevant configuration to undo (the previous config request
! 408: * was config_undo() too) or %CONF_SHUTDOWN if BIRD is in shutdown mode and
! 409: * no new configuration changes are accepted.
! 410: */
! 411: int
! 412: config_undo(void)
! 413: {
! 414: if (shutting_down)
! 415: return CONF_SHUTDOWN;
! 416:
! 417: if (!undo_available || !old_config)
! 418: return CONF_NOTHING;
! 419:
! 420: undo_available = 0;
! 421: tm_stop(config_timer);
! 422:
! 423: if (configuring)
! 424: {
! 425: if (future_cftype)
! 426: {
! 427: config_free(future_config);
! 428: future_config = NULL;
! 429:
! 430: log(L_INFO "Removing queued configuration");
! 431: future_cftype = RECONFIG_NONE;
! 432: return CONF_UNQUEUED;
! 433: }
! 434: else
! 435: {
! 436: log(L_INFO "Queueing undo configuration");
! 437: future_cftype = RECONFIG_UNDO;
! 438: return CONF_QUEUED;
! 439: }
! 440: }
! 441:
! 442: if (config_do_commit(NULL, RECONFIG_UNDO))
! 443: {
! 444: config_done(NULL);
! 445: return CONF_DONE;
! 446: }
! 447: return CONF_PROGRESS;
! 448: }
! 449:
! 450: int
! 451: config_status(void)
! 452: {
! 453: if (shutting_down)
! 454: return CONF_SHUTDOWN;
! 455:
! 456: if (configuring)
! 457: return future_cftype ? CONF_QUEUED : CONF_PROGRESS;
! 458:
! 459: return CONF_DONE;
! 460: }
! 461:
! 462: btime
! 463: config_timer_status(void)
! 464: {
! 465: return tm_active(config_timer) ? tm_remains(config_timer) : -1;
! 466: }
! 467:
! 468: extern void cmd_reconfig_undo_notify(void);
! 469:
! 470: static void
! 471: config_timeout(timer *t UNUSED)
! 472: {
! 473: log(L_INFO "Config timeout expired, starting undo");
! 474: cmd_reconfig_undo_notify();
! 475:
! 476: int r = config_undo();
! 477: if (r < 0)
! 478: log(L_ERR "Undo request failed");
! 479: }
! 480:
! 481: void
! 482: config_init(void)
! 483: {
! 484: config_event = ev_new(&root_pool);
! 485: config_event->hook = config_done;
! 486:
! 487: config_timer = tm_new(&root_pool);
! 488: config_timer->hook = config_timeout;
! 489: }
! 490:
! 491: /**
! 492: * order_shutdown - order BIRD shutdown
! 493: *
! 494: * This function initiates shutdown of BIRD. It's accomplished by asking
! 495: * for switching to an empty configuration.
! 496: */
! 497: void
! 498: order_shutdown(int gr)
! 499: {
! 500: struct config *c;
! 501:
! 502: if (shutting_down)
! 503: return;
! 504:
! 505: if (!gr)
! 506: log(L_INFO "Shutting down");
! 507: else
! 508: log(L_INFO "Shutting down for graceful restart");
! 509:
! 510: c = lp_alloc(config->mem, sizeof(struct config));
! 511: memcpy(c, config, sizeof(struct config));
! 512: init_list(&c->protos);
! 513: init_list(&c->tables);
! 514: c->shutdown = 1;
! 515: c->gr_down = gr;
! 516:
! 517: config_commit(c, RECONFIG_HARD, 0);
! 518: shutting_down = 1;
! 519: }
! 520:
! 521: /**
! 522: * cf_error - report a configuration error
! 523: * @msg: printf-like format string
! 524: *
! 525: * cf_error() can be called during execution of config_parse(), that is
! 526: * from the parser, a preconfig hook or a postconfig hook, to report an
! 527: * error in the configuration.
! 528: */
! 529: void
! 530: cf_error(const char *msg, ...)
! 531: {
! 532: char buf[1024];
! 533: va_list args;
! 534:
! 535: va_start(args, msg);
! 536: if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
! 537: strcpy(buf, "<bug: error message too long>");
! 538: va_end(args);
! 539: new_config->err_msg = cfg_strdup(buf);
! 540: new_config->err_lino = ifs->lino;
! 541: new_config->err_chno = ifs->chno - ifs->toklen + 1;
! 542: new_config->err_file_name = ifs->file_name;
! 543: cf_lex_unwind();
! 544: longjmp(conf_jmpbuf, 1);
! 545: }
! 546:
! 547: /**
! 548: * cfg_strdup - copy a string to config memory
! 549: * @c: string to copy
! 550: *
! 551: * cfg_strdup() creates a new copy of the string in the memory
! 552: * pool associated with the configuration being currently parsed.
! 553: * It's often used when a string literal occurs in the configuration
! 554: * and we want to preserve it for further use.
! 555: */
! 556: char *
! 557: cfg_strdup(const char *c)
! 558: {
! 559: int l = strlen(c) + 1;
! 560: char *z = cfg_allocu(l);
! 561: memcpy(z, c, l);
! 562: return z;
! 563: }
! 564:
! 565:
! 566: void
! 567: cfg_copy_list(list *dest, list *src, unsigned node_size)
! 568: {
! 569: node *dn, *sn;
! 570:
! 571: init_list(dest);
! 572: WALK_LIST(sn, *src)
! 573: {
! 574: dn = cfg_alloc(node_size);
! 575: memcpy(dn, sn, node_size);
! 576: add_tail(dest, dn);
! 577: }
! 578: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to conf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / conf