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