Statistics
| Branch: | Revision:

iof-bird / bird-2.0.1 / sysdep / unix / main.c @ 6b3f1a54

History | View | Annotate | Download (16 KB)

1
/*
2
 *        BIRD Internet Routing Daemon -- Unix Entry Point
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
#undef LOCAL_DEBUG
10

    
11
#ifndef _GNU_SOURCE
12
#define _GNU_SOURCE
13
#endif
14

    
15
#include <stdio.h>
16
#include <stdlib.h>
17
#include <fcntl.h>
18
#include <unistd.h>
19
#include <signal.h>
20
#include <pwd.h>
21
#include <grp.h>
22
#include <sys/stat.h>
23
#include <libgen.h>
24

    
25
#include "nest/bird.h"
26
#include "lib/lists.h"
27
#include "lib/resource.h"
28
#include "lib/socket.h"
29
#include "lib/event.h"
30
#include "lib/timer.h"
31
#include "lib/string.h"
32
#include "nest/route.h"
33
#include "nest/protocol.h"
34
#include "nest/iface.h"
35
#include "nest/cli.h"
36
#include "nest/locks.h"
37
#include "conf/conf.h"
38
#include "filter/filter.h"
39

    
40
#include "unix.h"
41
#include "krt.h"
42

    
43
/*
44
 *        Debugging
45
 */
46

    
47
#ifdef DEBUGGING
48
static int debug_flag = 1;
49
#else
50
static int debug_flag = 0;
51
#endif
52

    
53
void
54
async_dump(void)
55
{
56
  debug("INTERNAL STATE DUMP\n\n");
57

    
58
  rdump(&root_pool);
59
  sk_dump_all();
60
  // XXXX tm_dump_all();
61
  if_dump_all();
62
  neigh_dump_all();
63
  rta_dump_all();
64
  rt_dump_all();
65
  protos_dump_all();
66

    
67
  debug("\n");
68
}
69

    
70
/*
71
 *        Dropping privileges
72
 */
73

    
74
#ifdef CONFIG_RESTRICTED_PRIVILEGES
75
#include CONFIG_INCLUDE_SYSPRIV_H
76
#else
77

    
78
static inline void
79
drop_uid(uid_t uid UNUSED)
80
{
81
  die("Cannot change user on this platform");
82
}
83

    
84
#endif
85

    
86
static inline void
87
drop_gid(gid_t gid)
88
{
89
  if (setgid(gid) < 0)
90
    die("setgid: %m");
91
}
92

    
93
/*
94
 *        Reading the Configuration
95
 */
96

    
97
#ifdef PATH_IPROUTE_DIR
98

    
99
static inline void
100
add_num_const(char *name, int val)
101
{
102
  struct symbol *s = cf_get_symbol(name);
103
  s->class = SYM_CONSTANT | T_INT;
104
  s->def = cfg_allocz(sizeof(struct f_val));
105
  SYM_TYPE(s) = T_INT;
106
  SYM_VAL(s).i = val;
107
}
108

    
109
/* the code of read_iproute_table() is based on
110
   rtnl_tab_initialize() from iproute2 package */
111
static void
112
read_iproute_table(char *file, char *prefix, int max)
113
{
114
  char buf[512], namebuf[512];
115
  char *name;
116
  int val;
117
  FILE *fp;
118

    
119
  strcpy(namebuf, prefix);
120
  name = namebuf + strlen(prefix);
121

    
122
  fp = fopen(file, "r");
123
  if (!fp)
124
    return;
125

    
126
  while (fgets(buf, sizeof(buf), fp))
127
  {
128
    char *p = buf;
129

    
130
    while (*p == ' ' || *p == '\t')
131
      p++;
132

    
133
    if (*p == '#' || *p == '\n' || *p == 0)
134
      continue;
135
   
136
    if (sscanf(p, "0x%x %s\n", &val, name) != 2 &&
137
        sscanf(p, "0x%x %s #", &val, name) != 2 &&
138
        sscanf(p, "%d %s\n", &val, name) != 2 &&
139
        sscanf(p, "%d %s #", &val, name) != 2)
140
      continue;
141

    
142
    if (val < 0 || val > max)
143
      continue;
144

    
145
    for(p = name; *p; p++)
146
      if ((*p < 'a' || *p > 'z') && (*p < '0' || *p > '9') && (*p != '_'))
147
        *p = '_';
148

    
149
    add_num_const(namebuf, val);
150
  }
151

    
152
  fclose(fp);
153
}
154

    
155
#endif // PATH_IPROUTE_DIR
156

    
157

    
158
static char *config_name = PATH_CONFIG_FILE;
159

    
160
static int
161
cf_read(byte *dest, uint len, int fd)
162
{
163
  int l = read(fd, dest, len);
164
  if (l < 0)
165
    cf_error("Read error");
166
  return l;
167
}
168

    
169
void
170
sysdep_preconfig(struct config *c)
171
{
172
  init_list(&c->logfiles);
173

    
174
  c->latency_limit = UNIX_DEFAULT_LATENCY_LIMIT;
175
  c->watchdog_warning = UNIX_DEFAULT_WATCHDOG_WARNING;
176

    
177
#ifdef PATH_IPROUTE_DIR
178
  read_iproute_table(PATH_IPROUTE_DIR "/rt_protos", "ipp_", 256);
179
  read_iproute_table(PATH_IPROUTE_DIR "/rt_realms", "ipr_", 256);
180
  read_iproute_table(PATH_IPROUTE_DIR "/rt_scopes", "ips_", 256);
181
  read_iproute_table(PATH_IPROUTE_DIR "/rt_tables", "ipt_", 256);
182
#endif
183
}
184

    
185
int
186
sysdep_commit(struct config *new, struct config *old UNUSED)
187
{
188
  log_switch(debug_flag, &new->logfiles, new->syslog_name);
189
  return 0;
190
}
191

    
192
static int
193
unix_read_config(struct config **cp, char *name)
194
{
195
  struct config *conf = config_alloc(name);
196
  int ret;
197

    
198
  *cp = conf;
199
  conf->file_fd = open(name, O_RDONLY);
200
  if (conf->file_fd < 0)
201
    return 0;
202
  cf_read_hook = cf_read;
203
  ret = config_parse(conf);
204
  close(conf->file_fd);
205
  return ret;
206
}
207

    
208
static struct config *
209
read_config(void)
210
{
211
  struct config *conf;
212

    
213
  if (!unix_read_config(&conf, config_name))
214
    {
215
      if (conf->err_msg)
216
        die("%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
217
      else
218
        die("Unable to open configuration file %s: %m", config_name);
219
    }
220

    
221
  return conf;
222
}
223

    
224
void
225
async_config(void)
226
{
227
  struct config *conf;
228

    
229
  log(L_INFO "Reconfiguration requested by SIGHUP");
230
  if (!unix_read_config(&conf, config_name))
231
    {
232
      if (conf->err_msg)
233
        log(L_ERR "%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
234
      else
235
        log(L_ERR "Unable to open configuration file %s: %m", config_name);
236
      config_free(conf);
237
    }
238
  else
239
    config_commit(conf, RECONFIG_HARD, 0);
240
}
241

    
242
static struct config *
243
cmd_read_config(char *name)
244
{
245
  struct config *conf;
246

    
247
  if (!name)
248
    name = config_name;
249

    
250
  cli_msg(-2, "Reading configuration from %s", name);
251
  if (!unix_read_config(&conf, name))
252
    {
253
      if (conf->err_msg)
254
        cli_msg(8002, "%s, line %d: %s", conf->err_file_name, conf->err_lino, conf->err_msg);
255
      else
256
        cli_msg(8002, "%s: %m", name);
257
      config_free(conf);
258
      conf = NULL;
259
    }
260

    
261
  return conf;
262
}
263

    
264
void
265
cmd_check_config(char *name)
266
{
267
  struct config *conf = cmd_read_config(name);
268
  if (!conf)
269
    return;
270

    
271
  cli_msg(20, "Configuration OK");
272
  config_free(conf);
273
}
274

    
275
static void
276
cmd_reconfig_msg(int r)
277
{
278
  switch (r)
279
    {
280
    case CONF_DONE:        cli_msg( 3, "Reconfigured"); break;
281
    case CONF_PROGRESS: cli_msg( 4, "Reconfiguration in progress"); break;
282
    case CONF_QUEUED:        cli_msg( 5, "Reconfiguration already in progress, queueing new config"); break;
283
    case CONF_UNQUEUED:        cli_msg(17, "Reconfiguration already in progress, removing queued config"); break;
284
    case CONF_CONFIRM:        cli_msg(18, "Reconfiguration confirmed"); break;
285
    case CONF_SHUTDOWN:        cli_msg( 6, "Reconfiguration ignored, shutting down"); break;
286
    case CONF_NOTHING:        cli_msg(19, "Nothing to do"); break;
287
    default:                break;
288
    }
289
}
290

    
291
/* Hack for scheduled undo notification */
292
cli *cmd_reconfig_stored_cli;
293

    
294
void
295
cmd_reconfig_undo_notify(void)
296
{
297
  if (cmd_reconfig_stored_cli)
298
    {
299
      cli *c = cmd_reconfig_stored_cli;
300
      cli_printf(c, CLI_ASYNC_CODE, "Config timeout expired, starting undo");
301
      cli_write_trigger(c);
302
    }
303
}
304

    
305
void
306
cmd_reconfig(char *name, int type, uint timeout)
307
{
308
  if (cli_access_restricted())
309
    return;
310

    
311
  struct config *conf = cmd_read_config(name);
312
  if (!conf)
313
    return;
314

    
315
  int r = config_commit(conf, type, timeout);
316

    
317
  if ((r >= 0) && (timeout > 0))
318
    {
319
      cmd_reconfig_stored_cli = this_cli;
320
      cli_msg(-22, "Undo scheduled in %d s", timeout);
321
    }
322

    
323
  cmd_reconfig_msg(r);
324
}
325

    
326
void
327
cmd_reconfig_confirm(void)
328
{
329
  if (cli_access_restricted())
330
    return;
331

    
332
  int r = config_confirm();
333
  cmd_reconfig_msg(r);
334
}
335

    
336
void
337
cmd_reconfig_undo(void)
338
{
339
  if (cli_access_restricted())
340
    return;
341

    
342
  cli_msg(-21, "Undo requested");
343

    
344
  int r = config_undo();
345
  cmd_reconfig_msg(r);
346
}
347

    
348
/*
349
 *        Command-Line Interface
350
 */
351

    
352
static sock *cli_sk;
353
static char *path_control_socket = PATH_CONTROL_SOCKET;
354

    
355

    
356
static void
357
cli_write(cli *c)
358
{
359
  sock *s = c->priv;
360

    
361
  while (c->tx_pos)
362
    {
363
      struct cli_out *o = c->tx_pos;
364

    
365
      int len = o->wpos - o->outpos;
366
      s->tbuf = o->outpos;
367
      o->outpos = o->wpos;
368

    
369
      if (sk_send(s, len) <= 0)
370
        return;
371

    
372
      c->tx_pos = o->next;
373
    }
374

    
375
  /* Everything is written */
376
  s->tbuf = NULL;
377
  cli_written(c);
378
}
379

    
380
void
381
cli_write_trigger(cli *c)
382
{
383
  sock *s = c->priv;
384

    
385
  if (s->tbuf == NULL)
386
    cli_write(c);
387
}
388

    
389
static void
390
cli_tx(sock *s)
391
{
392
  cli_write(s->data);
393
}
394

    
395
int
396
cli_get_command(cli *c)
397
{
398
  sock *s = c->priv;
399
  byte *t = c->rx_aux ? : s->rbuf;
400
  byte *tend = s->rpos;
401
  byte *d = c->rx_pos;
402
  byte *dend = c->rx_buf + CLI_RX_BUF_SIZE - 2;
403

    
404
  while (t < tend)
405
    {
406
      if (*t == '\r')
407
        t++;
408
      else if (*t == '\n')
409
        {
410
          t++;
411
          c->rx_pos = c->rx_buf;
412
          c->rx_aux = t;
413
          *d = 0;
414
          return (d < dend) ? 1 : -1;
415
        }
416
      else if (d < dend)
417
        *d++ = *t++;
418
    }
419
  c->rx_aux = s->rpos = s->rbuf;
420
  c->rx_pos = d;
421
  return 0;
422
}
423

    
424
static int
425
cli_rx(sock *s, uint size UNUSED)
426
{
427
  cli_kick(s->data);
428
  return 0;
429
}
430

    
431
static void
432
cli_err(sock *s, int err)
433
{
434
  if (config->cli_debug)
435
    {
436
      if (err)
437
        log(L_INFO "CLI connection dropped: %s", strerror(err));
438
      else
439
        log(L_INFO "CLI connection closed");
440
    }
441
  cli_free(s->data);
442
}
443

    
444
static int
445
cli_connect(sock *s, uint size UNUSED)
446
{
447
  cli *c;
448

    
449
  if (config->cli_debug)
450
    log(L_INFO "CLI connect");
451
  s->rx_hook = cli_rx;
452
  s->tx_hook = cli_tx;
453
  s->err_hook = cli_err;
454
  s->data = c = cli_new(s);
455
  s->pool = c->pool;                /* We need to have all the socket buffers allocated in the cli pool */
456
  s->fast_rx = 1;
457
  c->rx_pos = c->rx_buf;
458
  c->rx_aux = NULL;
459
  rmove(s, c->pool);
460
  return 1;
461
}
462

    
463
static void
464
cli_init_unix(uid_t use_uid, gid_t use_gid)
465
{
466
  sock *s;
467

    
468
  cli_init();
469
  s = cli_sk = sk_new(cli_pool);
470
  s->type = SK_UNIX_PASSIVE;
471
  s->rx_hook = cli_connect;
472
  s->rbsize = 1024;
473
  s->fast_rx = 1;
474

    
475
  /* Return value intentionally ignored */
476
  unlink(path_control_socket);
477

    
478
  if (sk_open_unix(s, path_control_socket) < 0)
479
    die("Cannot create control socket %s: %m", path_control_socket);
480

    
481
  if (use_uid || use_gid)
482
    if (chown(path_control_socket, use_uid, use_gid) < 0)
483
      die("chown: %m");
484

    
485
  if (chmod(path_control_socket, 0660) < 0)
486
    die("chmod: %m");
487
}
488

    
489
/*
490
 *        PID file
491
 */
492

    
493
static char *pid_file;
494
static int pid_fd;
495

    
496
static inline void
497
open_pid_file(void)
498
{
499
  if (!pid_file)
500
    return;
501

    
502
  pid_fd = open(pid_file, O_WRONLY|O_CREAT, 0664);
503
  if (pid_fd < 0)
504
    die("Cannot create PID file %s: %m", pid_file);
505
}
506

    
507
static inline void
508
write_pid_file(void)
509
{
510
  int pl, rv;
511
  char ps[24];
512

    
513
  if (!pid_file)
514
    return;
515

    
516
  /* We don't use PID file for uniqueness, so no need for locking */
517

    
518
  pl = bsnprintf(ps, sizeof(ps), "%ld\n", (long) getpid());
519
  if (pl < 0)
520
    bug("PID buffer too small");
521

    
522
  rv = ftruncate(pid_fd, 0);
523
  if (rv < 0)
524
    die("fruncate: %m");
525
    
526
  rv = write(pid_fd, ps, pl);
527
  if(rv < 0)
528
    die("write: %m");
529

    
530
  close(pid_fd);
531
}
532

    
533
static inline void
534
unlink_pid_file(void)
535
{
536
  if (pid_file)
537
    unlink(pid_file);
538
}
539

    
540

    
541
/*
542
 *        Shutdown
543
 */
544

    
545
void
546
cmd_shutdown(void)
547
{
548
  if (cli_access_restricted())
549
    return;
550

    
551
  cli_msg(7, "Shutdown requested");
552
  order_shutdown();
553
}
554

    
555
void
556
async_shutdown(void)
557
{
558
  DBG("Shutting down...\n");
559
  order_shutdown();
560
}
561

    
562
void
563
sysdep_shutdown_done(void)
564
{
565
  unlink_pid_file();
566
  unlink(path_control_socket);
567
  log_msg(L_FATAL "Shutdown completed");
568
  exit(0);
569
}
570

    
571
/*
572
 *        Signals
573
 */
574

    
575
volatile int async_config_flag;
576
volatile int async_dump_flag;
577
volatile int async_shutdown_flag;
578

    
579
static void
580
handle_sighup(int sig UNUSED)
581
{
582
  DBG("Caught SIGHUP...\n");
583
  async_config_flag = 1;
584
}
585

    
586
static void
587
handle_sigusr(int sig UNUSED)
588
{
589
  DBG("Caught SIGUSR...\n");
590
  async_dump_flag = 1;
591
}
592

    
593
static void
594
handle_sigterm(int sig UNUSED)
595
{
596
  DBG("Caught SIGTERM...\n");
597
  async_shutdown_flag = 1;
598
}
599

    
600
void watchdog_sigalrm(int sig UNUSED);
601

    
602
static void
603
signal_init(void)
604
{
605
  struct sigaction sa;
606

    
607
  bzero(&sa, sizeof(sa));
608
  sa.sa_handler = handle_sigusr;
609
  sa.sa_flags = SA_RESTART;
610
  sigaction(SIGUSR1, &sa, NULL);
611
  sa.sa_handler = handle_sighup;
612
  sa.sa_flags = SA_RESTART;
613
  sigaction(SIGHUP, &sa, NULL);
614
  sa.sa_handler = handle_sigterm;
615
  sa.sa_flags = SA_RESTART;
616
  sigaction(SIGTERM, &sa, NULL);
617
  sa.sa_handler = watchdog_sigalrm;
618
  sa.sa_flags = 0;
619
  sigaction(SIGALRM, &sa, NULL);
620
  signal(SIGPIPE, SIG_IGN);
621
}
622

    
623
/*
624
 *        Parsing of command-line arguments
625
 */
626

    
627
static char *opt_list = "c:dD:ps:P:u:g:flRh";
628
static int parse_and_exit;
629
char *bird_name;
630
static char *use_user;
631
static char *use_group;
632
static int run_in_foreground = 0;
633

    
634
static void
635
display_usage(void)
636
{
637
  fprintf(stderr, "Usage: %s [--version] [--help] [-c <config-file>] [OPTIONS]\n", bird_name);
638
}
639

    
640
static void
641
display_help(void)
642
{
643
  display_usage();
644

    
645
  fprintf(stderr,
646
    "\n"
647
    "Options: \n"
648
    "  -c <config-file>     Use given configuration file instead\n"
649
    "                       of prefix/etc/bird.conf\n"
650
    "  -d                   Enable debug messages and run bird in foreground\n"
651
    "  -D <debug-file>      Log debug messages to given file instead of stderr\n"
652
    "  -f                   Run bird in foreground\n"
653
    "  -g <group>           Use given group ID\n"
654
    "  -h, --help           Display this information\n"
655
    "  -l                   Look for a configuration file and a communication socket\n"
656
    "                       file in the current working directory\n"
657
    "  -p                   Test configuration file and exit without start\n"
658
    "  -P <pid-file>        Create a PID file with given filename\n"
659
    "  -R                   Apply graceful restart recovery after start\n"
660
    "  -s <control-socket>  Use given filename for a control socket\n"
661
    "  -u <user>            Drop privileges and use given user ID\n"
662
    "  --version            Display version of BIRD\n");
663

    
664
  exit(0);
665
}
666

    
667
static void
668
display_version(void)
669
{
670
  fprintf(stderr, "BIRD version " BIRD_VERSION "\n");
671
  exit(0);
672
}
673

    
674
static inline char *
675
get_bird_name(char *s, char *def)
676
{
677
  char *t;
678
  if (!s)
679
    return def;
680
  t = strrchr(s, '/');
681
  if (!t)
682
    return s;
683
  if (!t[1])
684
    return def;
685
  return t+1;
686
}
687

    
688
static inline uid_t
689
get_uid(const char *s)
690
{
691
  struct passwd *pw;
692
  char *endptr;
693
  long int rv;
694

    
695
  if (!s)
696
    return 0;
697

    
698
  errno = 0;
699
  rv = strtol(s, &endptr, 10);
700

    
701
  if (!errno && !*endptr)
702
    return rv;
703

    
704
  pw = getpwnam(s);
705
  if (!pw)
706
    die("Cannot find user '%s'", s);
707

    
708
  return pw->pw_uid;
709
}
710

    
711
static inline gid_t
712
get_gid(const char *s)
713
{
714
  struct group *gr;
715
  char *endptr;
716
  long int rv;
717

    
718
  if (!s)
719
    return 0;
720

    
721
  errno = 0;
722
  rv = strtol(s, &endptr, 10);
723

    
724
  if (!errno && !*endptr)
725
    return rv;
726

    
727
  gr = getgrnam(s);
728
  if (!gr)
729
    die("Cannot find group '%s'", s);
730

    
731
  return gr->gr_gid;
732
}
733

    
734
static void
735
parse_args(int argc, char **argv)
736
{
737
  int config_changed = 0;
738
  int socket_changed = 0;
739
  int c;
740

    
741
  bird_name = get_bird_name(argv[0], "bird");
742
  if (argc == 2)
743
    {
744
      if (!strcmp(argv[1], "--version"))
745
        display_version();
746
      if (!strcmp(argv[1], "--help"))
747
        display_help();
748
    }
749
  while ((c = getopt(argc, argv, opt_list)) >= 0)
750
    switch (c)
751
      {
752
      case 'c':
753
        config_name = optarg;
754
        config_changed = 1;
755
        break;
756
      case 'd':
757
        debug_flag |= 1;
758
        break;
759
      case 'D':
760
        log_init_debug(optarg);
761
        debug_flag |= 2;
762
        break;
763
      case 'p':
764
        parse_and_exit = 1;
765
        break;
766
      case 's':
767
        path_control_socket = optarg;
768
        socket_changed = 1;
769
        break;
770
      case 'P':
771
        pid_file = optarg;
772
        break;
773
      case 'u':
774
        use_user = optarg;
775
        break;
776
      case 'g':
777
        use_group = optarg;
778
        break;
779
      case 'f':
780
        run_in_foreground = 1;
781
        break;
782
      case 'l':
783
        if (!config_changed)
784
          config_name = xbasename(config_name);
785
        if (!socket_changed)
786
          path_control_socket = xbasename(path_control_socket);
787
        break;
788
      case 'R':
789
        graceful_restart_recovery();
790
        break;
791
      case 'h':
792
        display_help();
793
        break;
794
      default:
795
        fputc('\n', stderr);
796
        display_usage();
797
        exit(1);
798
      }
799
  if (optind < argc)
800
   {
801
     display_usage();
802
     exit(1);
803
   }
804
}
805

    
806
/*
807
 *        Hic Est main()
808
 */
809

    
810
int
811
main(int argc, char **argv)
812
{
813
#ifdef HAVE_LIBDMALLOC
814
  if (!getenv("DMALLOC_OPTIONS"))
815
    dmalloc_debug(0x2f03d00);
816
#endif
817

    
818
  parse_args(argc, argv);
819
  if (debug_flag == 1)
820
    log_init_debug("");
821
  log_switch(debug_flag, NULL, NULL);
822

    
823
  net_init();
824
  resource_init();
825
  timer_init();
826
  olock_init();
827
  io_init();
828
  rt_init();
829
  if_init();
830
//  roa_init();
831
  config_init();
832

    
833
  uid_t use_uid = get_uid(use_user);
834
  gid_t use_gid = get_gid(use_group);
835

    
836
  if (!parse_and_exit)
837
  {
838
    test_old_bird(path_control_socket);
839
    cli_init_unix(use_uid, use_gid);
840
  }
841

    
842
  if (use_gid)
843
    drop_gid(use_gid);
844

    
845
  if (use_uid)
846
    drop_uid(use_uid);
847

    
848
  if (!parse_and_exit)
849
    open_pid_file();
850

    
851
  protos_build();
852
  proto_build(&proto_unix_kernel);
853
  proto_build(&proto_unix_iface);
854

    
855
  struct config *conf = read_config();
856

    
857
  if (parse_and_exit)
858
    exit(0);
859

    
860
  if (!(debug_flag||run_in_foreground))
861
    {
862
      pid_t pid = fork();
863
      if (pid < 0)
864
        die("fork: %m");
865
      if (pid)
866
        return 0;
867
      setsid();
868
      close(0);
869
      if (open("/dev/null", O_RDWR) < 0)
870
        die("Cannot open /dev/null: %m");
871
      dup2(0, 1);
872
      dup2(0, 2);
873
    }
874

    
875
  main_thread_init();
876

    
877
  write_pid_file();
878

    
879
  signal_init();
880

    
881
  config_commit(conf, RECONFIG_HARD, 0);
882

    
883
  graceful_restart_init();
884

    
885
#ifdef LOCAL_DEBUG
886
  async_dump_flag = 1;
887
#endif
888

    
889
  log(L_INFO "Started");
890
  DBG("Entering I/O loop.\n");
891

    
892
  io_loop();
893
  bug("I/O loop died");
894
}