Statistics
| Branch: | Revision:

iof-bird-daemon / conf / conf.c @ fe9f1a6d

History | View | Annotate | Download (14.6 KB)

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 there is one 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). The stored @old_config 
27
 * is also used for undo reconfiguration, which works in a similar way.
28
 * Reconfiguration could also have timeout (using @config_timer) and undo
29
 * is automatically called if the new configuration is not confirmed later.
30
 *
31
 * Loading of new configuration is very simple: just call config_alloc()
32
 * to get a new &config structure, then use config_parse() to parse a
33
 * configuration file and fill all fields of the structure
34
 * and finally ask the config manager to switch to the new
35
 * 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(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
  c->mrtdump_file = -1; /* Hack, this should be sysdep-specific */
95
  c->pool = p;
96
  cfg_mem = c->mem = l;
97
  c->file_name = cfg_strdup(name);
98
  c->load_time = now;
99
  c->tf_route = c->tf_proto = (struct timeformat){"%T", "%F", 20*3600};
100
  c->tf_base = c->tf_log = (struct timeformat){"%F %T", NULL, 0};
101
  c->gr_wait = DEFAULT_GR_WAIT;
102

    
103
  return c;
104
}
105

    
106
/**
107
 * config_parse - parse a configuration
108
 * @c: configuration
109
 *
110
 * config_parse() reads input by calling a hook function pointed to
111
 * by @cf_read_hook and parses it according to the configuration
112
 * grammar. It also calls all the preconfig and postconfig hooks
113
 * before, resp. after parsing.
114
 *
115
 * Result: 1 if the config has been parsed successfully, 0 if any
116
 * error has occurred (such as anybody calling cf_error()) and
117
 * the @err_msg field has been set to the error message.
118
 */
119
int
120
config_parse(struct config *c)
121
{
122
  DBG("Parsing configuration file `%s'\n", c->file_name);
123
  new_config = c;
124
  cfg_mem = c->mem;
125
  if (setjmp(conf_jmpbuf))
126
    return 0;
127
  cf_lex_init(0, c);
128
  sysdep_preconfig(c);
129
  protos_preconfig(c);
130
  rt_preconfig(c);
131
  roa_preconfig(c);
132
  cf_parse();
133
  protos_postconfig(c);
134
  if (EMPTY_LIST(c->protos))
135
    cf_error("No protocol is specified in the config file");
136
  /* XXXX */
137
  if (!c->router_id)
138
    cf_error("Router ID must be configured manually");
139

    
140
  return 1;
141
}
142

    
143
/**
144
 * cli_parse - parse a CLI command
145
 * @c: temporary config structure
146
 *
147
 * cli_parse() is similar to config_parse(), but instead of a configuration,
148
 * it parses a CLI command. See the CLI module for more information.
149
 */
150
int
151
cli_parse(struct config *c)
152
{
153
  new_config = c;
154
  c->sym_fallback = config->sym_hash;
155
  cfg_mem = c->mem;
156
  if (setjmp(conf_jmpbuf))
157
    return 0;
158
  cf_lex_init(1, c);
159
  cf_parse();
160
  return 1;
161
}
162

    
163
/**
164
 * config_free - free a configuration
165
 * @c: configuration to be freed
166
 *
167
 * This function takes a &config structure and frees all resources
168
 * associated with it.
169
 */
170
void
171
config_free(struct config *c)
172
{
173
  if (c)
174
    rfree(c->pool);
175
}
176

    
177
void
178
config_add_obstacle(struct config *c)
179
{
180
  DBG("+++ adding obstacle %d\n", c->obstacle_count);
181
  c->obstacle_count++;
182
}
183

    
184
void
185
config_del_obstacle(struct config *c)
186
{
187
  DBG("+++ deleting obstacle %d\n", c->obstacle_count);
188
  c->obstacle_count--;
189
  if (!c->obstacle_count)
190
    ev_schedule(config_event);
191
}
192

    
193
static int
194
global_commit(struct config *new, struct config *old)
195
{
196
  if (!old)
197
    return 0;
198

    
199
  if (!ipa_equal(old->listen_bgp_addr, new->listen_bgp_addr) ||
200
      (old->listen_bgp_port != new->listen_bgp_port) ||
201
      (old->listen_bgp_flags != new->listen_bgp_flags))
202
    log(L_WARN "Reconfiguration of BGP listening socket not implemented, please restart BIRD.");
203

    
204
  if (!new->router_id)
205
    {
206
      new->router_id = old->router_id;
207

    
208
      if (new->router_id_from)
209
        {
210
          u32 id = if_choose_router_id(new->router_id_from, old->router_id);
211
          if (!id)
212
            log(L_WARN "Cannot determine router ID, using old one");
213
          else
214
            new->router_id = id;
215
        }
216
    }
217

    
218
  return 0;
219
}
220

    
221
static int
222
config_do_commit(struct config *c, int type)
223
{
224
  if (type == RECONFIG_UNDO)
225
    {
226
      c = old_config;
227
      type = old_cftype;
228
    }
229
  else
230
    config_free(old_config);
231

    
232
  old_config = config;
233
  old_cftype = type;
234
  config = c;
235

    
236
  configuring = 1;
237
  if (old_config && !config->shutdown)
238
    log(L_INFO "Reconfiguring");
239

    
240
  /* This should not be necessary, but it seems there are some
241
     functions that access new_config instead of config */
242
  new_config = config;
243

    
244
  if (old_config)
245
    old_config->obstacle_count++;
246

    
247
  DBG("sysdep_commit\n");
248
  int force_restart = sysdep_commit(c, old_config);
249
  DBG("global_commit\n");
250
  force_restart |= global_commit(c, old_config);
251
  DBG("rt_commit\n");
252
  rt_commit(c, old_config);
253
  roa_commit(c, old_config);
254
  DBG("protos_commit\n");
255
  protos_commit(c, old_config, force_restart, type);
256

    
257
  /* Just to be sure nobody uses that now */
258
  new_config = NULL;
259

    
260
  int obs = 0;
261
  if (old_config)
262
    obs = --old_config->obstacle_count;
263

    
264
  DBG("do_commit finished with %d obstacles remaining\n", obs);
265
  return !obs;
266
}
267

    
268
static void
269
config_done(void *unused UNUSED)
270
{
271
  if (config->shutdown)
272
    sysdep_shutdown_done();
273

    
274
  configuring = 0;
275
  if (old_config)
276
    log(L_INFO "Reconfigured");
277

    
278
  if (future_cftype)
279
    {
280
      int type = future_cftype;
281
      struct config *conf = future_config;
282
      future_cftype = RECONFIG_NONE;
283
      future_config = NULL;
284

    
285
      log(L_INFO "Reconfiguring to queued configuration");
286
      if (config_do_commit(conf, type))
287
        config_done(NULL);
288
    }
289
}
290

    
291
/**
292
 * config_commit - commit a configuration
293
 * @c: new configuration
294
 * @type: type of reconfiguration (RECONFIG_SOFT or RECONFIG_HARD)
295
 * @timeout: timeout for undo (or 0 for no timeout)
296
 *
297
 * When a configuration is parsed and prepared for use, the
298
 * config_commit() function starts the process of reconfiguration.
299
 * It checks whether there is already a reconfiguration in progress
300
 * in which case it just queues the new config for later processing.
301
 * Else it notifies all modules about the new configuration by calling
302
 * their commit() functions which can either accept it immediately
303
 * or call config_add_obstacle() to report that they need some time
304
 * to complete the reconfiguration. After all such obstacles are removed
305
 * using config_del_obstacle(), the old configuration is freed and
306
 * everything runs according to the new one.
307
 *
308
 * When @timeout is nonzero, the undo timer is activated with given
309
 * timeout. The timer is deactivated when config_commit(),
310
 * config_confirm() or config_undo() is called.
311
 *
312
 * Result: %CONF_DONE if the configuration has been accepted immediately,
313
 * %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
314
 * if it's been queued due to another reconfiguration being in progress now
315
 * or %CONF_SHUTDOWN if BIRD is in shutdown mode and no new configurations
316
 * are accepted.
317
 */
318
int
319
config_commit(struct config *c, int type, int timeout)
320
{
321
  if (shutting_down)
322
    {
323
      config_free(c);
324
      return CONF_SHUTDOWN;
325
    }
326

    
327
  undo_available = 1;
328
  if (timeout > 0)
329
    tm_start(config_timer, timeout);
330
  else
331
    tm_stop(config_timer);
332

    
333
  if (configuring)
334
    {
335
      if (future_cftype)
336
        {
337
          log(L_INFO "Queueing new configuration, ignoring the one already queued");
338
          config_free(future_config);
339
        }
340
      else
341
        log(L_INFO "Queueing new configuration");
342

    
343
      future_cftype = type;
344
      future_config = c;
345
      return CONF_QUEUED;
346
    }
347

    
348
  if (config_do_commit(c, type))
349
    {
350
      config_done(NULL);
351
      return CONF_DONE;
352
    }
353
  return CONF_PROGRESS;
354
}
355

    
356
/**
357
 * config_confirm - confirm a commited configuration
358
 *
359
 * When the undo timer is activated by config_commit() with nonzero timeout,
360
 * this function can be used to deactivate it and therefore confirm
361
 * the current configuration.
362
 *
363
 * Result: %CONF_CONFIRM when the current configuration is confirmed,
364
 * %CONF_NONE when there is nothing to confirm (i.e. undo timer is not active).
365
 */
366
int
367
config_confirm(void)
368
{
369
  if (config_timer->expires == 0)
370
    return CONF_NOTHING;
371

    
372
  tm_stop(config_timer);
373

    
374
  return CONF_CONFIRM;
375
}
376

    
377
/**
378
 * config_undo - undo a configuration
379
 *
380
 * Function config_undo() can be used to change the current
381
 * configuration back to stored %old_config. If no reconfiguration is
382
 * running, this stored configuration is commited in the same way as a
383
 * new configuration in config_commit(). If there is already a
384
 * reconfiguration in progress and no next reconfiguration is
385
 * scheduled, then the undo is scheduled for later processing as
386
 * usual, but if another reconfiguration is already scheduled, then
387
 * such reconfiguration is removed instead (i.e. undo is applied on
388
 * the last commit that scheduled it).
389
 *
390
 * Result: %CONF_DONE if the configuration has been accepted immediately,
391
 * %CONF_PROGRESS if it will take some time to switch to it, %CONF_QUEUED
392
 * if it's been queued due to another reconfiguration being in progress now,
393
 * %CONF_UNQUEUED if a scheduled reconfiguration is removed, %CONF_NOTHING
394
 * if there is no relevant configuration to undo (the previous config request
395
 * was config_undo() too)  or %CONF_SHUTDOWN if BIRD is in shutdown mode and 
396
 * no new configuration changes  are accepted.
397
 */
398
int
399
config_undo(void)
400
{
401
  if (shutting_down)
402
    return CONF_SHUTDOWN;
403

    
404
  if (!undo_available || !old_config)
405
    return CONF_NOTHING;
406

    
407
  undo_available = 0;
408
  tm_stop(config_timer);
409

    
410
  if (configuring)
411
    {
412
      if (future_cftype)
413
        {
414
          config_free(future_config);
415
          future_config = NULL;
416

    
417
          log(L_INFO "Removing queued configuration");
418
          future_cftype = RECONFIG_NONE;
419
          return CONF_UNQUEUED;
420
        }
421
      else
422
        {
423
          log(L_INFO "Queueing undo configuration");
424
          future_cftype = RECONFIG_UNDO;
425
          return CONF_QUEUED;
426
        }
427
    }
428

    
429
  if (config_do_commit(NULL, RECONFIG_UNDO))
430
    {
431
      config_done(NULL);
432
      return CONF_DONE;
433
    }
434
  return CONF_PROGRESS;
435
}
436

    
437
extern void cmd_reconfig_undo_notify(void);
438

    
439
static void
440
config_timeout(struct timer *t)
441
{
442
  log(L_INFO "Config timeout expired, starting undo");
443
  cmd_reconfig_undo_notify();
444

    
445
  int r = config_undo();
446
  if (r < 0)
447
    log(L_ERR "Undo request failed");
448
}
449

    
450
void
451
config_init(void)
452
{
453
  config_event = ev_new(&root_pool);
454
  config_event->hook = config_done;
455

    
456
  config_timer = tm_new(&root_pool);
457
  config_timer->hook = config_timeout;
458
}
459

    
460
/**
461
 * order_shutdown - order BIRD shutdown
462
 *
463
 * This function initiates shutdown of BIRD. It's accomplished by asking
464
 * for switching to an empty configuration.
465
 */
466
void
467
order_shutdown(void)
468
{
469
  struct config *c;
470

    
471
  if (shutting_down)
472
    return;
473

    
474
  log(L_INFO "Shutting down");
475
  c = lp_alloc(config->mem, sizeof(struct config));
476
  memcpy(c, config, sizeof(struct config));
477
  init_list(&c->protos);
478
  init_list(&c->tables);
479
  c->shutdown = 1;
480

    
481
  config_commit(c, RECONFIG_HARD, 0);
482
  shutting_down = 1;
483
}
484

    
485
/**
486
 * cf_error - report a configuration error
487
 * @msg: printf-like format string
488
 *
489
 * cf_error() can be called during execution of config_parse(), that is
490
 * from the parser, a preconfig hook or a postconfig hook, to report an
491
 * error in the configuration.
492
 */
493
void
494
cf_error(char *msg, ...)
495
{
496
  char buf[1024];
497
  va_list args;
498

    
499
  va_start(args, msg);
500
  if (bvsnprintf(buf, sizeof(buf), msg, args) < 0)
501
    strcpy(buf, "<bug: error message too long>");
502
  new_config->err_msg = cfg_strdup(buf);
503
  new_config->err_lino = ifs->lino;
504
  new_config->err_file_name = ifs->file_name;
505
  cf_lex_unwind();
506
  longjmp(conf_jmpbuf, 1);
507
}
508

    
509
/**
510
 * cfg_strdup - copy a string to config memory
511
 * @c: string to copy
512
 *
513
 * cfg_strdup() creates a new copy of the string in the memory
514
 * pool associated with the configuration being currently parsed.
515
 * It's often used when a string literal occurs in the configuration
516
 * and we want to preserve it for further use.
517
 */
518
char *
519
cfg_strdup(char *c)
520
{
521
  int l = strlen(c) + 1;
522
  char *z = cfg_allocu(l);
523
  memcpy(z, c, l);
524
  return z;
525
}
526

    
527

    
528
void
529
cfg_copy_list(list *dest, list *src, unsigned node_size)
530
{
531
  node *dn, *sn;
532

    
533
  init_list(dest);
534
  WALK_LIST(sn, *src)
535
  {
536
    dn = cfg_alloc(node_size);
537
    memcpy(dn, sn, node_size);
538
    add_tail(dest, dn);
539
  }
540
}