Annotation of embedaddon/quagga/ospfd/ospf_main.c, revision 1.1.1.3

1.1       misho       1: /*
                      2:  * OSPFd main routine.
                      3:  *   Copyright (C) 1998, 99 Kunihiro Ishiguro, Toshiaki Takada
                      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 "thread.h"
                     28: #include "prefix.h"
                     29: #include "linklist.h"
                     30: #include "if.h"
                     31: #include "vector.h"
                     32: #include "vty.h"
                     33: #include "command.h"
                     34: #include "filter.h"
                     35: #include "plist.h"
                     36: #include "stream.h"
                     37: #include "log.h"
                     38: #include "memory.h"
                     39: #include "privs.h"
                     40: #include "sigevent.h"
1.1.1.2   misho      41: #include "zclient.h"
1.1       misho      42: 
                     43: #include "ospfd/ospfd.h"
                     44: #include "ospfd/ospf_interface.h"
                     45: #include "ospfd/ospf_asbr.h"
                     46: #include "ospfd/ospf_lsa.h"
                     47: #include "ospfd/ospf_lsdb.h"
                     48: #include "ospfd/ospf_neighbor.h"
                     49: #include "ospfd/ospf_dump.h"
                     50: #include "ospfd/ospf_zebra.h"
                     51: #include "ospfd/ospf_vty.h"
                     52: 
                     53: /* ospfd privileges */
                     54: zebra_capabilities_t _caps_p [] = 
                     55: {
                     56:   ZCAP_NET_RAW,
                     57:   ZCAP_BIND,
                     58:   ZCAP_NET_ADMIN,
                     59: };
                     60: 
                     61: struct zebra_privs_t ospfd_privs =
                     62: {
                     63: #if defined(QUAGGA_USER) && defined(QUAGGA_GROUP)
                     64:   .user = QUAGGA_USER,
                     65:   .group = QUAGGA_GROUP,
                     66: #endif
                     67: #if defined(VTY_GROUP)
                     68:   .vty_group = VTY_GROUP,
                     69: #endif
                     70:   .caps_p = _caps_p,
1.1.1.3 ! misho      71:   .cap_num_p = array_size(_caps_p),
1.1       misho      72:   .cap_num_i = 0
                     73: };
                     74: 
                     75: /* Configuration filename and directory. */
                     76: char config_default[] = SYSCONFDIR OSPF_DEFAULT_CONFIG;
                     77: 
                     78: /* OSPFd options. */
                     79: struct option longopts[] = 
                     80: {
                     81:   { "daemon",      no_argument,       NULL, 'd'},
                     82:   { "config_file", required_argument, NULL, 'f'},
                     83:   { "pid_file",    required_argument, NULL, 'i'},
1.1.1.2   misho      84:   { "socket",      required_argument, NULL, 'z'},
1.1       misho      85:   { "dryrun",      no_argument,       NULL, 'C'},
                     86:   { "help",        no_argument,       NULL, 'h'},
                     87:   { "vty_addr",    required_argument, NULL, 'A'},
                     88:   { "vty_port",    required_argument, NULL, 'P'},
                     89:   { "user",        required_argument, NULL, 'u'},
                     90:   { "group",       required_argument, NULL, 'g'},
                     91:   { "apiserver",   no_argument,       NULL, 'a'},
                     92:   { "version",     no_argument,       NULL, 'v'},
                     93:   { 0 }
                     94: };
                     95: 
                     96: /* OSPFd program name */
                     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_OSPFD_PID;
                    103: 
                    104: #ifdef SUPPORT_OSPF_API
                    105: extern int ospf_apiserver_enable;
                    106: #endif /* SUPPORT_OSPF_API */
                    107: 
                    108: /* Help information display. */
                    109: static void __attribute__ ((noreturn))
                    110: usage (char *progname, int status)
                    111: {
                    112:   if (status != 0)
                    113:     fprintf (stderr, "Try `%s --help' for more information.\n", progname);
                    114:   else
                    115:     {    
                    116:       printf ("Usage : %s [OPTION...]\n\
                    117: Daemon which manages OSPF.\n\n\
                    118: -d, --daemon       Runs in daemon mode\n\
                    119: -f, --config_file  Set configuration file name\n\
                    120: -i, --pid_file     Set process identifier file name\n\
1.1.1.2   misho     121: -z, --socket       Set path of zebra socket\n\
1.1       misho     122: -A, --vty_addr     Set vty's bind address\n\
                    123: -P, --vty_port     Set vty's port number\n\
                    124: -u, --user         User to run as\n\
                    125: -g, --group        Group to run as\n\
                    126: -a. --apiserver    Enable OSPF apiserver\n\
                    127: -v, --version      Print program version\n\
                    128: -C, --dryrun       Check configuration for validity and exit\n\
                    129: -h, --help         Display this help and exit\n\
                    130: \n\
                    131: Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
                    132:     }
                    133:   exit (status);
                    134: }
                    135: 
                    136: /* SIGHUP handler. */
                    137: static void 
                    138: sighup (void)
                    139: {
                    140:   zlog (NULL, LOG_INFO, "SIGHUP received");
                    141: }
                    142: 
                    143: /* SIGINT / SIGTERM handler. */
                    144: static void
                    145: sigint (void)
                    146: {
                    147:   zlog_notice ("Terminating on signal");
                    148:   ospf_terminate ();
                    149: }
                    150: 
                    151: /* SIGUSR1 handler. */
                    152: static void
                    153: sigusr1 (void)
                    154: {
                    155:   zlog_rotate (NULL);
                    156: }
                    157: 
                    158: struct quagga_signal_t ospf_signals[] =
                    159: {
                    160:   {
                    161:     .signal = SIGHUP,
                    162:     .handler = &sighup,
                    163:   },
                    164:   {
                    165:     .signal = SIGUSR1,
                    166:     .handler = &sigusr1,
                    167:   },  
                    168:   {
                    169:     .signal = SIGINT,
                    170:     .handler = &sigint,
                    171:   },
                    172:   {
                    173:     .signal = SIGTERM,
                    174:     .handler = &sigint,
                    175:   },
                    176: };
                    177: 
                    178: /* OSPFd main routine. */
                    179: int
                    180: main (int argc, char **argv)
                    181: {
                    182:   char *p;
                    183:   char *vty_addr = NULL;
                    184:   int vty_port = OSPF_VTY_PORT;
                    185:   int daemon_mode = 0;
                    186:   char *config_file = NULL;
                    187:   char *progname;
                    188:   struct thread thread;
                    189:   int dryrun = 0;
                    190: 
                    191:   /* Set umask before anything for security */
                    192:   umask (0027);
                    193: 
1.1.1.3 ! misho     194: #ifdef SUPPORT_OSPF_API
        !           195:   /* OSPF apiserver is disabled by default. */
        !           196:   ospf_apiserver_enable = 0;
        !           197: #endif /* SUPPORT_OSPF_API */
        !           198: 
1.1       misho     199:   /* get program name */
                    200:   progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
                    201: 
                    202:   while (1) 
                    203:     {
                    204:       int opt;
                    205: 
1.1.1.2   misho     206:       opt = getopt_long (argc, argv, "df:i:z:hA:P:u:g:avC", longopts, 0);
1.1       misho     207:     
                    208:       if (opt == EOF)
                    209:        break;
                    210: 
                    211:       switch (opt) 
                    212:        {
                    213:        case 0:
                    214:          break;
                    215:        case 'd':
                    216:          daemon_mode = 1;
                    217:          break;
                    218:        case 'f':
                    219:          config_file = optarg;
                    220:          break;
                    221:        case 'A':
                    222:          vty_addr = optarg;
                    223:          break;
                    224:         case 'i':
                    225:           pid_file = optarg;
                    226:           break;
1.1.1.2   misho     227:        case 'z':
                    228:          zclient_serv_path_set (optarg);
                    229:          break;
1.1       misho     230:        case 'P':
                    231:           /* Deal with atoi() returning 0 on failure, and ospfd not
                    232:              listening on ospfd port... */
                    233:           if (strcmp(optarg, "0") == 0) 
                    234:             {
                    235:               vty_port = 0;
                    236:               break;
                    237:             } 
                    238:           vty_port = atoi (optarg);
                    239:           if (vty_port <= 0 || vty_port > 0xffff)
                    240:             vty_port = OSPF_VTY_PORT;
                    241:          break;
                    242:        case 'u':
                    243:          ospfd_privs.user = optarg;
                    244:          break;
                    245:        case 'g':
                    246:          ospfd_privs.group = optarg;
                    247:          break;
                    248: #ifdef SUPPORT_OSPF_API
                    249:        case 'a':
                    250:          ospf_apiserver_enable = 1;
                    251:          break;
                    252: #endif /* SUPPORT_OSPF_API */
                    253:        case 'v':
                    254:          print_version (progname);
                    255:          exit (0);
                    256:          break;
                    257:        case 'C':
                    258:          dryrun = 1;
                    259:          break;
                    260:        case 'h':
                    261:          usage (progname, 0);
                    262:          break;
                    263:        default:
                    264:          usage (progname, 1);
                    265:          break;
                    266:        }
                    267:     }
                    268: 
1.1.1.2   misho     269:   /* Invoked by a priviledged user? -- endo. */
                    270:   if (geteuid () != 0)
                    271:     {
                    272:       errno = EPERM;
                    273:       perror (progname);
                    274:       exit (1);
                    275:     }
                    276: 
                    277:   zlog_default = openzlog (progname, ZLOG_OSPF,
                    278:                           LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
                    279: 
                    280:   /* OSPF master init. */
                    281:   ospf_master_init ();
                    282: 
1.1       misho     283:   /* Initializations. */
                    284:   master = om->master;
                    285: 
                    286:   /* Library inits. */
                    287:   zprivs_init (&ospfd_privs);
1.1.1.3 ! misho     288:   signal_init (master, array_size(ospf_signals), ospf_signals);
1.1       misho     289:   cmd_init (1);
                    290:   debug_init ();
                    291:   vty_init (master);
                    292:   memory_init ();
                    293: 
                    294:   access_list_init ();
                    295:   prefix_list_init ();
                    296: 
                    297:   /* OSPFd inits. */
                    298:   ospf_if_init ();
                    299:   ospf_zebra_init ();
                    300: 
                    301:   /* OSPF vty inits. */
                    302:   ospf_vty_init ();
                    303:   ospf_vty_show_init ();
                    304: 
                    305:   ospf_route_map_init ();
                    306: #ifdef HAVE_SNMP
                    307:   ospf_snmp_init ();
                    308: #endif /* HAVE_SNMP */
                    309: #ifdef HAVE_OPAQUE_LSA
                    310:   ospf_opaque_init ();
                    311: #endif /* HAVE_OPAQUE_LSA */
                    312:   
                    313:   sort_node ();
                    314: 
                    315:   /* Get configuration file. */
                    316:   vty_read_config (config_file, config_default);
                    317: 
                    318:   /* Start execution only if not in dry-run mode */
                    319:   if (dryrun)
                    320:     return(0);
                    321:   
                    322:   /* Change to the daemon program. */
                    323:   if (daemon_mode && daemon (0, 0) < 0)
                    324:     {
                    325:       zlog_err("OSPFd daemon failed: %s", strerror(errno));
                    326:       exit (1);
                    327:     }
                    328: 
                    329:   /* Process id file create. */
                    330:   pid_output (pid_file);
                    331: 
                    332:   /* Create VTY socket */
                    333:   vty_serv_sock (vty_addr, vty_port, OSPF_VTYSH_PATH);
                    334: 
                    335:   /* Print banner. */
                    336:   zlog_notice ("OSPFd %s starting: vty@%d", QUAGGA_VERSION, vty_port);
                    337: 
                    338:   /* Fetch next active thread. */
                    339:   while (thread_fetch (master, &thread))
                    340:     thread_call (&thread);
                    341: 
                    342:   /* Not reached. */
                    343:   return (0);
                    344: }
                    345: 

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