/* * RIPngd main routine. * Copyright (C) 1998, 1999 Kunihiro Ishiguro * * This file is part of GNU Zebra. * * GNU Zebra is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2, or (at your option) any * later version. * * GNU Zebra is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GNU Zebra; see the file COPYING. If not, write to the Free * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA * 02111-1307, USA. */ #include #include #include "getopt.h" #include "vector.h" #include "vty.h" #include "command.h" #include "memory.h" #include "thread.h" #include "log.h" #include "prefix.h" #include "if.h" #include "privs.h" #include "sigevent.h" #include "ripngd/ripngd.h" /* Configuration filename and directory. */ char config_default[] = SYSCONFDIR RIPNG_DEFAULT_CONFIG; char *config_file = NULL; /* RIPngd options. */ struct option longopts[] = { { "daemon", no_argument, NULL, 'd'}, { "config_file", required_argument, NULL, 'f'}, { "pid_file", required_argument, NULL, 'i'}, { "socket", required_argument, NULL, 'z'}, { "dryrun", no_argument, NULL, 'C'}, { "help", no_argument, NULL, 'h'}, { "vty_addr", required_argument, NULL, 'A'}, { "vty_port", required_argument, NULL, 'P'}, { "retain", no_argument, NULL, 'r'}, { "user", required_argument, NULL, 'u'}, { "group", required_argument, NULL, 'g'}, { "version", no_argument, NULL, 'v'}, { 0 } }; /* ripngd privileges */ zebra_capabilities_t _caps_p [] = { ZCAP_NET_RAW, ZCAP_BIND }; struct zebra_privs_t ripngd_privs = { #if defined(QUAGGA_USER) .user = QUAGGA_USER, #endif #if defined QUAGGA_GROUP .group = QUAGGA_GROUP, #endif #ifdef VTY_GROUP .vty_group = VTY_GROUP, #endif .caps_p = _caps_p, .cap_num_p = 2, .cap_num_i = 0 }; /* RIPngd program name */ /* Route retain mode flag. */ int retain_mode = 0; /* RIPng VTY bind address. */ char *vty_addr = NULL; /* RIPng VTY connection port. */ int vty_port = RIPNG_VTY_PORT; /* Master of threads. */ struct thread_master *master; /* Process ID saved for use by init system */ const char *pid_file = PATH_RIPNGD_PID; /* Help information display. */ static void usage (char *progname, int status) { if (status != 0) fprintf (stderr, "Try `%s --help' for more information.\n", progname); else { printf ("Usage : %s [OPTION...]\n\ Daemon which manages RIPng.\n\n\ -d, --daemon Runs in daemon mode\n\ -f, --config_file Set configuration file name\n\ -i, --pid_file Set process identifier file name\n\ -z, --socket Set path of zebra socket\n\ -A, --vty_addr Set vty's bind address\n\ -P, --vty_port Set vty's port number\n\ -r, --retain When program terminates, retain added route by ripngd.\n\ -u, --user User to run as\n\ -g, --group Group to run as\n\ -v, --version Print program version\n\ -C, --dryrun Check configuration for validity and exit\n\ -h, --help Display this help and exit\n\ \n\ Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS); } exit (status); } /* SIGHUP handler. */ static void sighup (void) { zlog_info ("SIGHUP received"); ripng_clean (); ripng_reset (); /* Reload config file. */ vty_read_config (config_file, config_default); /* Create VTY's socket */ vty_serv_sock (vty_addr, vty_port, RIPNG_VTYSH_PATH); /* Try to return to normal operation. */ } /* SIGINT handler. */ static void sigint (void) { zlog_notice ("Terminating on signal"); if (! retain_mode) ripng_clean (); exit (0); } /* SIGUSR1 handler. */ static void sigusr1 (void) { zlog_rotate (NULL); } struct quagga_signal_t ripng_signals[] = { { .signal = SIGHUP, .handler = &sighup, }, { .signal = SIGUSR1, .handler = &sigusr1, }, { .signal = SIGINT, .handler = &sigint, }, { .signal = SIGTERM, .handler = &sigint, }, }; /* RIPngd main routine. */ int main (int argc, char **argv) { char *p; int vty_port = RIPNG_VTY_PORT; int daemon_mode = 0; char *progname; struct thread thread; int dryrun = 0; /* Set umask before anything for security */ umask (0027); /* get program name */ progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]); zlog_default = openzlog(progname, ZLOG_RIPNG, LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON); while (1) { int opt; opt = getopt_long (argc, argv, "df:i:z:hA:P:u:g:vC", longopts, 0); if (opt == EOF) break; switch (opt) { case 0: break; case 'd': daemon_mode = 1; break; case 'f': config_file = optarg; break; case 'A': vty_addr = optarg; break; case 'i': pid_file = optarg; break; case 'z': zclient_serv_path_set (optarg); break; case 'P': /* Deal with atoi() returning 0 on failure, and ripngd not listening on ripngd port... */ if (strcmp(optarg, "0") == 0) { vty_port = 0; break; } vty_port = atoi (optarg); if (vty_port <= 0 || vty_port > 0xffff) vty_port = RIPNG_VTY_PORT; break; case 'r': retain_mode = 1; break; case 'u': ripngd_privs.user = optarg; break; case 'g': ripngd_privs.group = optarg; break; case 'v': print_version (progname); exit (0); break; case 'C': dryrun = 1; break; case 'h': usage (progname, 0); break; default: usage (progname, 1); break; } } master = thread_master_create (); /* Library inits. */ zprivs_init (&ripngd_privs); signal_init (master, array_size(ripng_signals), ripng_signals); cmd_init (1); vty_init (master); memory_init (); /* RIPngd inits. */ ripng_init (); zebra_init (); ripng_peer_init (); /* Sort all installed commands. */ sort_node (); /* Get configuration file. */ vty_read_config (config_file, config_default); /* Start execution only if not in dry-run mode */ if(dryrun) return(0); /* Change to the daemon program. */ if (daemon_mode && daemon (0, 0) < 0) { zlog_err("RIPNGd daemon failed: %s", strerror(errno)); exit (1); } /* Create VTY socket */ vty_serv_sock (vty_addr, vty_port, RIPNG_VTYSH_PATH); /* Process id file create. */ pid_output (pid_file); /* Print banner. */ zlog_notice ("RIPNGd %s starting: vty@%d", QUAGGA_VERSION, vty_port); /* Fetch next active thread. */ while (thread_fetch (master, &thread)) thread_call (&thread); /* Not reached. */ return 0; }