path: root/bgpd/bgp_main.c

/* Main routine of bgpd.
   Copyright (C) 1996, 97, 98, 1999 Kunihiro Ishiguro

This file is part of GNU Zebra.

GNU Zebra is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

GNU Zebra is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Zebra; see the file COPYING.  If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include <zebra.h>

#include "vector.h"
#include "vty.h"
#include "command.h"
#include "getopt.h"
#include "thread.h"
#include <lib/version.h>
#include "memory.h"
#include "prefix.h"
#include "log.h"
#include "privs.h"
#include "sigevent.h"
#include "zclient.h"
#include "routemap.h"
#include "filter.h"
#include "plist.h"
#include "qpnexus.h"
#include "qlib_init.h"
#include "thread.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_mplsvpn.h"
#include "bgpd/bgp_aspath.h"
#include "bgpd/bgp_dump.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_nexthop.h"
#include "bgpd/bgp_regex.h"
#include "bgpd/bgp_clist.h"
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_filter.h"
#include "bgpd/bgp_network.h"
#include "bgpd/bgp_engine.h"
#include "bgpd/bgp_zebra.h"

/* bgpd options, we use GNU getopt library. */
static const struct option longopts[] =
{
  { "daemon",      no_argument,       NULL, 'd'},
  { "config_file", required_argument, NULL, 'f'},
  { "pid_file",    required_argument, NULL, 'i'},
  { "bgp_port",    required_argument, NULL, 'p'},
  { "listenon",    required_argument, NULL, 'l'},
  { "vty_addr",    required_argument, NULL, 'A'},
  { "vty_port",    required_argument, NULL, 'P'},
  { "retain",      no_argument,       NULL, 'r'},
  { "no_kernel",   no_argument,       NULL, 'n'},
  { "user",        required_argument, NULL, 'u'},
  { "group",       required_argument, NULL, 'g'},
  { "version",     no_argument,       NULL, 'v'},
  { "dryrun",      no_argument,       NULL, 'C'},
  { "help",        no_argument,       NULL, 'h'},
  { "threaded",    no_argument,       NULL, 't'},
  { 0 }
};

/* signal definitions */
void sighup (void);
void sigint (void);
void sigusr1 (void);
void sigusr2 (void);

/* prototypes */
static void bgp_exit (int);
static void init_second_stage(int pthreads);
static void bgp_in_thread_init(void);
static void routing_start(void) ;
static int routing_foreground(void);
static int routing_background(void);
static void sighup_action(mqueue_block mqb, mqb_flag_t flag);
static void sighup_enqueue(void);
static void sigterm_action(mqueue_block mqb, mqb_flag_t flag);
static void sigterm_enqueue(void);

static struct quagga_signal_t bgp_signals[] =
{
  {
    .signal = SIGHUP,
    .handler = &sighup,
  },
  {
    .signal = SIGUSR1,
    .handler = &sigusr1,
  },
  {
    .signal = SIGUSR2,
    .handler = &sigusr2,
  },
  {
    .signal = SIGINT,
    .handler = &sigint,
  },
  {
    .signal = SIGTERM,
    .handler = &sigint,
  },
};

/* Configuration file and directory. */
char config_default[] = SYSCONFDIR BGP_DEFAULT_CONFIG;

/* Route retain mode flag. */
static int retain_mode = 0;

/* Master of threads. */
struct thread_master *master;

/* Manually specified configuration file name.  */
char *config_file = NULL;

/* Have we done the second stage initialization? */
static int done_2nd_state_init = 0;
/* Process ID saved for use by init system */
static const char *pid_file = PATH_BGPD_PID;

/* VTY port number and address.  */
int vty_port = BGP_VTY_PORT;
char *vty_addr = NULL;

/* privileges */
static zebra_capabilities_t _caps_p [] =
{
    ZCAP_BIND,
    ZCAP_NET_RAW,
};

struct zebra_privs_t bgpd_privs =
{
#if defined(QUAGGA_USER) && defined(QUAGGA_GROUP)
  .user = QUAGGA_USER,
  .group = QUAGGA_GROUP,
#endif
#ifdef VTY_GROUP
  .vty_group = VTY_GROUP,
#endif
  .caps_p = _caps_p,
  .cap_num_p = sizeof(_caps_p)/sizeof(_caps_p[0]),
  .cap_num_i = 0,
};

/* Help information display. */
static void
usage (char *progname, int status)
{
  if (status != 0)
    fprintf (stderr, "Try `%s --help' for more information.\n", progname);
  else
    {
      printf ("Usage : %s [OPTION...]\n\n\
Daemon which manages kernel routing table management and \
redistribution between different routing protocols.\n\n\
-d, --daemon       Runs in daemon mode\n\
-f, --config_file  Set configuration file name\n\
-i, --pid_file     Set process identifier file name\n\
-p, --bgp_port     Set bgp protocol's port number\n\
-l, --listenon     Listen on specified address (implies -n)\n\
-A, --vty_addr     Set vty's bind address\n\
-P, --vty_port     Set vty's port number\n\
-r, --retain       When program terminates, retain added route by bgpd.\n\
-n, --no_kernel    Do not install route to kernel.\n\
-u, --user         User to run as\n\
-g, --group        Group to run as\n\
-v, --version      Print program version\n\
-C, --dryrun       Check configuration for validity and exit\n\
-h, --help         Display this help and exit\n\
-t, --threaded     Use pthreads\n\
\n\
Report bugs to %s\n", progname, ZEBRA_BUG_ADDRESS);
    }

  exit (status);
}

/* SIGHUP handler. */
void
sighup (void)
{
  zlog (NULL, LOG_INFO, "SIGHUP received");

  /* tell the routing engine */
  sighup_enqueue();

  zlog_info ("bgpd restarting!");

  /* Reload config file. */
  vty_reset();
  vty_read_config (config_file, config_default);

  /* Create VTY's socket */
  vty_serv_sock (vty_addr, vty_port, BGP_VTYSH_PATH);

  /* Try to return to normal operation. */
}

/* SIGINT handler. */
void
sigint (void)
{
#ifdef QDEBUG
  vty_goodbye();
#endif
  zlog_notice ("Terminating on signal");

  /* tell the routing engine to send notifies to peers and wait
   * for all sessions to be disabled */
  sigterm_enqueue();
}

/* SIGUSR1 handler. */
void
sigusr1 (void)
{
  zlog_rotate (NULL);
}

/* SIGUSR2 handler. */
void
sigusr2 (void)
{
  /* Used to signal message queues */
  if (qpthreads_enabled)
    return;
  else
    exit(1);
}


/*
  Try to free up allocations we know about so that diagnostic tools such as
  valgrind are able to better illuminate leaks.

  Zebra route removal and protocol teardown are not meant to be done here.
  For example, "retain_mode" may be set.
*/
static void
bgp_exit (int status)
{
  struct bgp *bgp;
  struct listnode *node, *nnode;
  int *socket;
  struct interface *ifp;
  extern struct zclient *zclient;
  extern struct zclient *zlookup;

  /* it only makes sense for this to be called on a clean exit */
  assert (status == 0);

  /* reverse bgp_master_init */
  for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
    bgp_delete (bgp);
  list_free (bm->bgp);

  /* reverse bgp_master_init */
  for (ALL_LIST_ELEMENTS_RO(bm->listen_sockets, node, socket))
    {
      if (close ((int)(long)socket) == -1)
        zlog_err ("close (%d): %s", (int)(long)socket, safe_strerror (errno));
    }
  list_delete (bm->listen_sockets);

  /* reverse bgp_zebra_init/if_init */
  if (retain_mode)
    if_add_hook (IF_DELETE_HOOK, NULL);
  for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
    if_delete (ifp);
  list_free (iflist);

  /* reverse bgp_attr_init */
  bgp_attr_finish ();

  /* reverse bgp_dump_init */
  bgp_dump_finish ();

  /* reverse bgp_route_init */
  bgp_route_finish ();

  /* reverse bgp_route_map_init/route_map_init */
  route_map_finish ();

  /* reverse bgp_scan_init */
  bgp_scan_finish ();

  /* reverse access_list_init */
  access_list_add_hook (NULL);
  access_list_delete_hook (NULL);
  access_list_reset ();

  /* reverse bgp_filter_init */
  as_list_add_hook (NULL);
  as_list_delete_hook (NULL);
  bgp_filter_reset ();

  /* reverse prefix_list_init */
  prefix_list_add_hook (NULL);
  prefix_list_delete_hook (NULL);
  prefix_list_reset ();

  /* reverse community_list_init */
  community_list_terminate (bgp_clist);

  cmd_terminate ();
  vty_terminate ();
  if (zclient)
    zclient_free (zclient);
  if (zlookup)
    zclient_free (zlookup);

  /* reverse bgp_master_init */
  if (master)
    thread_master_free (master);

  if (zlog_default)
    closezlog (zlog_default);

  if (CONF_BGP_DEBUG (normal, NORMAL))
    log_memstats_stderr ("bgpd");

  if (qpthreads_enabled)
  {
    routing_nexus = qpn_free(routing_nexus);
    bgp_nexus = qpn_free(bgp_nexus);
  }
  cli_nexus = qpn_free(cli_nexus);

  qexit (status);
}

/* Threaded command.  If present must be the first command in the
 * configuration file.  If not the first command it will log and abort. */
DEFUN_HID_CALL (threaded,
       threaded_cmd,
       "threaded",
       "Use pthreads\n")
{
  if (!qpthreads_enabled)
    init_second_stage(1);

  return CMD_SUCCESS;
}

/* If neither the command line nor the first command enabled pthreads
 * then disable pthreads.  This is a call back after processing the
 * first command in the configuration file
 */
static void after_first_cmd()
{
  if (!qpthreads_enabled)
    init_second_stage(0);
}

/* Enable or disables pthreads.  Create the nexus(es). Perform
 * any post nexus creation initialization. The nexus(es) need
 * to be created as soon as we know the pthread state so that
 * the message queues are available for the configuration data.
 */
static void
init_second_stage(int pthreads)
{
  if (done_2nd_state_init)
    return;

  done_2nd_state_init = 1;

  qlib_init_second_stage(pthreads);
  bgp_peer_index_mutex_init();

  /* Make nexus for main thread, always needed */
  cli_nexus = qpn_init_new(cli_nexus, 1); /* main thread */

  /* if using pthreads create additional nexus */
  if (qpthreads_enabled)
    {
      bgp_nexus     = qpn_init_new(bgp_nexus, 0);
      routing_nexus = qpn_init_new(routing_nexus, 0);
    }
  else
    {
      /* we all share the single nexus and single thread */
      bgp_nexus     = cli_nexus;
      routing_nexus = cli_nexus;
    }

  /* Tell thread stuff to use this qtimer pile                          */
  thread_set_qtimer_pile(routing_nexus->pile) ;

  /* Nexus hooks.
   * Beware if !qpthreads_enabled then there is only 1 nexus object
   * with all nexus pointers being aliases for it.
   */
  qpn_add_hook_function(&routing_nexus->in_thread_init, routing_start) ;
  qpn_add_hook_function(&bgp_nexus->in_thread_init,  bgp_in_thread_init) ;

  qpn_add_hook_function(&bgp_nexus->in_thread_final, bgp_close_listeners) ;

  qpn_add_hook_function(&routing_nexus->foreground, routing_foreground) ;
  qpn_add_hook_function(&bgp_nexus->foreground, bgp_connection_queue_process) ;

  qpn_add_hook_function(&routing_nexus->background, routing_background) ;

  confirm(qpn_hooks_max >= 2) ;

  /* vty and zclient can use either nexus or threads.
   * For bgp client we always want nexus, regardless of pthreads.
   */
  vty_init_r(cli_nexus, routing_nexus);
  zclient_init_r(routing_nexus);

  /* Now we have our nexus we can init BGP. */
  /* BGP related initialization.  */
  bgp_init ();

  /* Sort CLI commands. */
  sort_node ();
}

/* Main routine of bgpd. Treatment of argument and start bgp finite
   state machine is handled at here. */
int
main (int argc, char **argv)
{
  char *p;
  int opt;
  int daemon_mode = 0;
  int dryrun = 0;
  char *progname;
  int tmp_port;
  int threaded = 0;

  /* Set umask before anything for security */
  umask (0027);

#ifdef QDEBUG
  fprintf(stderr, "%s\n", debug_banner);
#endif

  qlib_init_first_stage();

  /* Preserve name of myself. */
  progname = ((p = strrchr (argv[0], '/')) ? ++p : argv[0]);

  zlog_default = openzlog (progname, ZLOG_BGP,
			   LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);

  /* BGP master init. */
  bgp_master_init ();

  /* Command line argument treatment. */
  while (1)
    {
      opt = getopt_long (argc, argv, "df:i:hp:l:A:P:rnu:g:vCt", longopts, 0);

      if (opt == EOF)
	break;

      switch (opt)
	{
	case 0:
	  break;
	case 'd':
	  daemon_mode = 1;
	  break;
	case 'f':
	  config_file = optarg;
	  break;
        case 'i':
          pid_file = optarg;
          break;
	case 'p':
	  tmp_port = atoi (optarg);
	  if (tmp_port <= 0 || tmp_port > 0xffff)
	    bm->port = BGP_PORT_DEFAULT;
	  else
	    bm->port = tmp_port;
	  break;
	case 'A':
	  vty_addr = optarg;
	  break;
	case 'P':
          /* Deal with atoi() returning 0 on failure, and bgpd not
             listening on bgp port... */
          if (strcmp(optarg, "0") == 0)
            {
              vty_port = 0;
              break;
            }
          vty_port = atoi (optarg);
	  if (vty_port <= 0 || vty_port > 0xffff)
	    vty_port = BGP_VTY_PORT;
	  break;
	case 'r':
	  retain_mode = 1;
	  break;
	case 'l':
	  bm->address = optarg;
	  /* listenon implies -n */
	case 'n':
	  bgp_option_set (BGP_OPT_NO_FIB);
	  break;
	case 'u':
	  bgpd_privs.user = optarg;
	  break;
	case 'g':
	  bgpd_privs.group = optarg;
	  break;
	case 'v':
	  print_version (progname);
	  exit (0);
	  break;
	case 'C':
	  dryrun = 1;
	  break;
	case 'h':
	  usage (progname, 0);
	  break;
	case 't':
	  threaded = 1;
	  break;
	default:
	  usage (progname, 1);
	  break;
	}
    }

  /* Make thread master. */
  master = bm->master;

  /* Initializations. */
  srand (time (NULL));
  signal_init (master, Q_SIGC(bgp_signals), bgp_signals);
  zprivs_init (&bgpd_privs);
  cmd_init (1);
  install_element (CONFIG_NODE, &threaded_cmd);
  vty_init (master);
  memory_init ();

  if (threaded)
    init_second_stage(1);

  /* Parse config file. */
  vty_read_config_first_cmd_special (config_file, config_default, after_first_cmd);

  /* if not threaded and empty config file then still need to
   * do second stage initialization
   */
  if (!done_2nd_state_init)
    init_second_stage(0);

  /* Start execution only if not in dry-run mode */
  if (dryrun)
    return(0);

  /* only the calling thread survives in the child after a fork
   * so ensure we haven't created any threads yet
   */
  assert(!qpthreads_thread_created);

  /* Turn into daemon if daemon_mode is set. */
  if (daemon_mode && daemon (0, 0) < 0)
    {
      zlog_err("BGPd daemon failed: %s", safe_strerror(errno));
      return (1);
    }

  /* Process ID file creation. */
  pid_output (pid_file);

  /* Make bgp vty socket. */
  vty_serv_sock (vty_addr, vty_port, BGP_VTYSH_PATH);

  /* Print banner. */
#ifdef QDEBUG
  zlog_notice("%s", debug_banner);
#endif
  zlog_notice ("BGPd %s%s starting: vty@%d, bgp@%s:%d",
               QUAGGA_VERSION,
               (qpthreads_enabled ? " pthreaded" : ""),
	       vty_port,
	       (bm->address ? bm->address : "<all>"),
	       (int)bm->port);

  /* Launch finite state machine(s) */
  if (qpthreads_enabled)
    {
      void * thread_result = NULL;

      qpn_exec(routing_nexus);
      qpn_exec(bgp_nexus);
      qpn_exec(cli_nexus);      /* must be last to start - on main thread */

      /* terminating, wait for all threads to finish */
      thread_result = qpt_thread_join(routing_nexus->thread_id);
      thread_result = qpt_thread_join(bgp_nexus->thread_id);
    }
  else
    {
      qpn_exec(cli_nexus);      /* only nexus - on main thread */
    }

  bgp_exit(0);
}

/* bgp_nexus in-thread initialization                   */
static void
bgp_in_thread_init(void)
{
  bgp_open_listeners(bm->port, bm->address);
}

/* routing_nexus in-thread initialization -- for gdb !  */

static int routing_started = 0 ;

static void
routing_start(void)
{
  routing_started = 1 ;
}

/* legacy threads in routing engine                     */
static int
routing_foreground(void)
{
  return thread_dispatch(master) ;
}

/* background threads in routing engine */
static int
routing_background(void)
{
  return thread_dispatch_background(master) ;
}

/* SIGINT/TERM SIGHUP need to tell routing engine what to do */

static void
sighup_enqueue(void)
{
  mqueue_block mqb = mqb_init_new(NULL, sighup_action, NULL) ;

  mqueue_enqueue(routing_nexus->queue, mqb, 0) ;
}

/* dispatch a command from the message queue block */
static void
sighup_action(mqueue_block mqb, mqb_flag_t flag)
{
  if (flag == mqb_action)
    {
      bgp_terminate (0, 0); /* send notifies */
      bgp_reset ();
    }

  mqb_free(mqb);
}

static void
sigterm_enqueue(void)
{
  mqueue_block mqb = mqb_init_new(NULL, sigterm_action, NULL) ;

  mqueue_enqueue(routing_nexus->queue, mqb, 0) ;
}

/* dispatch a command from the message queue block */
static void
sigterm_action(mqueue_block mqb, mqb_flag_t flag)
{
  if (flag == mqb_action)
    {
      /* send notify to all peers, wait for all sessions to be disables
       * then terminate all pthreads */
      bgp_terminate(1, retain_mode);
    }

  mqb_free(mqb);
}