Annotation of embedaddon/bird/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: static jmp_buf conf_jmpbuf;
! 60:
! 61: struct config *config, *new_config;
! 62:
! 63: static struct config *old_config; /* Old configuration */
! 64: static struct config *future_config; /* New config held here if recon requested during recon */
! 65: static int old_cftype; /* Type of transition old_config -> config (RECONFIG_SOFT/HARD) */
! 66: static int future_cftype; /* Type of scheduled transition, may also be RECONFIG_UNDO */
! 67: /* Note that when future_cftype is RECONFIG_UNDO, then future_config is NULL,
! 68: therefore proper check for future scheduled config checks future_cftype */
! 69:
! 70: static event *config_event; /* Event for finalizing reconfiguration */
! 71: static timer *config_timer; /* Timer for scheduled configuration rollback */
! 72:
! 73: /* These are public just for cmd_show_status(), should not be accessed elsewhere */
! 74: int shutting_down; /* Shutdown requested, do not accept new config changes */
! 75: int configuring; /* Reconfiguration is running */
! 76: int undo_available; /* Undo was not requested from last reconfiguration */
! 77: /* Note that both shutting_down and undo_available are related to requests, not processing */
! 78:
! 79: /**
! 80: * config_alloc - allocate a new configuration
! 81: * @name: name of the config
! 82: *
! 83: * This function creates new &config structure, attaches a resource
! 84: * pool and a linear memory pool to it and makes it available for
! 85: * further use. Returns a pointer to the structure.
! 86: */
! 87: struct config *
! 88: config_alloc(const byte *name)
! 89: {
! 90: pool *p = rp_new(&root_pool, "Config");
! 91: linpool *l = lp_new(p, 4080);
! 92: struct config *c = lp_allocz(l, sizeof(struct config));
! 93:
! 94: /* Duplication of name string in local linear pool */
! 95: uint nlen = strlen(name) + 1;
! 96: char *ndup = lp_allocu(l, nlen);
! 97: memcpy(ndup, name, nlen);
! 98:
! 99: c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
! 100: c->pool = p;
! 101: c->mem = l;
! 102: c->file_name = ndup;
! 103: c->load_time = now;
! 104: c->tf_route = c->tf_proto = (struct timeformat){"%T", "%F", 20*3600};
! 105: c->tf_base = c->tf_log = (struct timeformat){"%F %T", NULL, 0};
! 106: c->gr_wait = DEFAULT_GR_WAIT;
! 107:
! 108: return c;
! 109: }
! 110:
! 111: /**
! 112: * config_parse - parse a configuration
! 113: * @c: configuration
! 114: *
! 115: * config_parse() reads input by calling a hook function pointed to
! 116: * by @cf_read_hook and parses it according to the configuration
! 117: * grammar. It also calls all the preconfig and postconfig hooks
! 118: * before, resp. after parsing.
! 119: *
! 120: * Result: 1 if the config has been parsed successfully, 0 if any
! 121: * error has occurred (such as anybody calling cf_error()) and
! 122: * the @err_msg field has been set to the error message.
! 123: */
! 124: int
! 125: config_parse(struct config *c)
! 126: {
! 127: int done = 0;
! 128: DBG("Parsing configuration file `%s'\n", c->file_name);
! 129: new_config = c;
! 130: cfg_mem = c->mem;
! 131: if (setjmp(conf_jmpbuf))
! 132: goto cleanup;
! 133:
! 134: cf_lex_init(0, c);
! 135: sysdep_preconfig(c);
! 136: protos_preconfig(c);
! 137: rt_preconfig(c);
! 138: roa_preconfig(c);
! 139: cf_parse();
! 140: protos_postconfig(c);
! 141: if (EMPTY_LIST(c->protos))
! 142: cf_error("No protocol is specified in the config file");
! 143: #ifdef IPV6
! 144: if (!c->router_id)
! 145: cf_error("Router ID must be configured manually on IPv6 routers");
! 146: #endif
! 147: done = 1;
! 148:
! 149: cleanup:
! 150: new_config = NULL;
! 151: cfg_mem = NULL;
! 152: return done;
! 153: }
! 154:
! 155: /**
! 156: * cli_parse - parse a CLI command
! 157: * @c: temporary config structure
! 158: *
! 159: * cli_parse() is similar to config_parse(), but instead of a configuration,
! 160: * it parses a CLI command. See the CLI module for more information.
! 161: */
! 162: int
! 163: cli_parse(struct config *c)
! 164: {
! 165: int done = 0;
! 166: c->sym_fallback = config->sym_hash;
! 167: new_config = c;
! 168: cfg_mem = c->mem;
! 169: if (setjmp(conf_jmpbuf))
! 170: goto cleanup;
! 171:
! 172: cf_lex_init(1, c);
! 173: cf_parse();
! 174: done = 1;
! 175:
! 176: cleanup:
! 177: c->sym_fallback = NULL;
! 178: new_config = NULL;
! 179: cfg_mem = NULL;
! 180: return done;
! 181: }
! 182:
! 183: /**
! 184: * config_free - free a configuration
! 185: * @c: configuration to be freed
! 186: *
! 187: * This function takes a &config structure and frees all resources
! 188: * associated with it.
! 189: */
! 190: void
! 191: config_free(struct config *c)
! 192: {
! 193: if (c)
! 194: rfree(c->pool);
! 195: }
! 196:
! 197: void
! 198: config_add_obstacle(struct config *c)
! 199: {
! 200: DBG("+++ adding obstacle %d\n", c->obstacle_count);
! 201: c->obstacle_count++;
! 202: }
! 203:
! 204: void
! 205: config_del_obstacle(struct config *c)
! 206: {
! 207: DBG("+++ deleting obstacle %d\n", c->obstacle_count);
! 208: c->obstacle_count--;
! 209: if (!c->obstacle_count)
! 210: ev_schedule(config_event);
! 211: }
! 212:
! 213: static int
! 214: global_commit(struct config *new, struct config *old)
! 215: {
! 216: if (!old)
! 217: return 0;
! 218:
! 219: if (!ipa_equal(old->listen_bgp_addr, new->listen_bgp_addr) ||
! 220: (old->listen_bgp_port != new->listen_bgp_port) ||
! 221: (old->listen_bgp_flags != new->listen_bgp_flags))
! 222: log(L_WARN "Reconfiguration of BGP listening socket not implemented, please restart BIRD.");
! 223:
! 224: if (!new->router_id)
! 225: {
! 226: new->router_id = old->router_id;
! 227:
! 228: if (new->router_id_from)
! 229: {
! 230: u32 id = if_choose_router_id(new->router_id_from, old->router_id);
! 231: if (!id)
! 232: log(L_WARN "Cannot determine router ID, using old one");
! 233: else
! 234: new->router_id = id;
! 235: }
! 236: }
! 237:
! 238: return 0;
! 239: }
! 240:
! 241: static int
! 242: config_do_commit(struct config *c, int type)
! 243: {
! 244: if (type == RECONFIG_UNDO)
! 245: {
! 246: c = old_config;
! 247: type = old_cftype;
! 248: }
! 249: else
! 250: config_free(old_config);
! 251:
! 252: old_config = config;
! 253: old_cftype = type;
! 254: config = c;
! 255:
! 256: configuring = 1;
! 257: if (old_config && !config->shutdown)
! 258: log(L_INFO "Reconfiguring");
! 259:
! 260: if (old_config)
! 261: old_config->obstacle_count++;
! 262:
! 263: DBG("sysdep_commit\n");
! 264: int force_restart = sysdep_commit(c, old_config);
! 265: DBG("global_commit\n");
! 266: force_restart |= global_commit(c, old_config);
! 267: DBG("rt_commit\n");
! 268: rt_commit(c, old_config);
! 269: roa_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 (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, int timeout)
! 333: {
! 334: if (shutting_down)
! 335: {
! 336: config_free(c);
! 337: return CONF_SHUTDOWN;
! 338: }
! 339:
! 340: undo_available = 1;
! 341: if (timeout > 0)
! 342: tm_start(config_timer, timeout);
! 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: extern void cmd_reconfig_undo_notify(void);
! 451:
! 452: static void
! 453: config_timeout(struct timer *t UNUSED)
! 454: {
! 455: log(L_INFO "Config timeout expired, starting undo");
! 456: cmd_reconfig_undo_notify();
! 457:
! 458: int r = config_undo();
! 459: if (r < 0)
! 460: log(L_ERR "Undo request failed");
! 461: }
! 462:
! 463: void
! 464: config_init(void)
! 465: {
! 466: config_event = ev_new(&root_pool);
! 467: config_event->hook = config_done;
! 468:
! 469: config_timer = tm_new(&root_pool);
! 470: config_timer->hook = config_timeout;
! 471: }
! 472:
! 473: /**
! 474: * order_shutdown - order BIRD shutdown
! 475: *
! 476: * This function initiates shutdown of BIRD. It's accomplished by asking
! 477: * for switching to an empty configuration.
! 478: */
! 479: void
! 480: order_shutdown(void)
! 481: {
! 482: struct config *c;
! 483:
! 484: if (shutting_down)
! 485: return;
! 486:
! 487: log(L_INFO "Shutting down");
! 488: c = lp_alloc(config->mem, sizeof(struct config));
! 489: memcpy(c, config, sizeof(struct config));
! 490: init_list(&c->protos);
! 491: init_list(&c->tables);
! 492: c->shutdown = 1;
! 493:
! 494: config_commit(c, RECONFIG_HARD, 0);
! 495: shutting_down = 1;
! 496: }
! 497:
! 498: /**
! 499: * cf_error - report a configuration error
! 500: * @msg: printf-like format string
! 501: *
! 502: * cf_error() can be called during execution of config_parse(), that is
! 503: * from the parser, a preconfig hook or a postconfig hook, to report an
! 504: * error in the configuration.
! 505: */
! 506: void
! 507: cf_error(char *msg, ...)
! 508: {
! 509: char buf[1024];
! 510: va_list args;
! 511:
! 512: va_start(args, msg);
! 513: if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
! 514: strcpy(buf, "<bug: error message too long>");
! 515: va_end(args);
! 516: new_config->err_msg = cfg_strdup(buf);
! 517: new_config->err_lino = ifs->lino;
! 518: new_config->err_file_name = ifs->file_name;
! 519: cf_lex_unwind();
! 520: longjmp(conf_jmpbuf, 1);
! 521: }
! 522:
! 523: /**
! 524: * cfg_strdup - copy a string to config memory
! 525: * @c: string to copy
! 526: *
! 527: * cfg_strdup() creates a new copy of the string in the memory
! 528: * pool associated with the configuration being currently parsed.
! 529: * It's often used when a string literal occurs in the configuration
! 530: * and we want to preserve it for further use.
! 531: */
! 532: char *
! 533: cfg_strdup(const char *c)
! 534: {
! 535: int l = strlen(c) + 1;
! 536: char *z = cfg_allocu(l);
! 537: memcpy(z, c, l);
! 538: return z;
! 539: }
! 540:
! 541:
! 542: void
! 543: cfg_copy_list(list *dest, list *src, unsigned node_size)
! 544: {
! 545: node *dn, *sn;
! 546:
! 547: init_list(dest);
! 548: WALK_LIST(sn, *src)
! 549: {
! 550: dn = cfg_alloc(node_size);
! 551: memcpy(dn, sn, node_size);
! 552: add_tail(dest, dn);
! 553: }
! 554: }
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 / bird / conf