bgpd/bgp_main.c

   1 /* Main routine of bgpd.
   2  * Copyright (C) 1996, 97, 98, 1999 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 along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include <pthread.h>
  24 #include "vector.h"
  25 #include "command.h"
  26 #include "getopt.h"
  27 #include "thread.h"
  28 #include <lib/version.h>
  29 #include "memory.h"
  30 #include "memory_vty.h"
  31 #include "prefix.h"
  32 #include "log.h"
  33 #include "privs.h"
  34 #include "sigevent.h"
  35 #include "zclient.h"
  36 #include "routemap.h"
  37 #include "filter.h"
  38 #include "plist.h"
  39 #include "stream.h"
  40 #include "queue.h"
  41 #include "vrf.h"
  42 #include "bfd.h"
  43 #include "libfrr.h"
  44
  45 #include "bgpd/bgpd.h"
  46 #include "bgpd/bgp_attr.h"
  47 #include "bgpd/bgp_route.h"
  48 #include "bgpd/bgp_mplsvpn.h"
  49 #include "bgpd/bgp_aspath.h"
  50 #include "bgpd/bgp_dump.h"
  51 #include "bgpd/bgp_route.h"
  52 #include "bgpd/bgp_nexthop.h"
  53 #include "bgpd/bgp_regex.h"
  54 #include "bgpd/bgp_clist.h"
  55 #include "bgpd/bgp_debug.h"
  56 #include "bgpd/bgp_filter.h"
  57 #include "bgpd/bgp_zebra.h"
  58 #include "bgpd/bgp_packet.h"
  59 #include "bgpd/bgp_keepalives.h"
  60
  61 #ifdef ENABLE_BGP_VNC
  62 #include "bgpd/rfapi/rfapi_backend.h"
  63 #endif
  64
  65 /* bgpd options, we use GNU getopt library. */
  66 static const struct option longopts[] = {
  67         {"bgp_port", required_argument, NULL, 'p'},
  68         {"listenon", required_argument, NULL, 'l'},
  69         {"retain", no_argument, NULL, 'r'},
  70         {"no_kernel", no_argument, NULL, 'n'},
  71         {"skip_runas", no_argument, NULL, 'S'},
  72         {"ecmp", required_argument, NULL, 'e'},
  73         {0}};
  74
  75 /* signal definitions */
  76 void sighup(void);
  77 void sigint(void);
  78 void sigusr1(void);
  79
  80 static void bgp_exit(int);
  81 static void bgp_vrf_terminate(void);
  82
  83 static struct quagga_signal_t bgp_signals[] = {
  84         {
  85                 .signal = SIGHUP,
  86                 .handler = &sighup,
  87         },
  88         {
  89                 .signal = SIGUSR1,
  90                 .handler = &sigusr1,
  91         },
  92         {
  93                 .signal = SIGINT,
  94                 .handler = &sigint,
  95         },
  96         {
  97                 .signal = SIGTERM,
  98                 .handler = &sigint,
  99         },
 100 };
 101
 102 /* Route retain mode flag. */
 103 static int retain_mode = 0;
 104
 105 /* privileges */
 106 static zebra_capabilities_t _caps_p[] = {
 107         ZCAP_BIND, ZCAP_NET_RAW, ZCAP_NET_ADMIN,
 108 };
 109
 110 struct zebra_privs_t bgpd_privs = {
 111 #if defined(FRR_USER) && defined(FRR_GROUP)
 112         .user = FRR_USER,
 113         .group = FRR_GROUP,
 114 #endif
 115 #ifdef VTY_GROUP
 116         .vty_group = VTY_GROUP,
 117 #endif
 118         .caps_p = _caps_p,
 119         .cap_num_p = array_size(_caps_p),
 120         .cap_num_i = 0,
 121 };
 122
 123 static struct frr_daemon_info bgpd_di;
 124
 125 /* SIGHUP handler. */
 126 void sighup(void)
 127 {
 128         zlog_info("SIGHUP received");
 129
 130         /* Terminate all thread. */
 131         bgp_terminate();
 132         bgp_reset();
 133         zlog_info("bgpd restarting!");
 134
 135         /* Reload config file. */
 136         vty_read_config(bgpd_di.config_file, config_default);
 137
 138         /* Try to return to normal operation. */
 139 }
 140
 141 /* SIGINT handler. */
 142 __attribute__((__noreturn__)) void sigint(void)
 143 {
 144         zlog_notice("Terminating on signal");
 145
 146         if (!retain_mode)
 147                 bgp_terminate();
 148
 149         bgp_exit(0);
 150
 151         exit(0);
 152 }
 153
 154 /* SIGUSR1 handler. */
 155 void sigusr1(void)
 156 {
 157         zlog_rotate();
 158 }
 159
 160 /*
 161   Try to free up allocations we know about so that diagnostic tools such as
 162   valgrind are able to better illuminate leaks.
 163
 164   Zebra route removal and protocol teardown are not meant to be done here.
 165   For example, "retain_mode" may be set.
 166 */
 167 static __attribute__((__noreturn__)) void bgp_exit(int status)
 168 {
 169         struct bgp *bgp;
 170         struct listnode *node, *nnode;
 171
 172         /* it only makes sense for this to be called on a clean exit */
 173         assert(status == 0);
 174
 175         frr_early_fini();
 176
 177         bfd_gbl_exit();
 178
 179         bgp_close();
 180
 181         /* reverse bgp_master_init */
 182         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
 183                 bgp_delete(bgp);
 184
 185         /* reverse bgp_dump_init */
 186         bgp_dump_finish();
 187
 188         /* reverse bgp_route_init */
 189         bgp_route_finish();
 190
 191         /* cleanup route maps */
 192         bgp_route_map_terminate();
 193
 194         /* reverse bgp_attr_init */
 195         bgp_attr_finish();
 196
 197         /* stop pthreads */
 198         bgp_pthreads_finish();
 199
 200         /* reverse access_list_init */
 201         access_list_add_hook(NULL);
 202         access_list_delete_hook(NULL);
 203         access_list_reset();
 204
 205         /* reverse bgp_filter_init */
 206         as_list_add_hook(NULL);
 207         as_list_delete_hook(NULL);
 208         bgp_filter_reset();
 209
 210         /* reverse prefix_list_init */
 211         prefix_list_add_hook(NULL);
 212         prefix_list_delete_hook(NULL);
 213         prefix_list_reset();
 214
 215         /* reverse community_list_init */
 216         community_list_terminate(bgp_clist);
 217
 218         bgp_vrf_terminate();
 219 #if ENABLE_BGP_VNC
 220         vnc_zebra_destroy();
 221 #endif
 222         bgp_zebra_destroy();
 223
 224         list_delete_and_null(&bm->bgp);
 225         memset(bm, 0, sizeof(*bm));
 226
 227         frr_fini();
 228         exit(status);
 229 }
 230
 231 static int bgp_vrf_new(struct vrf *vrf)
 232 {
 233         if (BGP_DEBUG(zebra, ZEBRA))
 234                 zlog_debug("VRF Created: %s(%d)", vrf->name, vrf->vrf_id);
 235
 236         return 0;
 237 }
 238
 239 static int bgp_vrf_delete(struct vrf *vrf)
 240 {
 241         if (BGP_DEBUG(zebra, ZEBRA))
 242                 zlog_debug("VRF Deletion: %s(%d)", vrf->name, vrf->vrf_id);
 243
 244         return 0;
 245 }
 246
 247 static int bgp_vrf_enable(struct vrf *vrf)
 248 {
 249         struct bgp *bgp;
 250         vrf_id_t old_vrf_id;
 251
 252         if (BGP_DEBUG(zebra, ZEBRA))
 253                 zlog_debug("VRF enable add %s id %d", vrf->name, vrf->vrf_id);
 254
 255         bgp = bgp_lookup_by_name(vrf->name);
 256         if (bgp) {
 257                 old_vrf_id = bgp->vrf_id;
 258                 /* We have instance configured, link to VRF and make it "up". */
 259                 bgp_vrf_link(bgp, vrf);
 260
 261                 /* Update any redistribute vrf bitmaps if the vrf_id changed */
 262                 if (old_vrf_id != bgp->vrf_id)
 263                         bgp_update_redist_vrf_bitmaps(bgp, old_vrf_id);
 264                 bgp_instance_up(bgp);
 265         }
 266
 267         return 0;
 268 }
 269
 270 static int bgp_vrf_disable(struct vrf *vrf)
 271 {
 272         struct bgp *bgp;
 273         vrf_id_t old_vrf_id;
 274
 275         if (vrf->vrf_id == VRF_DEFAULT)
 276                 return 0;
 277
 278         if (BGP_DEBUG(zebra, ZEBRA))
 279                 zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 280
 281         bgp = bgp_lookup_by_name(vrf->name);
 282         if (bgp) {
 283                 old_vrf_id = bgp->vrf_id;
 284                 /* We have instance configured, unlink from VRF and make it
 285                  * "down". */
 286                 bgp_vrf_unlink(bgp, vrf);
 287                 /* Update any redistribute vrf bitmaps if the vrf_id changed */
 288                 if (old_vrf_id != bgp->vrf_id)
 289                         bgp_update_redist_vrf_bitmaps(bgp, old_vrf_id);
 290                 bgp_instance_down(bgp);
 291         }
 292
 293         /* Note: This is a callback, the VRF will be deleted by the caller. */
 294         return 0;
 295 }
 296
 297 static void bgp_vrf_init(void)
 298 {
 299         vrf_init(bgp_vrf_new, bgp_vrf_enable, bgp_vrf_disable, bgp_vrf_delete);
 300 }
 301
 302 static void bgp_vrf_terminate(void)
 303 {
 304         vrf_terminate();
 305 }
 306
 307 FRR_DAEMON_INFO(bgpd, BGP, .vty_port = BGP_VTY_PORT,
 308
 309                 .proghelp = "Implementation of the BGP routing protocol.",
 310
 311                 .signals = bgp_signals, .n_signals = array_size(bgp_signals),
 312
 313                 .privs = &bgpd_privs, )
 314
 315 /* Main routine of bgpd. Treatment of argument and start bgp finite
 316    state machine is handled at here. */
 317 int main(int argc, char **argv)
 318 {
 319         int opt;
 320         int tmp_port;
 321
 322         int bgp_port = BGP_PORT_DEFAULT;
 323         char *bgp_address = NULL;
 324         int no_fib_flag = 0;
 325         int skip_runas = 0;
 326
 327         frr_preinit(&bgpd_di, argc, argv);
 328         frr_opt_add(
 329                 "p:l:rSne:", longopts,
 330                 "  -p, --bgp_port     Set bgp protocol's port number\n"
 331                 "  -l, --listenon     Listen on specified address (implies -n)\n"
 332                 "  -r, --retain       When program terminates, retain added route by bgpd.\n"
 333                 "  -n, --no_kernel    Do not install route to kernel.\n"
 334                 "  -S, --skip_runas   Skip capabilities checks, and changing user and group IDs.\n"
 335                 "  -e, --ecmp         Specify ECMP to use.\n");
 336
 337         /* Command line argument treatment. */
 338         while (1) {
 339                 opt = frr_getopt(argc, argv, 0);
 340
 341                 if (opt == EOF)
 342                         break;
 343
 344                 switch (opt) {
 345                 case 0:
 346                         break;
 347                 case 'p':
 348                         tmp_port = atoi(optarg);
 349                         if (tmp_port <= 0 || tmp_port > 0xffff)
 350                                 bgp_port = BGP_PORT_DEFAULT;
 351                         else
 352                                 bgp_port = tmp_port;
 353                         break;
 354                 case 'e':
 355                         multipath_num = atoi(optarg);
 356                         if (multipath_num > MULTIPATH_NUM
 357                             || multipath_num <= 0) {
 358                                 zlog_err(
 359                                         "Multipath Number specified must be less than %d and greater than 0",
 360                                         MULTIPATH_NUM);
 361                                 return 1;
 362                         }
 363                         break;
 364                 case 'r':
 365                         retain_mode = 1;
 366                         break;
 367                 case 'l':
 368                         bgp_address = optarg;
 369                 /* listenon implies -n */
 370                 /* fallthru */
 371                 case 'n':
 372                         no_fib_flag = 1;
 373                         break;
 374                 case 'S':
 375                         skip_runas = 1;
 376                         break;
 377                 default:
 378                         frr_help_exit(1);
 379                         break;
 380                 }
 381         }
 382         if (skip_runas)
 383                 memset(&bgpd_privs, 0, sizeof(bgpd_privs));
 384
 385         /* BGP master init. */
 386         bgp_master_init(frr_init());
 387         bm->port = bgp_port;
 388         bm->address = bgp_address;
 389         if (no_fib_flag)
 390                 bgp_option_set(BGP_OPT_NO_FIB);
 391
 392         /* Initializations. */
 393         bgp_vrf_init();
 394
 395         /* BGP related initialization.  */
 396         bgp_init();
 397
 398         snprintf(bgpd_di.startinfo, sizeof(bgpd_di.startinfo), ", bgp@%s:%d",
 399                  (bm->address ? bm->address : "<all>"), bm->port);
 400
 401         frr_config_fork();
 402         /* must be called after fork() */
 403         bgp_pthreads_run();
 404         frr_run(bm->master);
 405
 406         /* Not reached. */
 407         return (0);
 408 }