zebra/test_main.c

   1 /* main routine.
   2  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   3  *
   4  * GNU Zebra is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2, or (at your option) any
   7  * later version.
   8  *
   9  * GNU Zebra is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  16  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17  * 02111-1307, USA.
  18  */
  19
  20 #include <zebra.h>
  21
  22 #include <lib/version.h>
  23 #include "getopt.h"
  24 #include "command.h"
  25 #include "thread.h"
  26 #include "filter.h"
  27 #include "memory.h"
  28 #include "prefix.h"
  29 #include "log.h"
  30 #include "privs.h"
  31 #include "sigevent.h"
  32
  33 #include "zebra/rib.h"
  34 #include "zebra/zserv.h"
  35 #include "zebra/debug.h"
  36 #include "zebra/router-id.h"
  37 #include "zebra/interface.h"
  38
  39 /* Zebra instance */
  40 struct zebra_t zebrad =
  41 {
  42   .rtm_table_default = 0,
  43 };
  44
  45 /* process id. */
  46 pid_t pid;
  47
  48 /* zebra_rib's workqueue hold time. Private export for use by test code only */
  49 extern int rib_process_hold_time;
  50
  51 /* Pacify zclient.o in libzebra, which expects this variable. */
  52 struct thread_master *master;
  53
  54 /* Command line options. */
  55 struct option longopts[] =
  56 {
  57   { "batch",       no_argument,       NULL, 'b'},
  58   { "daemon",      no_argument,       NULL, 'd'},
  59   { "config_file", required_argument, NULL, 'f'},
  60   { "help",        no_argument,       NULL, 'h'},
  61   { "vty_addr",    required_argument, NULL, 'A'},
  62   { "vty_port",    required_argument, NULL, 'P'},
  63   { "version",     no_argument,       NULL, 'v'},
  64   { "rib_hold",    required_argument, NULL, 'r'},
  65   { 0 }
  66 };
  67
  68 zebra_capabilities_t _caps_p [] =
  69 {
  70   ZCAP_NET_ADMIN,
  71   ZCAP_SYS_ADMIN,
  72   ZCAP_NET_RAW,
  73 };
  74
  75 /* Default configuration file path. */
  76 char config_default[] = SYSCONFDIR DEFAULT_CONFIG_FILE;
  77
  78 /* Process ID saved for use by init system */
  79 const char *pid_file = PATH_ZEBRA_PID;
  80
  81 /* Help information display. */
  82 static void
  83 usage (char *progname, int status)
  84 {
  85   if (status != 0)
  86     fprintf (stderr, "Try `%s --help' for more information.\n", progname);
  87   else
  88     {
  89       printf ("Usage : %s [OPTION...]\n\n"\
  90               "Daemon which manages kernel routing table management and "\
  91               "redistribution between different routing protocols.\n\n"\
  92               "-b, --batch        Runs in batch mode\n"\
  93               "-d, --daemon       Runs in daemon mode\n"\
  94               "-f, --config_file  Set configuration file name\n"\
  95               "-A, --vty_addr     Set vty's bind address\n"\
  96               "-P, --vty_port     Set vty's port number\n"\
  97               "-r, --rib_hold     Set rib-queue hold time\n"\
  98               "-v, --version      Print program version\n"\
  99               "-h, --help         Display this help and exit\n"\
 100               "\n"\
 101               "Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
 102     }
 103
 104   exit (status);
 105 }
 106 \f
 107 static unsigned int test_ifindex = 0;
 108
 109 /* testrib commands */
 110 DEFUN (test_interface_state,
 111        test_interface_state_cmd,
 112        "state (up|down)",
 113        "configure interface\n"
 114        "up\n"
 115        "down\n")
 116 {
 117   struct interface *ifp;
 118   if (argc < 1)
 119     return CMD_WARNING;
 120
 121   ifp = vty->index;
 122   if (ifp->ifindex == IFINDEX_INTERNAL)
 123     {
 124       ifp->ifindex = ++test_ifindex;
 125       ifp->mtu = 1500;
 126       ifp->flags = IFF_BROADCAST|IFF_MULTICAST;
 127     }
 128
 129   switch (argv[0][0])
 130     {
 131       case 'u':
 132         SET_FLAG (ifp->flags, IFF_UP);
 133         if_add_update (ifp);
 134         printf ("up\n");
 135         break;
 136       case 'd':
 137         UNSET_FLAG (ifp->flags, IFF_UP);
 138         if_delete_update (ifp);
 139         printf ("down\n");
 140         break;
 141       default:
 142         return CMD_WARNING;
 143     }
 144   return CMD_SUCCESS;
 145 }
 146
 147 static void
 148 test_cmd_init (void)
 149 {
 150   install_element (INTERFACE_NODE, &test_interface_state_cmd);
 151 }
 152 \f
 153 /* SIGHUP handler. */
 154 static void
 155 sighup (void)
 156 {
 157   zlog_info ("SIGHUP received");
 158
 159   /* Reload of config file. */
 160   ;
 161 }
 162
 163 /* SIGINT handler. */
 164 static void
 165 sigint (void)
 166 {
 167   zlog_notice ("Terminating on signal");
 168
 169   exit (0);
 170 }
 171
 172 /* SIGUSR1 handler. */
 173 static void
 174 sigusr1 (void)
 175 {
 176   zlog_rotate (NULL);
 177 }
 178
 179 struct quagga_signal_t zebra_signals[] =
 180 {
 181   {
 182     .signal = SIGHUP,
 183     .handler = &sighup,
 184   },
 185   {
 186     .signal = SIGUSR1,
 187     .handler = &sigusr1,
 188   },
 189   {
 190     .signal = SIGINT,
 191     .handler = &sigint,
 192   },
 193   {
 194     .signal = SIGTERM,
 195     .handler = &sigint,
 196   },
 197 };
 198 \f
 199 /* Main startup routine. */
 200 int
 201 main (int argc, char **argv)
 202 {
 203   char *p;
 204   char *vty_addr = NULL;
 205   int vty_port = 0;
 206   int batch_mode = 0;
 207   int daemon_mode = 0;
 208   char *config_file = NULL;
 209   char *progname;
 210   struct thread thread;
 211
 212   /* Set umask before anything for security */
 213   umask (0027);
 214
 215   /* preserve my name */
 216   progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
 217
 218   zlog_default = openzlog (progname, ZLOG_ZEBRA,
 219                            LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
 220
 221   while (1)
 222     {
 223       int opt;
 224
 225       opt = getopt_long (argc, argv, "bdf:hA:P:r:v", longopts, 0);
 226
 227       if (opt == EOF)
 228         break;
 229
 230       switch (opt)
 231         {
 232         case 0:
 233           break;
 234         case 'b':
 235           batch_mode = 1;
 236         case 'd':
 237           daemon_mode = 1;
 238           break;
 239         case 'f':
 240           config_file = optarg;
 241           break;
 242         case 'A':
 243           vty_addr = optarg;
 244           break;
 245         case 'P':
 246           /* Deal with atoi() returning 0 on failure, and zebra not
 247              listening on zebra port... */
 248           if (strcmp(optarg, "0") == 0)
 249             {
 250               vty_port = 0;
 251               break;
 252             }
 253           vty_port = atoi (optarg);
 254           break;
 255         case 'r':
 256           rib_process_hold_time = atoi(optarg);
 257           break;
 258         case 'v':
 259           print_version (progname);
 260           exit (0);
 261           break;
 262         case 'h':
 263           usage (progname, 0);
 264           break;
 265         default:
 266           usage (progname, 1);
 267           break;
 268         }
 269     }
 270
 271   /* port and conf file mandatory */
 272   if (!vty_port || !config_file)
 273     usage (progname, 1);
 274
 275   /* Make master thread emulator. */
 276   zebrad.master = thread_master_create ();
 277
 278   /* Vty related initialize. */
 279   signal_init (zebrad.master, Q_SIGC(zebra_signals), zebra_signals);
 280   cmd_init (1);
 281   vty_init (zebrad.master);
 282   memory_init ();
 283   if_init();
 284   zebra_debug_init ();
 285   zebra_if_init ();
 286   test_cmd_init ();
 287
 288   /* Zebra related initialize. */
 289   rib_init ();
 290   access_list_init ();
 291
 292   /* Make kernel routing socket. */
 293   kernel_init ();
 294   route_read ();
 295   zebra_vty_init();
 296
 297   /* Sort VTY commands. */
 298   sort_node ();
 299
 300   /* Configuration file read*/
 301   vty_read_config (config_file, config_default);
 302
 303   /* Clean up rib. */
 304   rib_weed_tables ();
 305
 306   /* Exit when zebra is working in batch mode. */
 307   if (batch_mode)
 308     exit (0);
 309
 310   /* Daemonize. */
 311   if (daemon_mode && daemon (0, 0) < 0)
 312     {
 313       perror("daemon start failed");
 314       exit (1);
 315     }
 316
 317   /* Needed for BSD routing socket. */
 318   pid = getpid ();
 319
 320   /* Make vty server socket. */
 321   vty_serv_sock (vty_addr, vty_port, "/tmp/test_zebra");
 322
 323   /* Print banner. */
 324   zlog_notice ("Zebra %s starting: vty@%d", QUAGGA_VERSION, vty_port);
 325
 326   while (thread_fetch (zebrad.master, &thread))
 327     thread_call (&thread);
 328
 329   /* Not reached... */
 330   return 0;
 331 }