watchquagga/watchquagga.c

   1 /*
   2     Monitor status of quagga daemons and restart if necessary.
   3
   4     Copyright (C) 2004  Andrew J. Schorr
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <zebra.h>
  22 #include <thread.h>
  23 #include <log.h>
  24 #include <network.h>
  25 #include <sigevent.h>
  26 #include <lib/version.h>
  27 #include <getopt.h>
  28 #include <sys/un.h>
  29 #include <sys/wait.h>
  30 #include <memory.h>
  31
  32 #ifndef MIN
  33 #define MIN(X,Y) (((X) <= (Y)) ? (X) : (Y))
  34 #endif
  35
  36 /* Macros to help randomize timers. */
  37 #define JITTER(X) ((random() % ((X)+1))-((X)/2))
  38 #define FUZZY(X) ((X)+JITTER((X)/20))
  39
  40 #define DEFAULT_PERIOD          5
  41 #define DEFAULT_TIMEOUT         10
  42 #define DEFAULT_RESTART_TIMEOUT 20
  43 #define DEFAULT_LOGLEVEL        LOG_INFO
  44 #define DEFAULT_MIN_RESTART     60
  45 #define DEFAULT_MAX_RESTART     600
  46 #ifdef PATH_WATCHQUAGGA_PID
  47 #define DEFAULT_PIDFILE         PATH_WATCHQUAGGA_PID
  48 #else
  49 #define DEFAULT_PIDFILE         STATEDIR "/watchquagga.pid"
  50 #endif
  51 #ifdef DAEMON_VTY_DIR
  52 #define VTYDIR                  DAEMON_VTY_DIR
  53 #else
  54 #define VTYDIR                  STATEDIR
  55 #endif
  56
  57 #define PING_TOKEN      "PING"
  58
  59 /* Needs to be global, referenced somewhere inside libzebra. */
  60 struct thread_master *master;
  61
  62 typedef enum
  63 {
  64   MODE_MONITOR = 0,
  65   MODE_GLOBAL_RESTART,
  66   MODE_SEPARATE_RESTART,
  67   MODE_PHASED_ZEBRA_RESTART,
  68   MODE_PHASED_ALL_RESTART
  69 } watch_mode_t;
  70
  71 static const char *mode_str[] =
  72 {
  73   "monitor",
  74   "global restart",
  75   "individual daemon restart",
  76   "phased zebra restart",
  77   "phased global restart for any failure",
  78 };
  79
  80 typedef enum
  81 {
  82   PHASE_NONE = 0,
  83   PHASE_STOPS_PENDING,
  84   PHASE_WAITING_DOWN,
  85   PHASE_ZEBRA_RESTART_PENDING,
  86   PHASE_WAITING_ZEBRA_UP
  87 } restart_phase_t;
  88
  89 static const char *phase_str[] =
  90 {
  91   "None",
  92   "Stop jobs running",
  93   "Waiting for other daemons to come down",
  94   "Zebra restart job running",
  95   "Waiting for zebra to come up",
  96   "Start jobs running",
  97 };
  98
  99 #define PHASE_TIMEOUT (3*gs.restart_timeout)
 100
 101 struct restart_info
 102 {
 103   const char *name;
 104   const char *what;
 105   pid_t pid;
 106   struct timeval time;
 107   long interval;
 108   struct thread *t_kill;
 109   int kills;
 110 };
 111
 112 static struct global_state
 113 {
 114   watch_mode_t mode;
 115   restart_phase_t phase;
 116   struct thread *t_phase_hanging;
 117   const char *vtydir;
 118   long period;
 119   long timeout;
 120   long restart_timeout;
 121   long min_restart_interval;
 122   long max_restart_interval;
 123   int do_ping;
 124   struct daemon *daemons;
 125   const char *restart_command;
 126   const char *start_command;
 127   const char *stop_command;
 128   struct restart_info restart;
 129   int unresponsive_restart;
 130   int loglevel;
 131   struct daemon *special;       /* points to zebra when doing phased restart */
 132   int numdaemons;
 133   int numpids;
 134   int numdown;          /* # of daemons that are not UP or UNRESPONSIVE */
 135 } gs = {
 136   .mode = MODE_MONITOR,
 137   .phase = PHASE_NONE,
 138   .vtydir = VTYDIR,
 139   .period = 1000*DEFAULT_PERIOD,
 140   .timeout = DEFAULT_TIMEOUT,
 141   .restart_timeout = DEFAULT_RESTART_TIMEOUT,
 142   .loglevel = DEFAULT_LOGLEVEL,
 143   .min_restart_interval = DEFAULT_MIN_RESTART,
 144   .max_restart_interval = DEFAULT_MAX_RESTART,
 145   .do_ping = 1,
 146 };
 147
 148 typedef enum
 149 {
 150   DAEMON_INIT,
 151   DAEMON_DOWN,
 152   DAEMON_CONNECTING,
 153   DAEMON_UP,
 154   DAEMON_UNRESPONSIVE
 155 } daemon_state_t;
 156
 157 #define IS_UP(DMN) \
 158   (((DMN)->state == DAEMON_UP) || ((DMN)->state == DAEMON_UNRESPONSIVE))
 159
 160 static const char *state_str[] =
 161 {
 162   "Init",
 163   "Down",
 164   "Connecting",
 165   "Up",
 166   "Unresponsive",
 167 };
 168
 169 struct daemon {
 170   const char *name;
 171   daemon_state_t state;
 172   int fd;
 173   struct timeval echo_sent;
 174   u_int connect_tries;
 175   struct thread *t_wakeup;
 176   struct thread *t_read;
 177   struct thread *t_write;
 178   struct daemon *next;
 179   struct restart_info restart;
 180 };
 181
 182 static const struct option longopts[] =
 183 {
 184   { "daemon", no_argument, NULL, 'd'},
 185   { "statedir", required_argument, NULL, 'S'},
 186   { "no-echo", no_argument, NULL, 'e'},
 187   { "loglevel", required_argument, NULL, 'l'},
 188   { "interval", required_argument, NULL, 'i'},
 189   { "timeout", required_argument, NULL, 't'},
 190   { "restart-timeout", required_argument, NULL, 'T'},
 191   { "restart", required_argument, NULL, 'r'},
 192   { "start-command", required_argument, NULL, 's'},
 193   { "kill-command", required_argument, NULL, 'k'},
 194   { "restart-all", required_argument, NULL, 'R'},
 195   { "all-restart", no_argument, NULL, 'a'},
 196   { "always-all-restart", no_argument, NULL, 'A'},
 197   { "unresponsive-restart", no_argument, NULL, 'z'},
 198   { "min-restart-interval", required_argument, NULL, 'm'},
 199   { "max-restart-interval", required_argument, NULL, 'M'},
 200   { "pid-file", required_argument, NULL, 'p'},
 201   { "blank-string", required_argument, NULL, 'b'},
 202   { "help", no_argument, NULL, 'h'},
 203   { "version", no_argument, NULL, 'v'},
 204   { NULL, 0, NULL, 0 }
 205 };
 206
 207 static int try_connect(struct daemon *dmn);
 208 static int wakeup_send_echo(struct thread *t_wakeup);
 209 static void try_restart(struct daemon *dmn);
 210 static void phase_check(void);
 211
 212 static int
 213 usage(const char *progname, int status)
 214 {
 215   if (status != 0)
 216     fprintf(stderr, "Try `%s --help' for more information.\n", progname);
 217   else
 218     {
 219       printf("Usage : %s [OPTION...] <daemon name> ...\n\n\
 220 Watchdog program to monitor status of quagga daemons and try to restart\n\
 221 them if they are down or unresponsive.  It determines whether a daemon is\n\
 222 up based on whether it can connect to the daemon's vty unix stream socket.\n\
 223 It then repeatedly sends echo commands over that socket to determine whether\n\
 224 the daemon is responsive.  If the daemon crashes, we will receive an EOF\n\
 225 on the socket connection and know immediately that the daemon is down.\n\n\
 226 The daemons to be monitored should be listed on the command line.\n\n\
 227 This program can run in one of 5 modes:\n\n\
 228 0. Mode: %s.\n\
 229   Just monitor and report on status changes.  Example:\n\
 230     %s -d zebra ospfd bgpd\n\n\
 231 1. Mode: %s.\n\
 232   Whenever any daemon hangs or crashes, use the given command to restart\n\
 233   them all.  Example:\n\
 234     %s -dz \\\n\
 235       -R '/sbin/service zebra restart; /sbin/service ospfd restart' \\\n\
 236       zebra ospfd\n\n\
 237 2. Mode: %s.\n\
 238   When any single daemon hangs or crashes, restart only the daemon that's\n\
 239   in trouble using the supplied restart command.  Example:\n\
 240     %s -dz -r '/sbin/service %%s restart' zebra ospfd bgpd\n\n\
 241 3. Mode: %s.\n\
 242   The same as the previous mode, except that there is special treatment when\n\
 243   the zebra daemon is in trouble.  In that case, a phased restart approach\n\
 244   is used: 1. stop all other daemons; 2. restart zebra; 3. start the other\n\
 245   daemons.  Example:\n\
 246     %s -adz -r '/sbin/service %%s restart' \\\n\
 247       -s '/sbin/service %%s start' \\\n\
 248       -k '/sbin/service %%s stop' zebra ospfd bgpd\n\n\
 249 4. Mode: %s.\n\
 250   This is the same as the previous mode, except that the phased restart\n\
 251   procedure is used whenever any of the daemons hangs or crashes.  Example:\n\
 252     %s -Adz -r '/sbin/service %%s restart' \\\n\
 253       -s '/sbin/service %%s start' \\\n\
 254       -k '/sbin/service %%s stop' zebra ospfd bgpd\n\n\
 255 As of this writing, it is believed that mode 2 [%s]\n\
 256 is not safe, and mode 3 [%s] may not be safe with some of the\n\
 257 routing daemons.\n\n\
 258 In order to avoid attempting to restart the daemons in a fast loop,\n\
 259 the -m and -M options allow you to control the minimum delay between\n\
 260 restart commands.  The minimum restart delay is recalculated each time\n\
 261 a restart is attempted: if the time since the last restart attempt exceeds\n\
 262 twice the -M value, then the restart delay is set to the -m value.\n\
 263 Otherwise, the interval is doubled (but capped at the -M value).\n\n",
 264         progname,mode_str[0],progname,mode_str[1],progname,mode_str[2],
 265         progname,mode_str[3],progname,mode_str[4],progname,mode_str[2],
 266         mode_str[3]);
 267
 268       printf("Options:\n\
 269 -d, --daemon    Run in daemon mode.  In this mode, error messages are sent\n\
 270                 to syslog instead of stdout.\n\
 271 -S, --statedir  Set the vty socket directory (default is %s)\n\
 272 -e, --no-echo   Do not ping the daemons to test responsiveness (this\n\
 273                 option is necessary if the daemons do not support the\n\
 274                 echo command)\n\
 275 -l, --loglevel  Set the logging level (default is %d).\n\
 276                 The value should range from %d (LOG_EMERG) to %d (LOG_DEBUG),\n\
 277                 but it can be set higher than %d if extra-verbose debugging\n\
 278                 messages are desired.\n\
 279 -m, --min-restart-interval\n\
 280                 Set the minimum seconds to wait between invocations of daemon\n\
 281                 restart commands (default is %d).\n\
 282 -M, --max-restart-interval\n\
 283                 Set the maximum seconds to wait between invocations of daemon\n\
 284                 restart commands (default is %d).\n\
 285 -i, --interval  Set the status polling interval in seconds (default is %d)\n\
 286 -t, --timeout   Set the unresponsiveness timeout in seconds (default is %d)\n\
 287 -T, --restart-timeout\n\
 288                 Set the restart (kill) timeout in seconds (default is %d).\n\
 289                 If any background jobs are still running after this much\n\
 290                 time has elapsed, they will be killed.\n\
 291 -r, --restart   Supply a Bourne shell command to use to restart a single\n\
 292                 daemon.  The command string should include '%%s' where the\n\
 293                 name of the daemon should be substituted.\n\
 294                 Note that -r and -R are incompatible.\n\
 295 -s, --start-command\n\
 296                 Supply a Bourne shell to command to use to start a single\n\
 297                 daemon.  The command string should include '%%s' where the\n\
 298                 name of the daemon should be substituted.\n\
 299 -k, --kill-command\n\
 300                 Supply a Bourne shell to command to use to stop a single\n\
 301                 daemon.  The command string should include '%%s' where the\n\
 302                 name of the daemon should be substituted.\n\
 303 -R, --restart-all\n\
 304                 When one or more daemons is down, try to restart everything\n\
 305                 using the Bourne shell command supplied as the argument.\n\
 306                 Note that -r and -R are incompatible.\n\
 307 -z, --unresponsive-restart\n\
 308                 When a daemon is unresponsive, treat it as being down for\n\
 309                 restart purposes.\n\
 310 -a, --all-restart\n\
 311                 When zebra hangs or crashes, restart all daemons using\n\
 312                 this phased approach: 1. stop all other daemons; 2. restart\n\
 313                 zebra; 3. start other daemons.  Requires -r, -s, and -k.\n\
 314 -A, --always-all-restart\n\
 315                 When any daemon (not just zebra) hangs or crashes, use the\n\
 316                 same phased restart mechanism described above for -a.\n\
 317                 Requires -r, -s, and -k.\n\
 318 -p, --pid-file  Set process identifier file name\n\
 319                 (default is %s).\n\
 320 -b, --blank-string\n\
 321                 When the supplied argument string is found in any of the\n\
 322                 various shell command arguments (-r, -s, -k, or -R), replace\n\
 323                 it with a space.  This is an ugly hack to circumvent problems\n\
 324                 passing command-line arguments with embedded spaces.\n\
 325 -v, --version   Print program version\n\
 326 -h, --help      Display this help and exit\n",
 327         VTYDIR,DEFAULT_LOGLEVEL,LOG_EMERG,LOG_DEBUG,LOG_DEBUG,
 328         DEFAULT_MIN_RESTART,DEFAULT_MAX_RESTART,
 329         DEFAULT_PERIOD,DEFAULT_TIMEOUT,DEFAULT_RESTART_TIMEOUT,
 330         DEFAULT_PIDFILE);
 331     }
 332
 333   return status;
 334 }
 335
 336 static pid_t
 337 run_background(char *shell_cmd)
 338 {
 339   pid_t child;
 340
 341   switch (child = fork())
 342     {
 343     case -1:
 344       zlog_err("fork failed, cannot run command [%s]: %s",
 345                shell_cmd,safe_strerror(errno));
 346       return -1;
 347     case 0:
 348       /* Child process. */
 349       /* Use separate process group so child processes can be killed easily. */
 350       if (setpgid(0,0) < 0)
 351         zlog_warn("warning: setpgid(0,0) failed: %s",safe_strerror(errno));
 352       {
 353         char shell[] = "sh";
 354         char dashc[] = "-c";
 355         char *const argv[4] = { shell, dashc, shell_cmd, NULL};
 356         execv("/bin/sh", argv);
 357         zlog_err("execv(/bin/sh -c '%s') failed: %s",
 358                  shell_cmd,safe_strerror(errno));
 359         _exit(127);
 360       }
 361     default:
 362       /* Parent process: we will reap the child later. */
 363       zlog_err("Forked background command [pid %d]: %s",(int)child,shell_cmd);
 364       return child;
 365     }
 366 }
 367
 368 static struct timeval *
 369 time_elapsed(struct timeval *result, const struct timeval *start_time)
 370 {
 371   gettimeofday(result,NULL);
 372   result->tv_sec -= start_time->tv_sec;
 373   result->tv_usec -= start_time->tv_usec;
 374   while (result->tv_usec < 0)
 375     {
 376       result->tv_usec += 1000000L;
 377       result->tv_sec--;
 378     }
 379   return result;
 380 }
 381
 382 static int
 383 restart_kill(struct thread *t_kill)
 384 {
 385   struct restart_info *restart = THREAD_ARG(t_kill);
 386   struct timeval delay;
 387
 388   time_elapsed(&delay,&restart->time);
 389   zlog_warn("Warning: %s %s child process %d still running after "
 390             "%ld seconds, sending signal %d",
 391             restart->what,restart->name,(int)restart->pid, (long)delay.tv_sec,
 392             (restart->kills ? SIGKILL : SIGTERM));
 393   kill(-restart->pid,(restart->kills ? SIGKILL : SIGTERM));
 394   restart->kills++;
 395   restart->t_kill = thread_add_timer(master,restart_kill,restart,
 396                                      gs.restart_timeout);
 397   return 0;
 398 }
 399
 400 static struct restart_info *
 401 find_child(pid_t child)
 402 {
 403   if (gs.mode == MODE_GLOBAL_RESTART)
 404     {
 405       if (gs.restart.pid == child)
 406         return &gs.restart;
 407     }
 408   else
 409     {
 410       struct daemon *dmn;
 411       for (dmn = gs.daemons; dmn; dmn = dmn->next)
 412         {
 413           if (dmn->restart.pid == child)
 414             return &dmn->restart;
 415         }
 416     }
 417   return NULL;
 418 }
 419
 420 static void
 421 sigchild(void)
 422 {
 423   pid_t child;
 424   int status;
 425   const char *name;
 426   const char *what;
 427   struct restart_info *restart;
 428
 429   switch (child = waitpid(-1,&status,WNOHANG))
 430     {
 431     case -1:
 432       zlog_err("waitpid failed: %s",safe_strerror(errno));
 433       return;
 434     case 0:
 435       zlog_warn("SIGCHLD received, but waitpid did not reap a child");
 436       return;
 437     }
 438
 439   if ((restart = find_child(child)) != NULL)
 440     {
 441       name = restart->name;
 442       what = restart->what;
 443       restart->pid = 0;
 444       gs.numpids--;
 445       thread_cancel(restart->t_kill);
 446       restart->t_kill = NULL;
 447       /* Update restart time to reflect the time the command completed. */
 448       gettimeofday(&restart->time,NULL);
 449     }
 450   else
 451     {
 452       zlog_err("waitpid returned status for an unknown child process %d",
 453                (int)child);
 454       name = "(unknown)";
 455       what = "background";
 456     }
 457   if (WIFSTOPPED(status))
 458       zlog_warn("warning: %s %s process %d is stopped",
 459                 what,name,(int)child);
 460   else if (WIFSIGNALED(status))
 461     zlog_warn("%s %s process %d terminated due to signal %d",
 462               what,name,(int)child,WTERMSIG(status));
 463   else if (WIFEXITED(status))
 464     {
 465       if (WEXITSTATUS(status) != 0)
 466         zlog_warn("%s %s process %d exited with non-zero status %d",
 467                   what,name,(int)child,WEXITSTATUS(status));
 468       else
 469         zlog_debug("%s %s process %d exited normally",what,name,(int)child);
 470     }
 471   else
 472     zlog_err("cannot interpret %s %s process %d wait status 0x%x",
 473              what,name,(int)child,status);
 474   phase_check();
 475 }
 476
 477 static int
 478 run_job(struct restart_info *restart, const char *cmdtype, const char *command,
 479         int force, int update_interval)
 480 {
 481   struct timeval delay;
 482
 483   if (gs.loglevel > LOG_DEBUG+1)
 484     zlog_debug("attempting to %s %s",cmdtype,restart->name);
 485
 486   if (restart->pid)
 487     {
 488       if (gs.loglevel > LOG_DEBUG+1)
 489         zlog_debug("cannot %s %s, previous pid %d still running",
 490                    cmdtype,restart->name,(int)restart->pid);
 491       return -1;
 492     }
 493
 494   /* Note: time_elapsed test must come before the force test, since we need
 495      to make sure that delay is initialized for use below in updating the
 496      restart interval. */
 497   if ((time_elapsed(&delay,&restart->time)->tv_sec < restart->interval) &&
 498       !force)
 499     {
 500       if (gs.loglevel > LOG_DEBUG+1)
 501         zlog_debug("postponing %s %s: "
 502                    "elapsed time %ld < retry interval %ld",
 503                    cmdtype,restart->name,(long)delay.tv_sec,restart->interval);
 504       return -1;
 505     }
 506
 507   gettimeofday(&restart->time,NULL);
 508   restart->kills = 0;
 509   {
 510     char cmd[strlen(command)+strlen(restart->name)+1];
 511     snprintf(cmd,sizeof(cmd),command,restart->name);
 512     if ((restart->pid = run_background(cmd)) > 0)
 513       {
 514         restart->t_kill = thread_add_timer(master,restart_kill,restart,
 515                                            gs.restart_timeout);
 516         restart->what = cmdtype;
 517         gs.numpids++;
 518       }
 519     else
 520       restart->pid = 0;
 521   }
 522
 523   /* Calculate the new restart interval. */
 524   if (update_interval)
 525     {
 526       if (delay.tv_sec > 2*gs.max_restart_interval)
 527         restart->interval = gs.min_restart_interval;
 528       else if ((restart->interval *= 2) > gs.max_restart_interval)
 529         restart->interval = gs.max_restart_interval;
 530       if (gs.loglevel > LOG_DEBUG+1)
 531         zlog_debug("restart %s interval is now %ld",
 532                    restart->name,restart->interval);
 533     }
 534   return restart->pid;
 535 }
 536
 537 #define SET_READ_HANDLER(DMN) \
 538   (DMN)->t_read = thread_add_read(master,handle_read,(DMN),(DMN)->fd)
 539
 540 #define SET_WAKEUP_DOWN(DMN)    \
 541   (DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_down,(DMN),     \
 542                                           FUZZY(gs.period))
 543
 544 #define SET_WAKEUP_UNRESPONSIVE(DMN)    \
 545   (DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_unresponsive,(DMN), \
 546                                           FUZZY(gs.period))
 547
 548 #define SET_WAKEUP_ECHO(DMN) \
 549   (DMN)->t_wakeup = thread_add_timer_msec(master,wakeup_send_echo,(DMN), \
 550                                           FUZZY(gs.period))
 551
 552 static int
 553 wakeup_down(struct thread *t_wakeup)
 554 {
 555   struct daemon *dmn = THREAD_ARG(t_wakeup);
 556
 557   dmn->t_wakeup = NULL;
 558   if (try_connect(dmn) < 0)
 559     SET_WAKEUP_DOWN(dmn);
 560   if ((dmn->connect_tries > 1) && (dmn->state != DAEMON_UP))
 561     try_restart(dmn);
 562   return 0;
 563 }
 564
 565 static int
 566 wakeup_init(struct thread *t_wakeup)
 567 {
 568   struct daemon *dmn = THREAD_ARG(t_wakeup);
 569
 570   dmn->t_wakeup = NULL;
 571   if (try_connect(dmn) < 0)
 572     {
 573       SET_WAKEUP_DOWN(dmn);
 574       zlog_err("%s state -> down : initial connection attempt failed",
 575                dmn->name);
 576       dmn->state = DAEMON_DOWN;
 577     }
 578   return 0;
 579 }
 580
 581 static void
 582 daemon_down(struct daemon *dmn, const char *why)
 583 {
 584   if (IS_UP(dmn) || (dmn->state == DAEMON_INIT))
 585     zlog_err("%s state -> down : %s",dmn->name,why);
 586   else if (gs.loglevel > LOG_DEBUG)
 587     zlog_debug("%s still down : %s",dmn->name,why);
 588   if (IS_UP(dmn))
 589     gs.numdown++;
 590   dmn->state = DAEMON_DOWN;
 591   if (dmn->fd >= 0)
 592     {
 593       close(dmn->fd);
 594       dmn->fd = -1;
 595     }
 596   THREAD_OFF(dmn->t_read);
 597   THREAD_OFF(dmn->t_write);
 598   THREAD_OFF(dmn->t_wakeup);
 599   if (try_connect(dmn) < 0)
 600     SET_WAKEUP_DOWN(dmn);
 601   phase_check();
 602 }
 603
 604 static int
 605 handle_read(struct thread *t_read)
 606 {
 607   struct daemon *dmn = THREAD_ARG(t_read);
 608   static const char resp[sizeof(PING_TOKEN)+4] = PING_TOKEN "\n";
 609   char buf[sizeof(resp)+100];
 610   ssize_t rc;
 611   struct timeval delay;
 612
 613   dmn->t_read = NULL;
 614   if ((rc = read(dmn->fd,buf,sizeof(buf))) < 0)
 615     {
 616       char why[100];
 617
 618       if (ERRNO_IO_RETRY(errno))
 619         {
 620           /* Pretend it never happened. */
 621           SET_READ_HANDLER(dmn);
 622           return 0;
 623         }
 624       snprintf(why,sizeof(why),"unexpected read error: %s",
 625                safe_strerror(errno));
 626       daemon_down(dmn,why);
 627       return 0;
 628     }
 629   if (rc == 0)
 630     {
 631       daemon_down(dmn,"read returned EOF");
 632       return 0;
 633     }
 634   if (!dmn->echo_sent.tv_sec)
 635     {
 636       char why[sizeof(buf)+100];
 637       snprintf(why,sizeof(why),"unexpected read returns %d bytes: %.*s",
 638                (int)rc,(int)rc,buf);
 639       daemon_down(dmn,why);
 640       return 0;
 641     }
 642
 643   /* We are expecting an echo response: is there any chance that the
 644      response would not be returned entirely in the first read?  That
 645      seems inconceivable... */
 646   if ((rc != sizeof(resp)) || memcmp(buf,resp,sizeof(resp)))
 647     {
 648       char why[100+sizeof(buf)];
 649       snprintf(why,sizeof(why),"read returned bad echo response of %d bytes "
 650                                "(expecting %u): %.*s",
 651                (int)rc,(u_int)sizeof(resp),(int)rc,buf);
 652       daemon_down(dmn,why);
 653       return 0;
 654     }
 655
 656   time_elapsed(&delay,&dmn->echo_sent);
 657   dmn->echo_sent.tv_sec = 0;
 658   if (dmn->state == DAEMON_UNRESPONSIVE)
 659     {
 660       if (delay.tv_sec < gs.timeout)
 661         {
 662           dmn->state = DAEMON_UP;
 663           zlog_warn("%s state -> up : echo response received after %ld.%06ld "
 664                     "seconds", dmn->name,
 665                     (long)delay.tv_sec, (long)delay.tv_usec);
 666         }
 667       else
 668         zlog_warn("%s: slow echo response finally received after %ld.%06ld "
 669                   "seconds", dmn->name,
 670                   (long)delay.tv_sec, (long)delay.tv_usec);
 671     }
 672   else if (gs.loglevel > LOG_DEBUG+1)
 673     zlog_debug("%s: echo response received after %ld.%06ld seconds",
 674                dmn->name, (long)delay.tv_sec, (long)delay.tv_usec);
 675
 676   SET_READ_HANDLER(dmn);
 677   if (dmn->t_wakeup)
 678     thread_cancel(dmn->t_wakeup);
 679   SET_WAKEUP_ECHO(dmn);
 680
 681   return 0;
 682 }
 683
 684 static void
 685 daemon_up(struct daemon *dmn, const char *why)
 686 {
 687   dmn->state = DAEMON_UP;
 688   gs.numdown--;
 689   dmn->connect_tries = 0;
 690   zlog_notice("%s state -> up : %s",dmn->name,why);
 691   if (gs.do_ping)
 692     SET_WAKEUP_ECHO(dmn);
 693   phase_check();
 694 }
 695
 696 static int
 697 check_connect(struct thread *t_write)
 698 {
 699   struct daemon *dmn = THREAD_ARG(t_write);
 700   int sockerr;
 701   socklen_t reslen = sizeof(sockerr);
 702
 703   dmn->t_write = NULL;
 704   if (getsockopt(dmn->fd,SOL_SOCKET,SO_ERROR,(char *)&sockerr,&reslen) < 0)
 705     {
 706       zlog_warn("%s: check_connect: getsockopt failed: %s",
 707                 dmn->name,safe_strerror(errno));
 708       daemon_down(dmn,"getsockopt failed checking connection success");
 709       return 0;
 710     }
 711   if ((reslen == sizeof(sockerr)) && sockerr)
 712     {
 713       char why[100];
 714       snprintf(why,sizeof(why),
 715                "getsockopt reports that connection attempt failed: %s",
 716                safe_strerror(sockerr));
 717       daemon_down(dmn,why);
 718       return 0;
 719     }
 720
 721   daemon_up(dmn,"delayed connect succeeded");
 722   return 0;
 723 }
 724
 725 static int
 726 wakeup_connect_hanging(struct thread *t_wakeup)
 727 {
 728   struct daemon *dmn = THREAD_ARG(t_wakeup);
 729   char why[100];
 730
 731   dmn->t_wakeup = NULL;
 732   snprintf(why,sizeof(why),"connection attempt timed out after %ld seconds",
 733            gs.timeout);
 734   daemon_down(dmn,why);
 735   return 0;
 736 }
 737
 738 /* Making connection to protocol daemon. */
 739 static int
 740 try_connect(struct daemon *dmn)
 741 {
 742   int sock;
 743   struct sockaddr_un addr;
 744   socklen_t len;
 745
 746   if (gs.loglevel > LOG_DEBUG+1)
 747     zlog_debug("%s: attempting to connect",dmn->name);
 748   dmn->connect_tries++;
 749
 750   memset (&addr, 0, sizeof (struct sockaddr_un));
 751   addr.sun_family = AF_UNIX;
 752   snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/%s.vty",
 753            gs.vtydir,dmn->name);
 754 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
 755   len = addr.sun_len = SUN_LEN(&addr);
 756 #else
 757   len = sizeof (addr.sun_family) + strlen (addr.sun_path);
 758 #endif /* HAVE_STRUCT_SOCKADDR_UN_SUN_LEN */
 759
 760   /* Quick check to see if we might succeed before we go to the trouble
 761      of creating a socket. */
 762   if (access(addr.sun_path, W_OK) < 0)
 763     {
 764       if (errno != ENOENT)
 765         zlog_err("%s: access to socket %s denied: %s",
 766                 dmn->name,addr.sun_path,safe_strerror(errno));
 767       return -1;
 768     }
 769
 770   if ((sock = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
 771     {
 772       zlog_err("%s(%s): cannot make socket: %s",
 773                __func__,addr.sun_path, safe_strerror(errno));
 774       return -1;
 775     }
 776
 777   if (set_nonblocking(sock) < 0)
 778     {
 779       zlog_err("%s(%s): set_nonblocking(%d) failed",
 780                __func__, addr.sun_path, sock);
 781       close(sock);
 782       return -1;
 783     }
 784
 785   if (connect (sock, (struct sockaddr *) &addr, len) < 0)
 786     {
 787       if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK))
 788         {
 789           if (gs.loglevel > LOG_DEBUG)
 790             zlog_debug("%s(%s): connect failed: %s",
 791                        __func__,addr.sun_path, safe_strerror(errno));
 792           close (sock);
 793           return -1;
 794         }
 795       if (gs.loglevel > LOG_DEBUG)
 796         zlog_debug("%s: connection in progress",dmn->name);
 797       dmn->state = DAEMON_CONNECTING;
 798       dmn->fd = sock;
 799       dmn->t_write = thread_add_write(master,check_connect,dmn,dmn->fd);
 800       dmn->t_wakeup = thread_add_timer(master,wakeup_connect_hanging,dmn,
 801                                        gs.timeout);
 802       SET_READ_HANDLER(dmn);
 803       return 0;
 804     }
 805
 806   dmn->fd = sock;
 807   SET_READ_HANDLER(dmn);
 808   daemon_up(dmn,"connect succeeded");
 809   return 1;
 810 }
 811
 812 static int
 813 phase_hanging(struct thread *t_hanging)
 814 {
 815   gs.t_phase_hanging = NULL;
 816   zlog_err("Phase [%s] hanging for %ld seconds, aborting phased restart",
 817            phase_str[gs.phase],PHASE_TIMEOUT);
 818   gs.phase = PHASE_NONE;
 819   return 0;
 820 }
 821
 822 static void
 823 set_phase(restart_phase_t new_phase)
 824 {
 825   gs.phase = new_phase;
 826   if (gs.t_phase_hanging)
 827     thread_cancel(gs.t_phase_hanging);
 828   gs.t_phase_hanging = thread_add_timer(master,phase_hanging,NULL,
 829                                         PHASE_TIMEOUT);
 830 }
 831
 832 static void
 833 phase_check(void)
 834 {
 835   switch (gs.phase)
 836     {
 837     case PHASE_NONE:
 838       break;
 839     case PHASE_STOPS_PENDING:
 840       if (gs.numpids)
 841         break;
 842       zlog_info("Phased restart: all routing daemon stop jobs have completed.");
 843       set_phase(PHASE_WAITING_DOWN);
 844       /*FALLTHRU*/
 845     case PHASE_WAITING_DOWN:
 846       if (gs.numdown+IS_UP(gs.special) < gs.numdaemons)
 847         break;
 848       zlog_info("Phased restart: all routing daemons now down.");
 849       run_job(&gs.special->restart,"restart",gs.restart_command,1,1);
 850       set_phase(PHASE_ZEBRA_RESTART_PENDING);
 851       /*FALLTHRU*/
 852     case PHASE_ZEBRA_RESTART_PENDING:
 853       if (gs.special->restart.pid)
 854         break;
 855       zlog_info("Phased restart: %s restart job completed.",gs.special->name);
 856       set_phase(PHASE_WAITING_ZEBRA_UP);
 857       /*FALLTHRU*/
 858     case PHASE_WAITING_ZEBRA_UP:
 859       if (!IS_UP(gs.special))
 860         break;
 861       zlog_info("Phased restart: %s is now up.",gs.special->name);
 862       {
 863         struct daemon *dmn;
 864         for (dmn = gs.daemons; dmn; dmn = dmn->next)
 865           {
 866             if (dmn != gs.special)
 867               run_job(&dmn->restart,"start",gs.start_command,1,0);
 868           }
 869       }
 870       gs.phase = PHASE_NONE;
 871       THREAD_OFF(gs.t_phase_hanging);
 872       zlog_notice("Phased global restart has completed.");
 873       break;
 874     }
 875 }
 876
 877 static void
 878 try_restart(struct daemon *dmn)
 879 {
 880   switch (gs.mode)
 881   {
 882   case MODE_MONITOR:
 883     return;
 884   case MODE_GLOBAL_RESTART:
 885     run_job(&gs.restart,"restart",gs.restart_command,0,1);
 886     break;
 887   case MODE_SEPARATE_RESTART:
 888     run_job(&dmn->restart,"restart",gs.restart_command,0,1);
 889     break;
 890   case MODE_PHASED_ZEBRA_RESTART:
 891     if (dmn != gs.special)
 892       {
 893         if ((gs.special->state == DAEMON_UP) && (gs.phase == PHASE_NONE))
 894           run_job(&dmn->restart,"restart",gs.restart_command,0,1);
 895         else
 896           zlog_debug("%s: postponing restart attempt because master %s daemon "
 897                      "not up [%s], or phased restart in progress",
 898                      dmn->name,gs.special->name,state_str[gs.special->state]);
 899         break;
 900       }
 901     /*FALLTHRU*/
 902   case MODE_PHASED_ALL_RESTART:
 903     if ((gs.phase != PHASE_NONE) || gs.numpids)
 904       {
 905         if (gs.loglevel > LOG_DEBUG+1)
 906           zlog_debug("postponing phased global restart: restart already in "
 907                      "progress [%s], or outstanding child processes [%d]",
 908                      phase_str[gs.phase],gs.numpids);
 909         break;
 910       }
 911     /* Is it too soon for a restart? */
 912     {
 913       struct timeval delay;
 914       if (time_elapsed(&delay,&gs.special->restart.time)->tv_sec <
 915           gs.special->restart.interval)
 916         {
 917           if (gs.loglevel > LOG_DEBUG+1)
 918             zlog_debug("postponing phased global restart: "
 919                        "elapsed time %ld < retry interval %ld",
 920                        (long)delay.tv_sec,gs.special->restart.interval);
 921           break;
 922         }
 923     }
 924     zlog_info("Phased restart: stopping all routing daemons.");
 925     /* First step: stop all other daemons. */
 926     for (dmn = gs.daemons; dmn; dmn = dmn->next)
 927       {
 928         if (dmn != gs.special)
 929           run_job(&dmn->restart,"stop",gs.stop_command,1,1);
 930       }
 931     set_phase(PHASE_STOPS_PENDING);
 932     break;
 933   default:
 934     zlog_err("error: unknown restart mode %d",gs.mode);
 935     break;
 936   }
 937 }
 938
 939 static int
 940 wakeup_unresponsive(struct thread *t_wakeup)
 941 {
 942   struct daemon *dmn = THREAD_ARG(t_wakeup);
 943
 944   dmn->t_wakeup = NULL;
 945   if (dmn->state != DAEMON_UNRESPONSIVE)
 946     zlog_err("%s: no longer unresponsive (now %s), "
 947              "wakeup should have been cancelled!",
 948              dmn->name,state_str[dmn->state]);
 949   else
 950     {
 951       SET_WAKEUP_UNRESPONSIVE(dmn);
 952       try_restart(dmn);
 953     }
 954   return 0;
 955 }
 956
 957 static int
 958 wakeup_no_answer(struct thread *t_wakeup)
 959 {
 960   struct daemon *dmn = THREAD_ARG(t_wakeup);
 961
 962   dmn->t_wakeup = NULL;
 963   dmn->state = DAEMON_UNRESPONSIVE;
 964   zlog_err("%s state -> unresponsive : no response yet to ping "
 965            "sent %ld seconds ago",dmn->name,gs.timeout);
 966   if (gs.unresponsive_restart)
 967     {
 968       SET_WAKEUP_UNRESPONSIVE(dmn);
 969       try_restart(dmn);
 970     }
 971   return 0;
 972 }
 973
 974 static int
 975 wakeup_send_echo(struct thread *t_wakeup)
 976 {
 977   static const char echocmd[] = "echo " PING_TOKEN;
 978   ssize_t rc;
 979   struct daemon *dmn = THREAD_ARG(t_wakeup);
 980
 981   dmn->t_wakeup = NULL;
 982   if (((rc = write(dmn->fd,echocmd,sizeof(echocmd))) < 0) ||
 983       ((size_t)rc != sizeof(echocmd)))
 984     {
 985       char why[100+sizeof(echocmd)];
 986       snprintf(why,sizeof(why),"write '%s' returned %d instead of %u",
 987                echocmd,(int)rc,(u_int)sizeof(echocmd));
 988       daemon_down(dmn,why);
 989     }
 990   else
 991     {
 992       gettimeofday(&dmn->echo_sent,NULL);
 993       dmn->t_wakeup = thread_add_timer(master,wakeup_no_answer,dmn,gs.timeout);
 994     }
 995   return 0;
 996 }
 997
 998 static void
 999 sigint(void)
1000 {
1001   zlog_notice("Terminating on signal");
1002   exit(0);
1003 }
1004
1005 static int
1006 valid_command(const char *cmd)
1007 {
1008   char *p;
1009
1010   return ((p = strchr(cmd,'%')) != NULL) && (*(p+1) == 's') && !strchr(p+1,'%');
1011 }
1012
1013 /* This is an ugly hack to circumvent problems with passing command-line
1014    arguments that contain spaces.  The fix is to use a configuration file. */
1015 static char *
1016 translate_blanks(const char *cmd, const char *blankstr)
1017 {
1018   char *res;
1019   char *p;
1020   size_t bslen = strlen(blankstr);
1021
1022   if (!(res = strdup(cmd)))
1023     {
1024       perror("strdup");
1025       exit(1);
1026     }
1027   while ((p = strstr(res,blankstr)) != NULL)
1028     {
1029       *p = ' ';
1030       if (bslen != 1)
1031          memmove(p+1,p+bslen,strlen(p+bslen)+1);
1032     }
1033   return res;
1034 }
1035
1036 int
1037 main(int argc, char **argv)
1038 {
1039   const char *progname;
1040   int opt;
1041   int daemon_mode = 0;
1042   const char *pidfile = DEFAULT_PIDFILE;
1043   const char *special = "zebra";
1044   const char *blankstr = NULL;
1045   static struct quagga_signal_t my_signals[] =
1046   {
1047     {
1048       .signal = SIGINT,
1049       .handler = sigint,
1050     },
1051     {
1052       .signal = SIGTERM,
1053       .handler = sigint,
1054     },
1055     {
1056       .signal = SIGCHLD,
1057       .handler = sigchild,
1058     },
1059   };
1060
1061   if ((progname = strrchr (argv[0], '/')) != NULL)
1062     progname++;
1063   else
1064     progname = argv[0];
1065
1066   gs.restart.name = "all";
1067   while ((opt = getopt_long(argc, argv, "aAb:dek:l:m:M:i:p:r:R:S:s:t:T:zvh",
1068                             longopts, 0)) != EOF)
1069     {
1070       switch (opt)
1071         {
1072         case 0:
1073           break;
1074         case 'a':
1075           if ((gs.mode != MODE_MONITOR) && (gs.mode != MODE_SEPARATE_RESTART))
1076             {
1077               fputs("Ambiguous operating mode selected.\n",stderr);
1078               return usage(progname,1);
1079             }
1080           gs.mode = MODE_PHASED_ZEBRA_RESTART;
1081           break;
1082         case 'A':
1083           if ((gs.mode != MODE_MONITOR) && (gs.mode != MODE_SEPARATE_RESTART))
1084             {
1085               fputs("Ambiguous operating mode selected.\n",stderr);
1086               return usage(progname,1);
1087             }
1088           gs.mode = MODE_PHASED_ALL_RESTART;
1089           break;
1090         case 'b':
1091           blankstr = optarg;
1092           break;
1093         case 'd':
1094           daemon_mode = 1;
1095           break;
1096         case 'e':
1097           gs.do_ping = 0;
1098           break;
1099         case 'k':
1100           if (!valid_command(optarg))
1101           {
1102             fprintf(stderr,"Invalid kill command, must contain '%%s': %s\n",
1103                     optarg);
1104             return usage(progname,1);
1105           }
1106           gs.stop_command = optarg;
1107           break;
1108         case 'l':
1109           {
1110             char garbage[3];
1111             if ((sscanf(optarg,"%d%1s",&gs.loglevel,garbage) != 1) ||
1112                 (gs.loglevel < LOG_EMERG))
1113               {
1114                 fprintf(stderr,"Invalid loglevel argument: %s\n",optarg);
1115                 return usage(progname,1);
1116               }
1117           }
1118           break;
1119         case 'm':
1120           {
1121             char garbage[3];
1122             if ((sscanf(optarg,"%ld%1s",
1123                         &gs.min_restart_interval,garbage) != 1) ||
1124                 (gs.min_restart_interval < 0))
1125               {
1126                 fprintf(stderr,"Invalid min_restart_interval argument: %s\n",
1127                         optarg);
1128                 return usage(progname,1);
1129               }
1130           }
1131           break;
1132         case 'M':
1133           {
1134             char garbage[3];
1135             if ((sscanf(optarg,"%ld%1s",
1136                         &gs.max_restart_interval,garbage) != 1) ||
1137                 (gs.max_restart_interval < 0))
1138               {
1139                 fprintf(stderr,"Invalid max_restart_interval argument: %s\n",
1140                         optarg);
1141                 return usage(progname,1);
1142               }
1143           }
1144           break;
1145         case 'i':
1146           {
1147             char garbage[3];
1148             int period;
1149             if ((sscanf(optarg,"%d%1s",&period,garbage) != 1) ||
1150                 (gs.period < 1))
1151               {
1152                 fprintf(stderr,"Invalid interval argument: %s\n",optarg);
1153                 return usage(progname,1);
1154               }
1155             gs.period = 1000*period;
1156           }
1157           break;
1158         case 'p':
1159           pidfile = optarg;
1160           break;
1161         case 'r':
1162           if ((gs.mode == MODE_GLOBAL_RESTART) ||
1163               (gs.mode == MODE_SEPARATE_RESTART))
1164             {
1165               fputs("Ambiguous operating mode selected.\n",stderr);
1166               return usage(progname,1);
1167             }
1168           if (!valid_command(optarg))
1169           {
1170             fprintf(stderr,
1171                     "Invalid restart command, must contain '%%s': %s\n",
1172                     optarg);
1173             return usage(progname,1);
1174           }
1175           gs.restart_command = optarg;
1176           if (gs.mode == MODE_MONITOR)
1177             gs.mode = MODE_SEPARATE_RESTART;
1178           break;
1179         case 'R':
1180           if (gs.mode != MODE_MONITOR)
1181             {
1182               fputs("Ambiguous operating mode selected.\n",stderr);
1183               return usage(progname,1);
1184             }
1185           if (strchr(optarg,'%'))
1186             {
1187               fprintf(stderr,
1188                       "Invalid restart-all arg, must not contain '%%s': %s\n",
1189                       optarg);
1190               return usage(progname,1);
1191             }
1192           gs.restart_command = optarg;
1193           gs.mode = MODE_GLOBAL_RESTART;
1194           break;
1195         case 's':
1196           if (!valid_command(optarg))
1197           {
1198             fprintf(stderr,"Invalid start command, must contain '%%s': %s\n",
1199                     optarg);
1200             return usage(progname,1);
1201           }
1202           gs.start_command = optarg;
1203           break;
1204         case 'S':
1205           gs.vtydir = optarg;
1206           break;
1207         case 't':
1208           {
1209             char garbage[3];
1210             if ((sscanf(optarg,"%ld%1s",&gs.timeout,garbage) != 1) ||
1211                 (gs.timeout < 1))
1212               {
1213                 fprintf(stderr,"Invalid timeout argument: %s\n",optarg);
1214                 return usage(progname,1);
1215               }
1216           }
1217           break;
1218         case 'T':
1219           {
1220             char garbage[3];
1221             if ((sscanf(optarg,"%ld%1s",&gs.restart_timeout,garbage) != 1) ||
1222                 (gs.restart_timeout < 1))
1223               {
1224                 fprintf(stderr,"Invalid restart timeout argument: %s\n",optarg);
1225                 return usage(progname,1);
1226               }
1227           }
1228           break;
1229         case 'z':
1230           gs.unresponsive_restart = 1;
1231           break;
1232         case 'v':
1233           printf ("%s version %s\n", progname, QUAGGA_VERSION);
1234           puts("Copyright 2004 Andrew J. Schorr");
1235           return 0;
1236         case 'h':
1237           return usage(progname,0);
1238         default:
1239           fputs("Invalid option.\n",stderr);
1240           return usage(progname,1);
1241         }
1242     }
1243
1244   if (gs.unresponsive_restart && (gs.mode == MODE_MONITOR))
1245     {
1246       fputs("Option -z requires a -r or -R restart option.\n",stderr);
1247       return usage(progname,1);
1248     }
1249   switch (gs.mode)
1250     {
1251     case MODE_MONITOR:
1252       if (gs.restart_command || gs.start_command || gs.stop_command)
1253         {
1254           fprintf(stderr,"No kill/(re)start commands needed for %s mode.\n",
1255                   mode_str[gs.mode]);
1256           return usage(progname,1);
1257         }
1258       break;
1259     case MODE_GLOBAL_RESTART:
1260     case MODE_SEPARATE_RESTART:
1261       if (!gs.restart_command || gs.start_command || gs.stop_command)
1262         {
1263           fprintf(stderr,"No start/kill commands needed in [%s] mode.\n",
1264                   mode_str[gs.mode]);
1265           return usage(progname,1);
1266         }
1267       break;
1268     case MODE_PHASED_ZEBRA_RESTART:
1269     case MODE_PHASED_ALL_RESTART:
1270       if (!gs.restart_command || !gs.start_command || !gs.stop_command)
1271         {
1272           fprintf(stderr,
1273                   "Need start, kill, and restart commands in [%s] mode.\n",
1274                   mode_str[gs.mode]);
1275           return usage(progname,1);
1276         }
1277       break;
1278     }
1279
1280   if (blankstr)
1281     {
1282       if (gs.restart_command)
1283         gs.restart_command = translate_blanks(gs.restart_command,blankstr);
1284       if (gs.start_command)
1285         gs.start_command = translate_blanks(gs.start_command,blankstr);
1286       if (gs.stop_command)
1287         gs.stop_command = translate_blanks(gs.stop_command,blankstr);
1288     }
1289
1290   gs.restart.interval = gs.min_restart_interval;
1291   master = thread_master_create();
1292   signal_init (master, array_size(my_signals), my_signals);
1293   srandom(time(NULL));
1294
1295   {
1296     int i;
1297     struct daemon *tail = NULL;
1298
1299     for (i = optind; i < argc; i++)
1300       {
1301         struct daemon *dmn;
1302
1303         if (!(dmn = (struct daemon *)calloc(1,sizeof(*dmn))))
1304           {
1305             fprintf(stderr,"calloc(1,%u) failed: %s\n",
1306                     (u_int)sizeof(*dmn), safe_strerror(errno));
1307             return 1;
1308           }
1309         dmn->name = dmn->restart.name = argv[i];
1310         dmn->state = DAEMON_INIT;
1311         gs.numdaemons++;
1312         gs.numdown++;
1313         dmn->fd = -1;
1314         dmn->t_wakeup = thread_add_timer_msec(master,wakeup_init,dmn,
1315                                               100+(random() % 900));
1316         dmn->restart.interval = gs.min_restart_interval;
1317         if (tail)
1318           tail->next = dmn;
1319         else
1320           gs.daemons = dmn;
1321         tail = dmn;
1322
1323         if (((gs.mode == MODE_PHASED_ZEBRA_RESTART) ||
1324              (gs.mode == MODE_PHASED_ALL_RESTART)) &&
1325             !strcmp(dmn->name,special))
1326           gs.special = dmn;
1327       }
1328   }
1329   if (!gs.daemons)
1330     {
1331       fputs("Must specify one or more daemons to monitor.\n",stderr);
1332       return usage(progname,1);
1333     }
1334   if (((gs.mode == MODE_PHASED_ZEBRA_RESTART) ||
1335       (gs.mode == MODE_PHASED_ALL_RESTART)) && !gs.special)
1336     {
1337       fprintf(stderr,"In mode [%s], but cannot find master daemon %s\n",
1338               mode_str[gs.mode],special);
1339       return usage(progname,1);
1340     }
1341   if (gs.special && (gs.numdaemons < 2))
1342     {
1343       fprintf(stderr,"Mode [%s] does not make sense with only 1 daemon "
1344                      "to watch.\n",mode_str[gs.mode]);
1345       return usage(progname,1);
1346     }
1347
1348   zlog_default = openzlog(progname, ZLOG_NONE,
1349                           LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
1350   zlog_set_level(NULL, ZLOG_DEST_MONITOR, ZLOG_DISABLED);
1351   if (daemon_mode)
1352     {
1353       zlog_set_level(NULL, ZLOG_DEST_SYSLOG, MIN(gs.loglevel,LOG_DEBUG));
1354       if (daemon (0, 0) < 0)
1355         {
1356           fprintf(stderr, "Watchquagga daemon failed: %s", strerror(errno));
1357           exit (1);
1358         }
1359     }
1360   else
1361     zlog_set_level(NULL, ZLOG_DEST_STDOUT, MIN(gs.loglevel,LOG_DEBUG));
1362
1363   /* Make sure we're not already running. */
1364   pid_output (pidfile);
1365
1366   /* Announce which daemons are being monitored. */
1367   {
1368     struct daemon *dmn;
1369     size_t len = 0;
1370
1371     for (dmn = gs.daemons; dmn; dmn = dmn->next)
1372       len += strlen(dmn->name)+1;
1373
1374     {
1375       char buf[len+1];
1376       char *p = buf;
1377
1378       for (dmn = gs.daemons; dmn; dmn = dmn->next)
1379         {
1380           if (p != buf)
1381             *p++ = ' ';
1382           strcpy(p,dmn->name);
1383           p += strlen(p);
1384         }
1385       zlog_notice("%s %s watching [%s], mode [%s]",
1386                   progname, QUAGGA_VERSION, buf, mode_str[gs.mode]);
1387     }
1388   }
1389
1390   {
1391     struct thread thread;
1392
1393     while (thread_fetch (master, &thread))
1394       thread_call (&thread);
1395   }
1396
1397   /* Not reached. */
1398   return 0;
1399 }