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 "prefix.h"
  31 #include "log.h"
  32 #include "privs.h"
  33 #include "sigevent.h"
  34 #include "zclient.h"
  35 #include "routemap.h"
  36 #include "filter.h"
  37 #include "plist.h"
  38 #include "stream.h"
  39 #include "queue.h"
  40 #include "vrf.h"
  41 #include "bfd.h"
  42 #include "libfrr.h"
  43 #include "ns.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_errors.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 #include "bgpd/bgp_errors.h"
  63
  64 #ifdef ENABLE_BGP_VNC
  65 #include "bgpd/rfapi/rfapi_backend.h"
  66 #endif
  67
  68 /* bgpd options, we use GNU getopt library. */
  69 static const struct option longopts[] = {
  70         {"bgp_port", required_argument, NULL, 'p'},
  71         {"listenon", required_argument, NULL, 'l'},
  72         {"no_kernel", no_argument, NULL, 'n'},
  73         {"skip_runas", no_argument, NULL, 'S'},
  74         {"ecmp", required_argument, NULL, 'e'},
  75         {"int_num", required_argument, NULL, 'I'},
  76         {"no_zebra", no_argument, NULL, 'Z'},
  77         {"socket_size", required_argument, NULL, 's'},
  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(NULL, 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, *bgp_evpn;
 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         bgp_evpn = bgp_get_evpn();
 185
 186         /* reverse bgp_master_init */
 187         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 188                 if (bgp_default == bgp || bgp_evpn == bgp)
 189                         continue;
 190                 bgp_delete(bgp);
 191         }
 192         if (bgp_evpn && bgp_evpn != bgp_default)
 193                 bgp_delete(bgp_evpn);
 194         if (bgp_default)
 195                 bgp_delete(bgp_default);
 196
 197         /* reverse bgp_dump_init */
 198         bgp_dump_finish();
 199
 200         /* reverse bgp_route_init */
 201         bgp_route_finish();
 202
 203         /* cleanup route maps */
 204         bgp_route_map_terminate();
 205
 206         /* reverse bgp_attr_init */
 207         bgp_attr_finish();
 208
 209         /* stop pthreads */
 210         bgp_pthreads_finish();
 211
 212         /* reverse access_list_init */
 213         access_list_add_hook(NULL);
 214         access_list_delete_hook(NULL);
 215         access_list_reset();
 216
 217         /* reverse bgp_filter_init */
 218         as_list_add_hook(NULL);
 219         as_list_delete_hook(NULL);
 220         bgp_filter_reset();
 221
 222         /* reverse prefix_list_init */
 223         prefix_list_add_hook(NULL);
 224         prefix_list_delete_hook(NULL);
 225         prefix_list_reset();
 226
 227         /* reverse community_list_init */
 228         community_list_terminate(bgp_clist);
 229
 230         bgp_vrf_terminate();
 231 #if ENABLE_BGP_VNC
 232         vnc_zebra_destroy();
 233 #endif
 234         bgp_zebra_destroy();
 235
 236         bf_free(bm->rd_idspace);
 237         list_delete(&bm->bgp);
 238
 239         bgp_lp_finish();
 240
 241         memset(bm, 0, sizeof(*bm));
 242
 243         frr_fini();
 244         exit(status);
 245 }
 246
 247 static int bgp_vrf_new(struct vrf *vrf)
 248 {
 249         if (BGP_DEBUG(zebra, ZEBRA))
 250                 zlog_debug("VRF Created: %s(%u)", vrf->name, vrf->vrf_id);
 251
 252         return 0;
 253 }
 254
 255 static int bgp_vrf_delete(struct vrf *vrf)
 256 {
 257         if (BGP_DEBUG(zebra, ZEBRA))
 258                 zlog_debug("VRF Deletion: %s(%u)", vrf->name, vrf->vrf_id);
 259
 260         return 0;
 261 }
 262
 263 static int bgp_vrf_enable(struct vrf *vrf)
 264 {
 265         struct bgp *bgp;
 266         vrf_id_t old_vrf_id;
 267
 268         if (BGP_DEBUG(zebra, ZEBRA))
 269                 zlog_debug("VRF enable add %s id %u", vrf->name, vrf->vrf_id);
 270
 271         bgp = bgp_lookup_by_name(vrf->name);
 272         if (bgp && bgp->vrf_id != vrf->vrf_id) {
 273                 if (bgp->name && strmatch(vrf->name, VRF_DEFAULT_NAME)) {
 274                         XFREE(MTYPE_BGP, bgp->name);
 275                         XFREE(MTYPE_BGP, bgp->name_pretty);
 276                         bgp->name_pretty = XSTRDUP(MTYPE_BGP, "VRF default");
 277                         bgp->inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 278 #if ENABLE_BGP_VNC
 279                         if (!bgp->rfapi) {
 280                                 bgp->rfapi = bgp_rfapi_new(bgp);
 281                                 assert(bgp->rfapi);
 282                                 assert(bgp->rfapi_cfg);
 283                         }
 284 #endif /* ENABLE_BGP_VNC */
 285                 }
 286                 old_vrf_id = bgp->vrf_id;
 287                 /* We have instance configured, link to VRF and make it "up". */
 288                 bgp_vrf_link(bgp, vrf);
 289
 290                 bgp_handle_socket(bgp, vrf, old_vrf_id, true);
 291                 /* Update any redistribution if vrf_id changed */
 292                 if (old_vrf_id != bgp->vrf_id)
 293                         bgp_redistribute_redo(bgp);
 294                 bgp_instance_up(bgp);
 295                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP);
 296                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP6);
 297                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 298                                     bgp_get_default(), bgp);
 299                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 300                                     bgp_get_default(), bgp);
 301                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 302                                     bgp_get_default(), bgp);
 303                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 304                                     bgp_get_default(), bgp);
 305         }
 306
 307         return 0;
 308 }
 309
 310 static int bgp_vrf_disable(struct vrf *vrf)
 311 {
 312         struct bgp *bgp;
 313         vrf_id_t old_vrf_id;
 314
 315         if (vrf->vrf_id == VRF_DEFAULT)
 316                 return 0;
 317
 318         if (BGP_DEBUG(zebra, ZEBRA))
 319                 zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 320
 321         bgp = bgp_lookup_by_name(vrf->name);
 322         if (bgp) {
 323
 324                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP);
 325                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP6);
 326                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 327                                    bgp_get_default(), bgp);
 328                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 329                                    bgp_get_default(), bgp);
 330                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 331                                    bgp_get_default(), bgp);
 332                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 333                                    bgp_get_default(), bgp);
 334
 335                 old_vrf_id = bgp->vrf_id;
 336                 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, false);
 337                 /* We have instance configured, unlink from VRF and make it
 338                  * "down". */
 339                 bgp_vrf_unlink(bgp, vrf);
 340                 /* Delete any redistribute vrf bitmaps if the vrf_id changed */
 341                 if (old_vrf_id != bgp->vrf_id)
 342                         bgp_unset_redist_vrf_bitmaps(bgp, old_vrf_id);
 343                 bgp_instance_down(bgp);
 344         }
 345
 346         /* Note: This is a callback, the VRF will be deleted by the caller. */
 347         return 0;
 348 }
 349
 350 static void bgp_vrf_init(void)
 351 {
 352         vrf_init(bgp_vrf_new, bgp_vrf_enable, bgp_vrf_disable,
 353                  bgp_vrf_delete, bgp_vrf_enable);
 354 }
 355
 356 static void bgp_vrf_terminate(void)
 357 {
 358         vrf_terminate();
 359 }
 360
 361 static const struct frr_yang_module_info *const bgpd_yang_modules[] = {
 362         &frr_interface_info,
 363         &frr_route_map_info,
 364 };
 365
 366 FRR_DAEMON_INFO(bgpd, BGP, .vty_port = BGP_VTY_PORT,
 367
 368                 .proghelp = "Implementation of the BGP routing protocol.",
 369
 370                 .signals = bgp_signals, .n_signals = array_size(bgp_signals),
 371
 372                 .privs = &bgpd_privs, .yang_modules = bgpd_yang_modules,
 373                 .n_yang_modules = array_size(bgpd_yang_modules), )
 374
 375 #define DEPRECATED_OPTIONS ""
 376
 377 /* Main routine of bgpd. Treatment of argument and start bgp finite
 378    state machine is handled at here. */
 379 int main(int argc, char **argv)
 380 {
 381         int opt;
 382         int tmp_port;
 383
 384         int bgp_port = BGP_PORT_DEFAULT;
 385         char *bgp_address = NULL;
 386         int no_fib_flag = 0;
 387         int no_zebra_flag = 0;
 388         int skip_runas = 0;
 389         int instance = 0;
 390         int buffer_size = BGP_SOCKET_SNDBUF_SIZE;
 391
 392         frr_preinit(&bgpd_di, argc, argv);
 393         frr_opt_add(
 394                 "p:l:SnZe:I:s:" DEPRECATED_OPTIONS, longopts,
 395                 "  -p, --bgp_port     Set BGP listen port number (0 means do not listen).\n"
 396                 "  -l, --listenon     Listen on specified address (implies -n)\n"
 397                 "  -n, --no_kernel    Do not install route to kernel.\n"
 398                 "  -Z, --no_zebra     Do not communicate with Zebra.\n"
 399                 "  -S, --skip_runas   Skip capabilities checks, and changing user and group IDs.\n"
 400                 "  -e, --ecmp         Specify ECMP to use.\n"
 401                 "  -I, --int_num      Set instance number (label-manager)\n"
 402                 "  -s, --socket_size  Set BGP peer socket send buffer size\n");
 403
 404         /* Command line argument treatment. */
 405         while (1) {
 406                 opt = frr_getopt(argc, argv, 0);
 407
 408                 if (opt && opt < 128 && strchr(DEPRECATED_OPTIONS, opt)) {
 409                         fprintf(stderr,
 410                                 "The -%c option no longer exists.\nPlease refer to the manual.\n",
 411                                 opt);
 412                         continue;
 413                 }
 414
 415                 if (opt == EOF)
 416                         break;
 417
 418                 switch (opt) {
 419                 case 0:
 420                         break;
 421                 case 'p':
 422                         tmp_port = atoi(optarg);
 423                         if (tmp_port < 0 || tmp_port > 0xffff)
 424                                 bgp_port = BGP_PORT_DEFAULT;
 425                         else
 426                                 bgp_port = tmp_port;
 427                         break;
 428                 case 'e':
 429                         multipath_num = atoi(optarg);
 430                         if (multipath_num > MULTIPATH_NUM
 431                             || multipath_num <= 0) {
 432                                 flog_err(
 433                                         EC_BGP_MULTIPATH,
 434                                         "Multipath Number specified must be less than %d and greater than 0",
 435                                         MULTIPATH_NUM);
 436                                 return 1;
 437                         }
 438                         break;
 439                 case 'l':
 440                         bgp_address = optarg;
 441                 /* listenon implies -n */
 442                 /* fallthru */
 443                 case 'n':
 444                         no_fib_flag = 1;
 445                         break;
 446                 case 'Z':
 447                         no_zebra_flag = 1;
 448                         break;
 449                 case 'S':
 450                         skip_runas = 1;
 451                         break;
 452                 case 'I':
 453                         instance = atoi(optarg);
 454                         if (instance > (unsigned short)-1)
 455                                 zlog_err("Instance %i out of range (0..%u)",
 456                                          instance, (unsigned short)-1);
 457                         break;
 458                 case 's':
 459                         buffer_size = atoi(optarg);
 460                         break;
 461                 default:
 462                         frr_help_exit(1);
 463                         break;
 464                 }
 465         }
 466         if (skip_runas)
 467                 memset(&bgpd_privs, 0, sizeof(bgpd_privs));
 468
 469         /* BGP master init. */
 470         bgp_master_init(frr_init(), buffer_size);
 471         bm->port = bgp_port;
 472         if (bgp_port == 0)
 473                 bgp_option_set(BGP_OPT_NO_LISTEN);
 474         bm->address = bgp_address;
 475         if (no_fib_flag || no_zebra_flag)
 476                 bgp_option_set(BGP_OPT_NO_FIB);
 477         if (no_zebra_flag)
 478                 bgp_option_set(BGP_OPT_NO_ZEBRA);
 479         bgp_error_init();
 480         /* Initializations. */
 481         bgp_vrf_init();
 482
 483         /* BGP related initialization.  */
 484         bgp_init((unsigned short)instance);
 485
 486         snprintf(bgpd_di.startinfo, sizeof(bgpd_di.startinfo), ", bgp@%s:%d",
 487                  (bm->address ? bm->address : "<all>"), bm->port);
 488
 489         frr_config_fork();
 490         /* must be called after fork() */
 491         bgp_gr_apply_running_config();
 492         bgp_pthreads_run();
 493         frr_run(bm->master);
 494
 495         /* Not reached. */
 496         return (0);
 497 }