Annotation of embedaddon/quagga/ripngd/ripng_main.c, revision 1.1.1.2

1.1       misho       1: /*
                      2:  * RIPngd main routine.
                      3:  * Copyright (C) 1998, 1999 Kunihiro Ishiguro
                      4:  *
                      5:  * This file is part of GNU Zebra.
                      6:  *
                      7:  * GNU Zebra is free software; you can redistribute it and/or modify it
                      8:  * under the terms of the GNU General Public License as published by the
                      9:  * Free Software Foundation; either version 2, or (at your option) any
                     10:  * later version.
                     11:  *
                     12:  * GNU Zebra is distributed in the hope that it will be useful, but
                     13:  * WITHOUT ANY WARRANTY; without even the implied warranty of
                     14:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     15:  * General Public License for more details.
                     16:  *
                     17:  * You should have received a copy of the GNU General Public License
                     18:  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
                     19:  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
                     20:  * 02111-1307, USA.  
                     21:  */
                     22: 
                     23: #include <zebra.h>
                     24: 
                     25: #include <lib/version.h>
                     26: #include "getopt.h"
                     27: #include "vector.h"
                     28: #include "vty.h"
                     29: #include "command.h"
                     30: #include "memory.h"
                     31: #include "thread.h"
                     32: #include "log.h"
                     33: #include "prefix.h"
                     34: #include "if.h"
                     35: #include "privs.h"
                     36: #include "sigevent.h"
                     37: 
                     38: #include "ripngd/ripngd.h"
                     39: 
                     40: /* Configuration filename and directory. */
                     41: char config_default[] = SYSCONFDIR RIPNG_DEFAULT_CONFIG;
                     42: char *config_file = NULL;
                     43: 
                     44: /* RIPngd options. */
                     45: struct option longopts[] = 
                     46: {
                     47:   { "daemon",      no_argument,       NULL, 'd'},
                     48:   { "config_file", required_argument, NULL, 'f'},
                     49:   { "pid_file",    required_argument, NULL, 'i'},
1.1.1.2 ! misho      50:   { "socket",      required_argument, NULL, 'z'},
1.1       misho      51:   { "dryrun",      no_argument,       NULL, 'C'},
                     52:   { "help",        no_argument,       NULL, 'h'},
                     53:   { "vty_addr",    required_argument, NULL, 'A'},
                     54:   { "vty_port",    required_argument, NULL, 'P'},
                     55:   { "retain",      no_argument,       NULL, 'r'},
                     56:   { "user",        required_argument, NULL, 'u'},
                     57:   { "group",       required_argument, NULL, 'g'},
                     58:   { "version",     no_argument,       NULL, 'v'},
                     59:   { 0 }
                     60: };
                     61: 
                     62: /* ripngd privileges */
                     63: zebra_capabilities_t _caps_p [] = 
                     64: {
                     65:   ZCAP_NET_RAW,
                     66:   ZCAP_BIND
                     67: };
                     68: 
                     69: struct zebra_privs_t ripngd_privs =
                     70: {
                     71: #if defined(QUAGGA_USER)
                     72:   .user = QUAGGA_USER,
                     73: #endif
                     74: #if defined QUAGGA_GROUP
                     75:   .group = QUAGGA_GROUP,
                     76: #endif
                     77: #ifdef VTY_GROUP
                     78:   .vty_group = VTY_GROUP,
                     79: #endif
                     80:   .caps_p = _caps_p,
                     81:   .cap_num_p = 2,
                     82:   .cap_num_i = 0
                     83: };
                     84: 
                     85: 
                     86: /* RIPngd program name */
                     87: 
                     88: /* Route retain mode flag. */
                     89: int retain_mode = 0;
                     90: 
                     91: /* RIPng VTY bind address. */
                     92: char *vty_addr = NULL;
                     93: 
                     94: /* RIPng VTY connection port. */
                     95: int vty_port = RIPNG_VTY_PORT;
                     96: 
                     97: /* Master of threads. */
                     98: struct thread_master *master;
                     99: 
                    100: /* Process ID saved for use by init system */
                    101: const char *pid_file = PATH_RIPNGD_PID;
                    102: 
                    103: /* Help information display. */
                    104: static void
                    105: usage (char *progname, int status)
                    106: {
                    107:   if (status != 0)
                    108:     fprintf (stderr, "Try `%s --help' for more information.\n", progname);
                    109:   else
                    110:     {    
                    111:       printf ("Usage : %s [OPTION...]\n\
                    112: Daemon which manages RIPng.\n\n\
                    113: -d, --daemon       Runs in daemon mode\n\
                    114: -f, --config_file  Set configuration file name\n\
                    115: -i, --pid_file     Set process identifier file name\n\
1.1.1.2 ! misho     116: -z, --socket       Set path of zebra socket\n\
1.1       misho     117: -A, --vty_addr     Set vty's bind address\n\
                    118: -P, --vty_port     Set vty's port number\n\
                    119: -r, --retain       When program terminates, retain added route by ripngd.\n\
                    120: -u, --user         User to run as\n\
                    121: -g, --group        Group to run as\n\
                    122: -v, --version      Print program version\n\
                    123: -C, --dryrun       Check configuration for validity and exit\n\
                    124: -h, --help         Display this help and exit\n\
                    125: \n\
                    126: Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
                    127:     }
                    128:   exit (status);
                    129: }
                    130: 
                    131: /* SIGHUP handler. */
                    132: static void 
                    133: sighup (void)
                    134: {
                    135:   zlog_info ("SIGHUP received");
                    136:   ripng_clean ();
                    137:   ripng_reset ();
                    138: 
                    139:   /* Reload config file. */
                    140:   vty_read_config (config_file, config_default);
                    141:   /* Create VTY's socket */
                    142:   vty_serv_sock (vty_addr, vty_port, RIPNG_VTYSH_PATH);
                    143: 
                    144:   /* Try to return to normal operation. */
                    145: }
                    146: 
                    147: /* SIGINT handler. */
                    148: static void
                    149: sigint (void)
                    150: {
                    151:   zlog_notice ("Terminating on signal");
                    152: 
                    153:   if (! retain_mode)
                    154:     ripng_clean ();
                    155: 
                    156:   exit (0);
                    157: }
                    158: 
                    159: /* SIGUSR1 handler. */
                    160: static void
                    161: sigusr1 (void)
                    162: {
                    163:   zlog_rotate (NULL);
                    164: }
                    165: 
                    166: struct quagga_signal_t ripng_signals[] =
                    167: {
                    168:   { 
                    169:     .signal = SIGHUP, 
                    170:     .handler = &sighup,
                    171:   },
                    172:   {
                    173:     .signal = SIGUSR1,
                    174:     .handler = &sigusr1,
                    175:   },
                    176:   {
                    177:     .signal = SIGINT,
                    178:     .handler = &sigint,
                    179:   },
                    180:   {
                    181:     .signal = SIGTERM,
                    182:     .handler = &sigint,
                    183:   },
                    184: };
                    185: 
                    186: /* RIPngd main routine. */
                    187: int
                    188: main (int argc, char **argv)
                    189: {
                    190:   char *p;
                    191:   int vty_port = RIPNG_VTY_PORT;
                    192:   int daemon_mode = 0;
                    193:   char *progname;
                    194:   struct thread thread;
                    195:   int dryrun = 0;
                    196: 
                    197:   /* Set umask before anything for security */
                    198:   umask (0027);
                    199: 
                    200:   /* get program name */
                    201:   progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
                    202: 
                    203:   zlog_default = openzlog(progname, ZLOG_RIPNG,
                    204:                          LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
                    205: 
                    206:   while (1) 
                    207:     {
                    208:       int opt;
                    209: 
1.1.1.2 ! misho     210:       opt = getopt_long (argc, argv, "df:i:z:hA:P:u:g:vC", longopts, 0);
1.1       misho     211:     
                    212:       if (opt == EOF)
                    213:        break;
                    214: 
                    215:       switch (opt) 
                    216:        {
                    217:        case 0:
                    218:          break;
                    219:        case 'd':
                    220:          daemon_mode = 1;
                    221:          break;
                    222:        case 'f':
                    223:          config_file = optarg;
                    224:          break;
                    225:        case 'A':
                    226:          vty_addr = optarg;
                    227:          break;
                    228:         case 'i':
                    229:           pid_file = optarg;
1.1.1.2 ! misho     230:           break;
        !           231:        case 'z':
        !           232:          zclient_serv_path_set (optarg);
        !           233:          break;
1.1       misho     234:        case 'P':
                    235:           /* Deal with atoi() returning 0 on failure, and ripngd not
                    236:              listening on ripngd port... */
                    237:           if (strcmp(optarg, "0") == 0) 
                    238:             {
                    239:               vty_port = 0;
                    240:               break;
                    241:             } 
                    242:           vty_port = atoi (optarg);
                    243:           if (vty_port <= 0 || vty_port > 0xffff)
                    244:             vty_port = RIPNG_VTY_PORT;
                    245:           break;
                    246:        case 'r':
                    247:          retain_mode = 1;
                    248:          break;
                    249:        case 'u':
                    250:          ripngd_privs.user = optarg;
                    251:          break;
                    252:        case 'g':
                    253:          ripngd_privs.group = optarg;
                    254:          break;
                    255:        case 'v':
                    256:          print_version (progname);
                    257:          exit (0);
                    258:          break;
                    259:        case 'C':
                    260:          dryrun = 1;
                    261:          break;
                    262:        case 'h':
                    263:          usage (progname, 0);
                    264:          break;
                    265:        default:
                    266:          usage (progname, 1);
                    267:          break;
                    268:        }
                    269:     }
                    270: 
                    271:   master = thread_master_create ();
                    272: 
                    273:   /* Library inits. */
                    274:   zprivs_init (&ripngd_privs);
                    275:   signal_init (master, Q_SIGC(ripng_signals), ripng_signals);
                    276:   cmd_init (1);
                    277:   vty_init (master);
                    278:   memory_init ();
                    279: 
                    280:   /* RIPngd inits. */
                    281:   ripng_init ();
                    282:   zebra_init ();
                    283:   ripng_peer_init ();
                    284: 
                    285:   /* Sort all installed commands. */
                    286:   sort_node ();
                    287: 
                    288:   /* Get configuration file. */
                    289:   vty_read_config (config_file, config_default);
                    290: 
                    291:   /* Start execution only if not in dry-run mode */
                    292:   if(dryrun)
                    293:     return(0);
                    294:   
                    295:   /* Change to the daemon program. */
                    296:   if (daemon_mode && daemon (0, 0) < 0)
                    297:     {
                    298:       zlog_err("RIPNGd daemon failed: %s", strerror(errno));
                    299:       exit (1);
                    300:     }
                    301: 
                    302:   /* Create VTY socket */
                    303:   vty_serv_sock (vty_addr, vty_port, RIPNG_VTYSH_PATH);
                    304: 
                    305:   /* Process id file create. */
                    306:   pid_output (pid_file);
                    307: 
                    308:   /* Print banner. */
                    309:   zlog_notice ("RIPNGd %s starting: vty@%d", QUAGGA_VERSION, vty_port);
                    310: 
                    311:   /* Fetch next active thread. */
                    312:   while (thread_fetch (master, &thread))
                    313:     thread_call (&thread);
                    314: 
                    315:   /* Not reached. */
                    316:   return 0;
                    317: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>