Statistics
| Branch: | Revision:

iof-bird-daemon / sysdep / unix / main.c @ 3e236955

History | View | Annotate | Download (15.8 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
#define _GNU_SOURCE 1
12

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

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

    
37
#include "unix.h"
38
#include "krt.h"
39

    
40
/*
41
 *        Debugging
42
 */
43

    
44
#ifdef DEBUGGING
45
static int debug_flag = 1;
46
#else
47
static int debug_flag = 0;
48
#endif
49

    
50
void
51
async_dump(void)
52
{
53
  debug("INTERNAL STATE DUMP\n\n");
54

    
55
  rdump(&root_pool);
56
  sk_dump_all();
57
  tm_dump_all();
58
  if_dump_all();
59
  neigh_dump_all();
60
  rta_dump_all();
61
  rt_dump_all();
62
  protos_dump_all();
63

    
64
  debug("\n");
65
}
66

    
67
/*
68
 *        Dropping privileges
69
 */
70

    
71
#ifdef CONFIG_RESTRICTED_PRIVILEGES
72
#include "lib/syspriv.h"
73
#else
74

    
75
static inline void
76
drop_uid(uid_t uid UNUSED)
77
{
78
  die("Cannot change user on this platform");
79
}
80

    
81
#endif
82

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

    
90
/*
91
 *        Reading the Configuration
92
 */
93

    
94
#ifdef PATH_IPROUTE_DIR
95

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

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

    
116
  strcpy(namebuf, prefix);
117
  name = namebuf + strlen(prefix);
118

    
119
  fp = fopen(file, "r");
120
  if (!fp)
121
    return;
122

    
123
  while (fgets(buf, sizeof(buf), fp))
124
  {
125
    char *p = buf;
126

    
127
    while (*p == ' ' || *p == '\t')
128
      p++;
129

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

    
139
    if (val < 0 || val > max)
140
      continue;
141

    
142
    for(p = name; *p; p++)
143
      if ((*p < 'a' || *p > 'z') && (*p < '0' || *p > '9') && (*p != '_'))
144
        *p = '_';
145

    
146
    add_num_const(namebuf, val);
147
  }
148

    
149
  fclose(fp);
150
}
151

    
152
#endif // PATH_IPROUTE_DIR
153

    
154

    
155
static char *config_name = PATH_CONFIG_FILE;
156

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

    
166
void
167
sysdep_preconfig(struct config *c)
168
{
169
  init_list(&c->logfiles);
170

    
171
  c->latency_limit = UNIX_DEFAULT_LATENCY_LIMIT;
172
  c->watchdog_warning = UNIX_DEFAULT_WATCHDOG_WARNING;
173

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

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

    
189
static int
190
unix_read_config(struct config **cp, char *name)
191
{
192
  struct config *conf = config_alloc(name);
193
  int ret;
194

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

    
205
static struct config *
206
read_config(void)
207
{
208
  struct config *conf;
209

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

    
218
  return conf;
219
}
220

    
221
void
222
async_config(void)
223
{
224
  struct config *conf;
225

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

    
239
static struct config *
240
cmd_read_config(char *name)
241
{
242
  struct config *conf;
243

    
244
  if (!name)
245
    name = config_name;
246

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

    
258
  return conf;
259
}
260

    
261
void
262
cmd_check_config(char *name)
263
{
264
  struct config *conf = cmd_read_config(name);
265
  if (!conf)
266
    return;
267

    
268
  cli_msg(20, "Configuration OK");
269
  config_free(conf);
270
}
271

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

    
288
/* Hack for scheduled undo notification */
289
cli *cmd_reconfig_stored_cli;
290

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

    
302
void
303
cmd_reconfig(char *name, int type, int timeout)
304
{
305
  if (cli_access_restricted())
306
    return;
307

    
308
  struct config *conf = cmd_read_config(name);
309
  if (!conf)
310
    return;
311

    
312
  int r = config_commit(conf, type, timeout);
313

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

    
320
  cmd_reconfig_msg(r);
321
}
322

    
323
void
324
cmd_reconfig_confirm(void)
325
{
326
  if (cli_access_restricted())
327
    return;
328

    
329
  int r = config_confirm();
330
  cmd_reconfig_msg(r);
331
}
332

    
333
void
334
cmd_reconfig_undo(void)
335
{
336
  if (cli_access_restricted())
337
    return;
338

    
339
  cli_msg(-21, "Undo requested");
340

    
341
  int r = config_undo();
342
  cmd_reconfig_msg(r);
343
}
344

    
345
/*
346
 *        Command-Line Interface
347
 */
348

    
349
static sock *cli_sk;
350
static char *path_control_socket = PATH_CONTROL_SOCKET;
351

    
352

    
353
static void
354
cli_write(cli *c)
355
{
356
  sock *s = c->priv;
357

    
358
  while (c->tx_pos)
359
    {
360
      struct cli_out *o = c->tx_pos;
361

    
362
      int len = o->wpos - o->outpos;
363
      s->tbuf = o->outpos;
364
      o->outpos = o->wpos;
365

    
366
      if (sk_send(s, len) <= 0)
367
        return;
368

    
369
      c->tx_pos = o->next;
370
    }
371

    
372
  /* Everything is written */
373
  s->tbuf = NULL;
374
  cli_written(c);
375
}
376

    
377
void
378
cli_write_trigger(cli *c)
379
{
380
  sock *s = c->priv;
381

    
382
  if (s->tbuf == NULL)
383
    cli_write(c);
384
}
385

    
386
static void
387
cli_tx(sock *s)
388
{
389
  cli_write(s->data);
390
}
391

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

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

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

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

    
441
static int
442
cli_connect(sock *s, uint size UNUSED)
443
{
444
  cli *c;
445

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

    
460
static void
461
cli_init_unix(uid_t use_uid, gid_t use_gid)
462
{
463
  sock *s;
464

    
465
  cli_init();
466
  s = cli_sk = sk_new(cli_pool);
467
  s->type = SK_UNIX_PASSIVE;
468
  s->rx_hook = cli_connect;
469
  s->rbsize = 1024;
470
  s->fast_rx = 1;
471

    
472
  /* Return value intentionally ignored */
473
  unlink(path_control_socket);
474

    
475
  if (sk_open_unix(s, path_control_socket) < 0)
476
    die("Cannot create control socket %s: %m", path_control_socket);
477

    
478
  if (use_uid || use_gid)
479
    if (chown(path_control_socket, use_uid, use_gid) < 0)
480
      die("chown: %m");
481

    
482
  if (chmod(path_control_socket, 0660) < 0)
483
    die("chmod: %m");
484
}
485

    
486
/*
487
 *        PID file
488
 */
489

    
490
static char *pid_file;
491
static int pid_fd;
492

    
493
static inline void
494
open_pid_file(void)
495
{
496
  if (!pid_file)
497
    return;
498

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

    
504
static inline void
505
write_pid_file(void)
506
{
507
  int pl, rv;
508
  char ps[24];
509

    
510
  if (!pid_file)
511
    return;
512

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

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

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

    
527
  close(pid_fd);
528
}
529

    
530
static inline void
531
unlink_pid_file(void)
532
{
533
  if (pid_file)
534
    unlink(pid_file);
535
}
536

    
537

    
538
/*
539
 *        Shutdown
540
 */
541

    
542
void
543
cmd_shutdown(void)
544
{
545
  if (cli_access_restricted())
546
    return;
547

    
548
  cli_msg(7, "Shutdown requested");
549
  order_shutdown();
550
}
551

    
552
void
553
async_shutdown(void)
554
{
555
  DBG("Shutting down...\n");
556
  order_shutdown();
557
}
558

    
559
void
560
sysdep_shutdown_done(void)
561
{
562
  unlink_pid_file();
563
  unlink(path_control_socket);
564
  log_msg(L_FATAL "Shutdown completed");
565
  exit(0);
566
}
567

    
568
/*
569
 *        Signals
570
 */
571

    
572
static void
573
handle_sighup(int sig UNUSED)
574
{
575
  DBG("Caught SIGHUP...\n");
576
  async_config_flag = 1;
577
}
578

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

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

    
593
void watchdog_sigalrm(int sig UNUSED);
594

    
595
static void
596
signal_init(void)
597
{
598
  struct sigaction sa;
599

    
600
  bzero(&sa, sizeof(sa));
601
  sa.sa_handler = handle_sigusr;
602
  sa.sa_flags = SA_RESTART;
603
  sigaction(SIGUSR1, &sa, NULL);
604
  sa.sa_handler = handle_sighup;
605
  sa.sa_flags = SA_RESTART;
606
  sigaction(SIGHUP, &sa, NULL);
607
  sa.sa_handler = handle_sigterm;
608
  sa.sa_flags = SA_RESTART;
609
  sigaction(SIGTERM, &sa, NULL);
610
  sa.sa_handler = watchdog_sigalrm;
611
  sa.sa_flags = 0;
612
  sigaction(SIGALRM, &sa, NULL);
613
  signal(SIGPIPE, SIG_IGN);
614
}
615

    
616
/*
617
 *        Parsing of command-line arguments
618
 */
619

    
620
static char *opt_list = "c:dD:ps:P:u:g:flRh";
621
static int parse_and_exit;
622
char *bird_name;
623
static char *use_user;
624
static char *use_group;
625
static int run_in_foreground = 0;
626

    
627
static void
628
display_usage(void)
629
{
630
  fprintf(stderr, "Usage: %s [--version] [--help] [-c <config-file>] [OPTIONS]\n", bird_name);
631
}
632

    
633
static void
634
display_help(void)
635
{
636
  display_usage();
637

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

    
657
  exit(0);
658
}
659

    
660
static void
661
display_version(void)
662
{
663
  fprintf(stderr, "BIRD version " BIRD_VERSION "\n");
664
  exit(0);
665
}
666

    
667
static inline char *
668
get_bird_name(char *s, char *def)
669
{
670
  char *t;
671
  if (!s)
672
    return def;
673
  t = strrchr(s, '/');
674
  if (!t)
675
    return s;
676
  if (!t[1])
677
    return def;
678
  return t+1;
679
}
680

    
681
static inline uid_t
682
get_uid(const char *s)
683
{
684
  struct passwd *pw;
685
  char *endptr;
686
  long int rv;
687

    
688
  if (!s)
689
    return 0;
690

    
691
  errno = 0;
692
  rv = strtol(s, &endptr, 10);
693

    
694
  if (!errno && !*endptr)
695
    return rv;
696

    
697
  pw = getpwnam(s);
698
  if (!pw)
699
    die("Cannot find user '%s'", s);
700

    
701
  return pw->pw_uid;
702
}
703

    
704
static inline gid_t
705
get_gid(const char *s)
706
{
707
  struct group *gr;
708
  char *endptr;
709
  long int rv;
710

    
711
  if (!s)
712
    return 0;
713

    
714
  errno = 0;
715
  rv = strtol(s, &endptr, 10);
716

    
717
  if (!errno && !*endptr)
718
    return rv;
719

    
720
  gr = getgrnam(s);
721
  if (!gr)
722
    die("Cannot find group '%s'", s);
723

    
724
  return gr->gr_gid;
725
}
726

    
727
static void
728
parse_args(int argc, char **argv)
729
{
730
  int config_changed = 0;
731
  int socket_changed = 0;
732
  int c;
733

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

    
799
/*
800
 *        Hic Est main()
801
 */
802

    
803
int
804
main(int argc, char **argv)
805
{
806
#ifdef HAVE_LIBDMALLOC
807
  if (!getenv("DMALLOC_OPTIONS"))
808
    dmalloc_debug(0x2f03d00);
809
#endif
810

    
811
  parse_args(argc, argv);
812
  if (debug_flag == 1)
813
    log_init_debug("");
814
  log_switch(debug_flag, NULL, NULL);
815

    
816
  resource_init();
817
  olock_init();
818
  io_init();
819
  rt_init();
820
  if_init();
821
  roa_init();
822
  config_init();
823

    
824
  uid_t use_uid = get_uid(use_user);
825
  gid_t use_gid = get_gid(use_group);
826

    
827
  if (!parse_and_exit)
828
  {
829
    test_old_bird(path_control_socket);
830
    cli_init_unix(use_uid, use_gid);
831
  }
832

    
833
  if (use_gid)
834
    drop_gid(use_gid);
835

    
836
  if (use_uid)
837
    drop_uid(use_uid);
838

    
839
  if (!parse_and_exit)
840
    open_pid_file();
841

    
842
  protos_build();
843
  proto_build(&proto_unix_kernel);
844
  proto_build(&proto_unix_iface);
845

    
846
  struct config *conf = read_config();
847

    
848
  if (parse_and_exit)
849
    exit(0);
850

    
851
  if (!(debug_flag||run_in_foreground))
852
    {
853
      pid_t pid = fork();
854
      if (pid < 0)
855
        die("fork: %m");
856
      if (pid)
857
        return 0;
858
      setsid();
859
      close(0);
860
      if (open("/dev/null", O_RDWR) < 0)
861
        die("Cannot open /dev/null: %m");
862
      dup2(0, 1);
863
      dup2(0, 2);
864
    }
865

    
866
  main_thread_init();
867

    
868
  write_pid_file();
869

    
870
  signal_init();
871

    
872
  config_commit(conf, RECONFIG_HARD, 0);
873

    
874
  graceful_restart_init();
875

    
876
#ifdef LOCAL_DEBUG
877
  async_dump_flag = 1;
878
#endif
879

    
880
  log(L_INFO "Started");
881
  DBG("Entering I/O loop.\n");
882

    
883
  io_loop();
884
  bug("I/O loop died");
885
}