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

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

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