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