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(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;
 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
 188         /* reverse bgp_master_init */
 189         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 190                 if (bgp_default == bgp)
 191                         continue;
 192                 bgp_delete(bgp);
 193         }
 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         memset(bm, 0, sizeof(*bm));
 239
 240         frr_fini();
 241         exit(status);
 242 }
 243
 244 static int bgp_vrf_new(struct vrf *vrf)
 245 {
 246         if (BGP_DEBUG(zebra, ZEBRA))
 247                 zlog_debug("VRF Created: %s(%u)", vrf->name, vrf->vrf_id);
 248
 249         return 0;
 250 }
 251
 252 static int bgp_vrf_delete(struct vrf *vrf)
 253 {
 254         if (BGP_DEBUG(zebra, ZEBRA))
 255                 zlog_debug("VRF Deletion: %s(%u)", vrf->name, vrf->vrf_id);
 256
 257         return 0;
 258 }
 259
 260 static int bgp_vrf_enable(struct vrf *vrf)
 261 {
 262         struct bgp *bgp;
 263         vrf_id_t old_vrf_id;
 264
 265         if (BGP_DEBUG(zebra, ZEBRA))
 266                 zlog_debug("VRF enable add %s id %u", vrf->name, vrf->vrf_id);
 267
 268         bgp = bgp_lookup_by_name(vrf->name);
 269         if (bgp) {
 270                 if (bgp->name && strmatch(vrf->name, VRF_DEFAULT_NAME)) {
 271                         XFREE(MTYPE_BGP, bgp->name);
 272                         bgp->name = NULL;
 273                         XFREE(MTYPE_BGP, bgp->name_pretty);
 274                         bgp->name_pretty = XSTRDUP(MTYPE_BGP, "VRF default");
 275                 }
 276                 old_vrf_id = bgp->vrf_id;
 277                 /* We have instance configured, link to VRF and make it "up". */
 278                 bgp_vrf_link(bgp, vrf);
 279
 280                 bgp_handle_socket(bgp, vrf, old_vrf_id, true);
 281                 /* Update any redistribute vrf bitmaps if the vrf_id changed */
 282                 if (old_vrf_id != bgp->vrf_id)
 283                         bgp_update_redist_vrf_bitmaps(bgp, old_vrf_id);
 284                 bgp_instance_up(bgp);
 285                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP);
 286                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP6);
 287                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 288                                     bgp_get_default(), bgp);
 289                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 290                                     bgp_get_default(), bgp);
 291                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 292                                     bgp_get_default(), bgp);
 293                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 294                                     bgp_get_default(), bgp);
 295         }
 296
 297         return 0;
 298 }
 299
 300 static int bgp_vrf_disable(struct vrf *vrf)
 301 {
 302         struct bgp *bgp;
 303         vrf_id_t old_vrf_id;
 304
 305         if (vrf->vrf_id == VRF_DEFAULT)
 306                 return 0;
 307
 308         if (BGP_DEBUG(zebra, ZEBRA))
 309                 zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 310
 311         bgp = bgp_lookup_by_name(vrf->name);
 312         if (bgp) {
 313
 314                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP);
 315                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP6);
 316                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 317                                    bgp_get_default(), bgp);
 318                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 319                                    bgp_get_default(), bgp);
 320                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 321                                    bgp_get_default(), bgp);
 322                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 323                                    bgp_get_default(), bgp);
 324
 325                 old_vrf_id = bgp->vrf_id;
 326                 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, false);
 327                 /* We have instance configured, unlink from VRF and make it
 328                  * "down". */
 329                 bgp_vrf_unlink(bgp, vrf);
 330                 /* Update any redistribute vrf bitmaps if the vrf_id changed */
 331                 if (old_vrf_id != bgp->vrf_id)
 332                         bgp_update_redist_vrf_bitmaps(bgp, old_vrf_id);
 333                 bgp_instance_down(bgp);
 334         }
 335
 336         /* Note: This is a callback, the VRF will be deleted by the caller. */
 337         return 0;
 338 }
 339
 340 static void bgp_vrf_init(void)
 341 {
 342         vrf_init(bgp_vrf_new, bgp_vrf_enable, bgp_vrf_disable,
 343                  bgp_vrf_delete, NULL);
 344 }
 345
 346 static void bgp_vrf_terminate(void)
 347 {
 348         vrf_terminate();
 349 }
 350
 351 FRR_DAEMON_INFO(bgpd, BGP, .vty_port = BGP_VTY_PORT,
 352
 353                 .proghelp = "Implementation of the BGP routing protocol.",
 354
 355                 .signals = bgp_signals, .n_signals = array_size(bgp_signals),
 356
 357                 .privs = &bgpd_privs, )
 358
 359 #if CONFDATE > 20190521
 360 CPP_NOTICE("-r / --retain has reached deprecation EOL, remove")
 361 #endif
 362 #define DEPRECATED_OPTIONS "r"
 363
 364 /* Main routine of bgpd. Treatment of argument and start bgp finite
 365    state machine is handled at here. */
 366 int main(int argc, char **argv)
 367 {
 368         int opt;
 369         int tmp_port;
 370
 371         int bgp_port = BGP_PORT_DEFAULT;
 372         char *bgp_address = NULL;
 373         int no_fib_flag = 0;
 374         int skip_runas = 0;
 375         int instance = 0;
 376
 377         frr_preinit(&bgpd_di, argc, argv);
 378         frr_opt_add(
 379                 "p:l:Sne:I:" DEPRECATED_OPTIONS, longopts,
 380                 "  -p, --bgp_port     Set BGP listen port number (0 means do not listen).\n"
 381                 "  -l, --listenon     Listen on specified address (implies -n)\n"
 382                 "  -n, --no_kernel    Do not install route to kernel.\n"
 383                 "  -S, --skip_runas   Skip capabilities checks, and changing user and group IDs.\n"
 384                 "  -e, --ecmp         Specify ECMP to use.\n"
 385                 "  -I, --int_num      Set instance number (label-manager)\n");
 386
 387         /* Command line argument treatment. */
 388         while (1) {
 389                 opt = frr_getopt(argc, argv, 0);
 390
 391                 if (opt && opt < 128 && strchr(DEPRECATED_OPTIONS, opt)) {
 392                         fprintf(stderr,
 393                                 "The -%c option no longer exists.\nPlease refer to the manual.\n",
 394                                 opt);
 395                         continue;
 396                 }
 397
 398                 if (opt == EOF)
 399                         break;
 400
 401                 switch (opt) {
 402                 case 0:
 403                         break;
 404                 case 'p':
 405                         tmp_port = atoi(optarg);
 406                         if (tmp_port < 0 || tmp_port > 0xffff)
 407                                 bgp_port = BGP_PORT_DEFAULT;
 408                         else
 409                                 bgp_port = tmp_port;
 410                         break;
 411                 case 'e':
 412                         multipath_num = atoi(optarg);
 413                         if (multipath_num > MULTIPATH_NUM
 414                             || multipath_num <= 0) {
 415                                 flog_err(
 416                                         EC_BGP_MULTIPATH,
 417                                         "Multipath Number specified must be less than %d and greater than 0",
 418                                         MULTIPATH_NUM);
 419                                 return 1;
 420                         }
 421                         break;
 422                 case 'l':
 423                         bgp_address = optarg;
 424                 /* listenon implies -n */
 425                 /* fallthru */
 426                 case 'n':
 427                         no_fib_flag = 1;
 428                         break;
 429                 case 'S':
 430                         skip_runas = 1;
 431                         break;
 432                 case 'I':
 433                         instance = atoi(optarg);
 434                         if (instance > (unsigned short)-1)
 435                                 zlog_err("Instance %i out of range (0..%u)",
 436                                          instance, (unsigned short)-1);
 437                         break;
 438                 default:
 439                         frr_help_exit(1);
 440                         break;
 441                 }
 442         }
 443         if (skip_runas)
 444                 memset(&bgpd_privs, 0, sizeof(bgpd_privs));
 445
 446         /* BGP master init. */
 447         bgp_master_init(frr_init());
 448         bm->port = bgp_port;
 449         if (bgp_port == 0)
 450                 bgp_option_set(BGP_OPT_NO_LISTEN);
 451         bm->address = bgp_address;
 452         if (no_fib_flag)
 453                 bgp_option_set(BGP_OPT_NO_FIB);
 454
 455         bgp_error_init();
 456         /* Initializations. */
 457         bgp_vrf_init();
 458
 459         /* BGP related initialization.  */
 460         bgp_init((unsigned short)instance);
 461
 462         snprintf(bgpd_di.startinfo, sizeof(bgpd_di.startinfo), ", bgp@%s:%d",
 463                  (bm->address ? bm->address : "<all>"), bm->port);
 464
 465         frr_config_fork();
 466         /* must be called after fork() */
 467         bgp_pthreads_run();
 468         frr_run(bm->master);
 469
 470         /* Not reached. */
 471         return (0);
 472 }