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