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         {"no_kernel", no_argument, NULL, 'n'},
  74         {"skip_runas", no_argument, NULL, 'S'},
  75         {"ecmp", required_argument, NULL, 'e'},
  76         {"int_num", required_argument, NULL, 'I'},
  77         {"no_zebra", no_argument, NULL, 'Z'},
  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                         bgp->name = NULL;
 276                         XFREE(MTYPE_BGP, bgp->name_pretty);
 277                         bgp->name_pretty = XSTRDUP(MTYPE_BGP, "VRF default");
 278                         bgp->inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 279 #if ENABLE_BGP_VNC
 280                         if (!bgp->rfapi) {
 281                                 bgp->rfapi = bgp_rfapi_new(bgp);
 282                                 assert(bgp->rfapi);
 283                                 assert(bgp->rfapi_cfg);
 284                         }
 285 #endif /* ENABLE_BGP_VNC */
 286                 }
 287                 old_vrf_id = bgp->vrf_id;
 288                 /* We have instance configured, link to VRF and make it "up". */
 289                 bgp_vrf_link(bgp, vrf);
 290
 291                 bgp_handle_socket(bgp, vrf, old_vrf_id, true);
 292                 /* Update any redistribution if vrf_id changed */
 293                 if (old_vrf_id != bgp->vrf_id)
 294                         bgp_redistribute_redo(bgp);
 295                 bgp_instance_up(bgp);
 296                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP);
 297                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP6);
 298                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 299                                     bgp_get_default(), bgp);
 300                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 301                                     bgp_get_default(), bgp);
 302                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 303                                     bgp_get_default(), bgp);
 304                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 305                                     bgp_get_default(), bgp);
 306         }
 307
 308         return 0;
 309 }
 310
 311 static int bgp_vrf_disable(struct vrf *vrf)
 312 {
 313         struct bgp *bgp;
 314         vrf_id_t old_vrf_id;
 315
 316         if (vrf->vrf_id == VRF_DEFAULT)
 317                 return 0;
 318
 319         if (BGP_DEBUG(zebra, ZEBRA))
 320                 zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 321
 322         bgp = bgp_lookup_by_name(vrf->name);
 323         if (bgp) {
 324
 325                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP);
 326                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP6);
 327                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 328                                    bgp_get_default(), bgp);
 329                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 330                                    bgp_get_default(), bgp);
 331                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 332                                    bgp_get_default(), bgp);
 333                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 334                                    bgp_get_default(), bgp);
 335
 336                 old_vrf_id = bgp->vrf_id;
 337                 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, false);
 338                 /* We have instance configured, unlink from VRF and make it
 339                  * "down". */
 340                 bgp_vrf_unlink(bgp, vrf);
 341                 /* Delete any redistribute vrf bitmaps if the vrf_id changed */
 342                 if (old_vrf_id != bgp->vrf_id)
 343                         bgp_unset_redist_vrf_bitmaps(bgp, old_vrf_id);
 344                 bgp_instance_down(bgp);
 345         }
 346
 347         /* Note: This is a callback, the VRF will be deleted by the caller. */
 348         return 0;
 349 }
 350
 351 static void bgp_vrf_init(void)
 352 {
 353         vrf_init(bgp_vrf_new, bgp_vrf_enable, bgp_vrf_disable,
 354                  bgp_vrf_delete, bgp_vrf_enable);
 355 }
 356
 357 static void bgp_vrf_terminate(void)
 358 {
 359         vrf_terminate();
 360 }
 361
 362 static const struct frr_yang_module_info *bgpd_yang_modules[] = {
 363 };
 364
 365 FRR_DAEMON_INFO(bgpd, BGP, .vty_port = BGP_VTY_PORT,
 366
 367                 .proghelp = "Implementation of the BGP routing protocol.",
 368
 369                 .signals = bgp_signals, .n_signals = array_size(bgp_signals),
 370
 371                 .privs = &bgpd_privs, .yang_modules = bgpd_yang_modules,
 372                 .n_yang_modules = array_size(bgpd_yang_modules), )
 373
 374 #define DEPRECATED_OPTIONS ""
 375
 376 /* Main routine of bgpd. Treatment of argument and start bgp finite
 377    state machine is handled at here. */
 378 int main(int argc, char **argv)
 379 {
 380         int opt;
 381         int tmp_port;
 382
 383         int bgp_port = BGP_PORT_DEFAULT;
 384         char *bgp_address = NULL;
 385         int no_fib_flag = 0;
 386         int no_zebra_flag = 0;
 387         int skip_runas = 0;
 388         int instance = 0;
 389
 390         frr_preinit(&bgpd_di, argc, argv);
 391         frr_opt_add(
 392                 "p:l:SnZe:I:" DEPRECATED_OPTIONS, longopts,
 393                 "  -p, --bgp_port     Set BGP listen port number (0 means do not listen).\n"
 394                 "  -l, --listenon     Listen on specified address (implies -n)\n"
 395                 "  -n, --no_kernel    Do not install route to kernel.\n"
 396                 "  -Z, --no_zebra     Do not communicate with Zebra.\n"
 397                 "  -S, --skip_runas   Skip capabilities checks, and changing user and group IDs.\n"
 398                 "  -e, --ecmp         Specify ECMP to use.\n"
 399                 "  -I, --int_num      Set instance number (label-manager)\n");
 400
 401         /* Command line argument treatment. */
 402         while (1) {
 403                 opt = frr_getopt(argc, argv, 0);
 404
 405                 if (opt && opt < 128 && strchr(DEPRECATED_OPTIONS, opt)) {
 406                         fprintf(stderr,
 407                                 "The -%c option no longer exists.\nPlease refer to the manual.\n",
 408                                 opt);
 409                         continue;
 410                 }
 411
 412                 if (opt == EOF)
 413                         break;
 414
 415                 switch (opt) {
 416                 case 0:
 417                         break;
 418                 case 'p':
 419                         tmp_port = atoi(optarg);
 420                         if (tmp_port < 0 || tmp_port > 0xffff)
 421                                 bgp_port = BGP_PORT_DEFAULT;
 422                         else
 423                                 bgp_port = tmp_port;
 424                         break;
 425                 case 'e':
 426                         multipath_num = atoi(optarg);
 427                         if (multipath_num > MULTIPATH_NUM
 428                             || multipath_num <= 0) {
 429                                 flog_err(
 430                                         EC_BGP_MULTIPATH,
 431                                         "Multipath Number specified must be less than %d and greater than 0",
 432                                         MULTIPATH_NUM);
 433                                 return 1;
 434                         }
 435                         break;
 436                 case 'l':
 437                         bgp_address = optarg;
 438                 /* listenon implies -n */
 439                 /* fallthru */
 440                 case 'n':
 441                         no_fib_flag = 1;
 442                         break;
 443                 case 'Z':
 444                         no_zebra_flag = 1;
 445                         break;
 446                 case 'S':
 447                         skip_runas = 1;
 448                         break;
 449                 case 'I':
 450                         instance = atoi(optarg);
 451                         if (instance > (unsigned short)-1)
 452                                 zlog_err("Instance %i out of range (0..%u)",
 453                                          instance, (unsigned short)-1);
 454                         break;
 455                 default:
 456                         frr_help_exit(1);
 457                         break;
 458                 }
 459         }
 460         if (skip_runas)
 461                 memset(&bgpd_privs, 0, sizeof(bgpd_privs));
 462
 463         /* BGP master init. */
 464         bgp_master_init(frr_init());
 465         bm->port = bgp_port;
 466         if (bgp_port == 0)
 467                 bgp_option_set(BGP_OPT_NO_LISTEN);
 468         bm->address = bgp_address;
 469         if (no_fib_flag || no_zebra_flag)
 470                 bgp_option_set(BGP_OPT_NO_FIB);
 471         if (no_zebra_flag)
 472                 bgp_option_set(BGP_OPT_NO_ZEBRA);
 473         bgp_error_init();
 474         /* Initializations. */
 475         bgp_vrf_init();
 476
 477         /* BGP related initialization.  */
 478         bgp_init((unsigned short)instance);
 479
 480         snprintf(bgpd_di.startinfo, sizeof(bgpd_di.startinfo), ", bgp@%s:%d",
 481                  (bm->address ? bm->address : "<all>"), bm->port);
 482
 483         frr_config_fork();
 484         /* must be called after fork() */
 485         bgp_pthreads_run();
 486         frr_run(bm->master);
 487
 488         /* Not reached. */
 489         return (0);
 490 }