zebra/main.c

   1 /* zebra daemon main routine.
   2  * Copyright (C) 1997, 98 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include <lib/version.h>
  25 #include "getopt.h"
  26 #include "command.h"
  27 #include "thread.h"
  28 #include "filter.h"
  29 #include "memory.h"
  30 #include "prefix.h"
  31 #include "log.h"
  32 #include "plist.h"
  33 #include "privs.h"
  34 #include "sigevent.h"
  35 #include "vrf.h"
  36
  37 #include "zebra/rib.h"
  38 #include "zebra/zserv.h"
  39 #include "zebra/debug.h"
  40 #include "zebra/router-id.h"
  41 #include "zebra/irdp.h"
  42 #include "zebra/rtadv.h"
  43 #include "zebra/zebra_fpm.h"
  44
  45 /* Zebra instance */
  46 struct zebra_t zebrad =
  47 {
  48   .rtm_table_default = 0,
  49 };
  50
  51 /* process id. */
  52 pid_t pid;
  53
  54 /* Pacify zclient.o in libzebra, which expects this variable. */
  55 struct thread_master *master;
  56
  57 /* Route retain mode flag. */
  58 int retain_mode = 0;
  59
  60 /* Don't delete kernel route. */
  61 int keep_kernel_mode = 0;
  62
  63 #ifdef HAVE_NETLINK
  64 /* Receive buffer size for netlink socket */
  65 u_int32_t nl_rcvbufsize = 0;
  66 #endif /* HAVE_NETLINK */
  67
  68 /* Command line options. */
  69 struct option longopts[] =
  70 {
  71   { "batch",       no_argument,       NULL, 'b'},
  72   { "daemon",      no_argument,       NULL, 'd'},
  73   { "keep_kernel", no_argument,       NULL, 'k'},
  74   { "fpm_format",  required_argument, NULL, 'F'},
  75   { "config_file", required_argument, NULL, 'f'},
  76   { "pid_file",    required_argument, NULL, 'i'},
  77   { "socket",      required_argument, NULL, 'z'},
  78   { "help",        no_argument,       NULL, 'h'},
  79   { "vty_addr",    required_argument, NULL, 'A'},
  80   { "vty_port",    required_argument, NULL, 'P'},
  81   { "retain",      no_argument,       NULL, 'r'},
  82   { "dryrun",      no_argument,       NULL, 'C'},
  83 #ifdef HAVE_NETLINK
  84   { "nl-bufsize",  required_argument, NULL, 's'},
  85 #endif /* HAVE_NETLINK */
  86   { "user",        required_argument, NULL, 'u'},
  87   { "group",       required_argument, NULL, 'g'},
  88   { "version",     no_argument,       NULL, 'v'},
  89   { 0 }
  90 };
  91
  92 zebra_capabilities_t _caps_p [] =
  93 {
  94   ZCAP_NET_ADMIN,
  95   ZCAP_SYS_ADMIN,
  96   ZCAP_NET_RAW,
  97 };
  98
  99 /* zebra privileges to run with */
 100 struct zebra_privs_t zserv_privs =
 101 {
 102 #if defined(QUAGGA_USER) && defined(QUAGGA_GROUP)
 103   .user = QUAGGA_USER,
 104   .group = QUAGGA_GROUP,
 105 #endif
 106 #ifdef VTY_GROUP
 107   .vty_group = VTY_GROUP,
 108 #endif
 109   .caps_p = _caps_p,
 110   .cap_num_p = array_size(_caps_p),
 111   .cap_num_i = 0
 112 };
 113
 114 /* Default configuration file path. */
 115 char config_default[] = SYSCONFDIR DEFAULT_CONFIG_FILE;
 116
 117 /* Process ID saved for use by init system */
 118 const char *pid_file = PATH_ZEBRA_PID;
 119
 120 /* Help information display. */
 121 static void
 122 usage (char *progname, int status)
 123 {
 124   if (status != 0)
 125     fprintf (stderr, "Try `%s --help' for more information.\n", progname);
 126   else
 127     {
 128       printf ("Usage : %s [OPTION...]\n\n"\
 129               "Daemon which manages kernel routing table management and "\
 130               "redistribution between different routing protocols.\n\n"\
 131               "-b, --batch        Runs in batch mode\n"\
 132               "-d, --daemon       Runs in daemon mode\n"\
 133               "-f, --config_file  Set configuration file name\n"\
 134               "-F, --fpm_format   Set fpm format to 'netlink' or 'protobuf'\n"\
 135               "-i, --pid_file     Set process identifier file name\n"\
 136               "-z, --socket       Set path of zebra socket\n"\
 137               "-k, --keep_kernel  Don't delete old routes which installed by "\
 138                                   "zebra.\n"\
 139               "-C, --dryrun       Check configuration for validity and exit\n"\
 140               "-A, --vty_addr     Set vty's bind address\n"\
 141               "-P, --vty_port     Set vty's port number\n"\
 142               "-r, --retain       When program terminates, retain added route "\
 143                                   "by zebra.\n"\
 144               "-u, --user         User to run as\n"\
 145               "-g, --group        Group to run as\n", progname);
 146 #ifdef HAVE_NETLINK
 147       printf ("-s, --nl-bufsize   Set netlink receive buffer size\n");
 148 #endif /* HAVE_NETLINK */
 149       printf ("-v, --version      Print program version\n"\
 150               "-h, --help         Display this help and exit\n"\
 151               "\n"\
 152               "Report bugs to %s\n", ZEBRA_BUG_ADDRESS);
 153     }
 154
 155   exit (status);
 156 }
 157
 158 /* SIGHUP handler. */
 159 static void
 160 sighup (void)
 161 {
 162   zlog_info ("SIGHUP received");
 163
 164   /* Reload of config file. */
 165   ;
 166 }
 167
 168 /* SIGINT handler. */
 169 static void
 170 sigint (void)
 171 {
 172   zlog_notice ("Terminating on signal");
 173
 174   if (!retain_mode)
 175     rib_close ();
 176 #ifdef HAVE_IRDP
 177   irdp_finish();
 178 #endif
 179
 180   exit (0);
 181 }
 182
 183 /* SIGUSR1 handler. */
 184 static void
 185 sigusr1 (void)
 186 {
 187   zlog_rotate (NULL);
 188 }
 189
 190 struct quagga_signal_t zebra_signals[] =
 191 {
 192   {
 193     .signal = SIGHUP,
 194     .handler = &sighup,
 195   },
 196   {
 197     .signal = SIGUSR1,
 198     .handler = &sigusr1,
 199   },
 200   {
 201     .signal = SIGINT,
 202     .handler = &sigint,
 203   },
 204   {
 205     .signal = SIGTERM,
 206     .handler = &sigint,
 207   },
 208 };
 209
 210 /* Callback upon creating a new VRF. */
 211 static int
 212 zebra_vrf_new (vrf_id_t vrf_id, void **info)
 213 {
 214   struct zebra_vrf *zvrf = *info;
 215
 216   if (! zvrf)
 217     {
 218       zvrf = zebra_vrf_alloc (vrf_id);
 219       *info = (void *)zvrf;
 220       router_id_init (zvrf);
 221     }
 222
 223   return 0;
 224 }
 225
 226 /* Callback upon enabling a VRF. */
 227 static int
 228 zebra_vrf_enable (vrf_id_t vrf_id, void **info)
 229 {
 230   struct zebra_vrf *zvrf = (struct zebra_vrf *) (*info);
 231
 232   assert (zvrf);
 233
 234 #if defined (HAVE_RTADV)
 235   rtadv_init (zvrf);
 236 #endif
 237   kernel_init (zvrf);
 238   interface_list (zvrf);
 239   route_read (zvrf);
 240
 241   return 0;
 242 }
 243
 244 /* Callback upon disabling a VRF. */
 245 static int
 246 zebra_vrf_disable (vrf_id_t vrf_id, void **info)
 247 {
 248   struct zebra_vrf *zvrf = (struct zebra_vrf *) (*info);
 249   struct listnode *list_node;
 250   struct interface *ifp;
 251
 252   assert (zvrf);
 253
 254   rib_close_table (zvrf->table[AFI_IP][SAFI_UNICAST]);
 255   rib_close_table (zvrf->table[AFI_IP6][SAFI_UNICAST]);
 256
 257   for (ALL_LIST_ELEMENTS_RO (vrf_iflist (vrf_id), list_node, ifp))
 258     {
 259       int operative = if_is_operative (ifp);
 260       UNSET_FLAG (ifp->flags, IFF_UP);
 261       if (operative)
 262         if_down (ifp);
 263     }
 264
 265 #if defined (HAVE_RTADV)
 266   rtadv_terminate (zvrf);
 267 #endif
 268   kernel_terminate (zvrf);
 269
 270   list_delete_all_node (zvrf->rid_all_sorted_list);
 271   list_delete_all_node (zvrf->rid_lo_sorted_list);
 272
 273   return 0;
 274 }
 275
 276 /* Zebra VRF initialization. */
 277 static void
 278 zebra_vrf_init (void)
 279 {
 280   vrf_add_hook (VRF_NEW_HOOK, zebra_vrf_new);
 281   vrf_add_hook (VRF_ENABLE_HOOK, zebra_vrf_enable);
 282   vrf_add_hook (VRF_DISABLE_HOOK, zebra_vrf_disable);
 283   vrf_init ();
 284 }
 285
 286 /* Main startup routine. */
 287 int
 288 main (int argc, char **argv)
 289 {
 290   char *p;
 291   char *vty_addr = NULL;
 292   int vty_port = ZEBRA_VTY_PORT;
 293   int dryrun = 0;
 294   int batch_mode = 0;
 295   int daemon_mode = 0;
 296   char *config_file = NULL;
 297   char *progname;
 298   struct thread thread;
 299   char *zserv_path = NULL;
 300   char *fpm_format = NULL;
 301
 302   /* Set umask before anything for security */
 303   umask (0027);
 304
 305   /* preserve my name */
 306   progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);
 307
 308   zlog_default = openzlog (progname, ZLOG_ZEBRA,
 309                            LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
 310
 311   while (1)
 312     {
 313       int opt;
 314
 315 #ifdef HAVE_NETLINK
 316       opt = getopt_long (argc, argv, "bdkf:F:i:z:hA:P:ru:g:vs:C", longopts, 0);
 317 #else
 318       opt = getopt_long (argc, argv, "bdkf:F:i:z:hA:P:ru:g:vC", longopts, 0);
 319 #endif /* HAVE_NETLINK */
 320
 321       if (opt == EOF)
 322         break;
 323
 324       switch (opt)
 325         {
 326         case 0:
 327           break;
 328         case 'b':
 329           batch_mode = 1;
 330         case 'd':
 331           daemon_mode = 1;
 332           break;
 333         case 'k':
 334           keep_kernel_mode = 1;
 335           break;
 336         case 'C':
 337           dryrun = 1;
 338           break;
 339         case 'f':
 340           config_file = optarg;
 341           break;
 342         case 'F':
 343           fpm_format = optarg;
 344           break;
 345         case 'A':
 346           vty_addr = optarg;
 347           break;
 348         case 'i':
 349           pid_file = optarg;
 350           break;
 351         case 'z':
 352           zserv_path = optarg;
 353           break;
 354         case 'P':
 355           /* Deal with atoi() returning 0 on failure, and zebra not
 356              listening on zebra port... */
 357           if (strcmp(optarg, "0") == 0)
 358             {
 359               vty_port = 0;
 360               break;
 361             }
 362           vty_port = atoi (optarg);
 363           if (vty_port <= 0 || vty_port > 0xffff)
 364             vty_port = ZEBRA_VTY_PORT;
 365           break;
 366         case 'r':
 367           retain_mode = 1;
 368           break;
 369 #ifdef HAVE_NETLINK
 370         case 's':
 371           nl_rcvbufsize = atoi (optarg);
 372           break;
 373 #endif /* HAVE_NETLINK */
 374         case 'u':
 375           zserv_privs.user = optarg;
 376           break;
 377         case 'g':
 378           zserv_privs.group = optarg;
 379           break;
 380         case 'v':
 381           print_version (progname);
 382           exit (0);
 383           break;
 384         case 'h':
 385           usage (progname, 0);
 386           break;
 387         default:
 388           usage (progname, 1);
 389           break;
 390         }
 391     }
 392
 393   /* Make master thread emulator. */
 394   zebrad.master = thread_master_create ();
 395
 396   /* privs initialise */
 397   zprivs_init (&zserv_privs);
 398
 399   /* Vty related initialize. */
 400   signal_init (zebrad.master, array_size(zebra_signals), zebra_signals);
 401   cmd_init (1);
 402   vty_init (zebrad.master);
 403   memory_init ();
 404
 405   /* Zebra related initialize. */
 406   zebra_init ();
 407   rib_init ();
 408   zebra_if_init ();
 409   zebra_debug_init ();
 410   router_id_cmd_init ();
 411   zebra_vty_init ();
 412   access_list_init ();
 413   prefix_list_init ();
 414 #if defined (HAVE_RTADV)
 415   rtadv_cmd_init ();
 416 #endif
 417 #ifdef HAVE_IRDP
 418   irdp_init();
 419 #endif
 420
 421   /* For debug purpose. */
 422   /* SET_FLAG (zebra_debug_event, ZEBRA_DEBUG_EVENT); */
 423
 424   /* Initialize VRF module, and make kernel routing socket. */
 425   zebra_vrf_init ();
 426
 427 #ifdef HAVE_SNMP
 428   zebra_snmp_init ();
 429 #endif /* HAVE_SNMP */
 430
 431 #ifdef HAVE_FPM
 432   zfpm_init (zebrad.master, 1, 0, fpm_format);
 433 #else
 434   zfpm_init (zebrad.master, 0, 0, fpm_format);
 435 #endif
 436
 437   /* Process the configuration file. Among other configuration
 438   *  directives we can meet those installing static routes. Such
 439   *  requests will not be executed immediately, but queued in
 440   *  zebra->ribq structure until we enter the main execution loop.
 441   *  The notifications from kernel will show originating PID equal
 442   *  to that after daemon() completes (if ever called).
 443   */
 444   vty_read_config (config_file, config_default);
 445
 446   /* Don't start execution if we are in dry-run mode */
 447   if (dryrun)
 448     return(0);
 449
 450   /* Count up events for interfaces */
 451   if_startup_count_up ();
 452
 453   /* Clean up rib. */
 454   rib_weed_tables ();
 455
 456   /* Exit when zebra is working in batch mode. */
 457   if (batch_mode)
 458     exit (0);
 459
 460   /* Daemonize. */
 461   if (daemon_mode && daemon (0, 0) < 0)
 462     {
 463       zlog_err("Zebra daemon failed: %s", strerror(errno));
 464       exit (1);
 465     }
 466
 467   /* Output pid of zebra. */
 468   pid_output (pid_file);
 469
 470   /* After we have successfully acquired the pidfile, we can be sure
 471   *  about being the only copy of zebra process, which is submitting
 472   *  changes to the FIB.
 473   *  Clean up zebra-originated routes. The requests will be sent to OS
 474   *  immediately, so originating PID in notifications from kernel
 475   *  will be equal to the current getpid(). To know about such routes,
 476   * we have to have route_read() called before.
 477   */
 478   if (! keep_kernel_mode)
 479     rib_sweep_route ();
 480
 481   /* Needed for BSD routing socket. */
 482   pid = getpid ();
 483
 484   /* This must be done only after locking pidfile (bug #403). */
 485   zebra_zserv_socket_init (zserv_path);
 486
 487   /* Make vty server socket. */
 488   vty_serv_sock (vty_addr, vty_port, ZEBRA_VTYSH_PATH);
 489
 490   /* Print banner. */
 491   zlog_notice ("Zebra %s starting: vty@%d", QUAGGA_VERSION, vty_port);
 492
 493   while (thread_fetch (zebrad.master, &thread))
 494     thread_call (&thread);
 495
 496   /* Not reached... */
 497   return 0;
 498 }