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