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