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         {"socket_size", required_argument, NULL, 's'},
  79         {0}};
  80
  81 /* signal definitions */
  82 void sighup(void);
  83 void sigint(void);
  84 void sigusr1(void);
  85
  86 static void bgp_exit(int);
  87 static void bgp_vrf_terminate(void);
  88
  89 static struct quagga_signal_t bgp_signals[] = {
  90         {
  91                 .signal = SIGHUP,
  92                 .handler = &sighup,
  93         },
  94         {
  95                 .signal = SIGUSR1,
  96                 .handler = &sigusr1,
  97         },
  98         {
  99                 .signal = SIGINT,
 100                 .handler = &sigint,
 101         },
 102         {
 103                 .signal = SIGTERM,
 104                 .handler = &sigint,
 105         },
 106 };
 107
 108 /* privileges */
 109 static zebra_capabilities_t _caps_p[] = {ZCAP_BIND, ZCAP_NET_RAW,
 110                                          ZCAP_NET_ADMIN, ZCAP_SYS_ADMIN};
 111
 112 struct zebra_privs_t bgpd_privs = {
 113 #if defined(FRR_USER) && defined(FRR_GROUP)
 114         .user = FRR_USER,
 115         .group = FRR_GROUP,
 116 #endif
 117 #ifdef VTY_GROUP
 118         .vty_group = VTY_GROUP,
 119 #endif
 120         .caps_p = _caps_p,
 121         .cap_num_p = array_size(_caps_p),
 122         .cap_num_i = 0,
 123 };
 124
 125 static struct frr_daemon_info bgpd_di;
 126
 127 /* SIGHUP handler. */
 128 void sighup(void)
 129 {
 130         zlog_info("SIGHUP received");
 131
 132         /* Terminate all thread. */
 133         bgp_terminate();
 134         bgp_reset();
 135         zlog_info("bgpd restarting!");
 136
 137         /* Reload config file. */
 138         vty_read_config(NULL, bgpd_di.config_file, config_default);
 139
 140         /* Try to return to normal operation. */
 141 }
 142
 143 /* SIGINT handler. */
 144 __attribute__((__noreturn__)) void sigint(void)
 145 {
 146         zlog_notice("Terminating on signal");
 147         assert(bm->terminating == false);
 148         bm->terminating = true; /* global flag that shutting down */
 149
 150         bgp_terminate();
 151
 152         bgp_exit(0);
 153
 154         exit(0);
 155 }
 156
 157 /* SIGUSR1 handler. */
 158 void sigusr1(void)
 159 {
 160         zlog_rotate();
 161 }
 162
 163 /*
 164   Try to free up allocations we know about so that diagnostic tools such as
 165   valgrind are able to better illuminate leaks.
 166
 167   Zebra route removal and protocol teardown are not meant to be done here.
 168   For example, "retain_mode" may be set.
 169 */
 170 static __attribute__((__noreturn__)) void bgp_exit(int status)
 171 {
 172         struct bgp *bgp, *bgp_default, *bgp_evpn;
 173         struct listnode *node, *nnode;
 174
 175         /* it only makes sense for this to be called on a clean exit */
 176         assert(status == 0);
 177
 178         frr_early_fini();
 179
 180         bfd_gbl_exit();
 181
 182         bgp_close();
 183
 184         bgp_default = bgp_get_default();
 185         bgp_evpn = bgp_get_evpn();
 186
 187         /* reverse bgp_master_init */
 188         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
 189                 if (bgp_default == bgp || bgp_evpn == bgp)
 190                         continue;
 191                 bgp_delete(bgp);
 192         }
 193         if (bgp_evpn && bgp_evpn != bgp_default)
 194                 bgp_delete(bgp_evpn);
 195         if (bgp_default)
 196                 bgp_delete(bgp_default);
 197
 198         /* reverse bgp_dump_init */
 199         bgp_dump_finish();
 200
 201         /* reverse bgp_route_init */
 202         bgp_route_finish();
 203
 204         /* cleanup route maps */
 205         bgp_route_map_terminate();
 206
 207         /* reverse bgp_attr_init */
 208         bgp_attr_finish();
 209
 210         /* stop pthreads */
 211         bgp_pthreads_finish();
 212
 213         /* reverse access_list_init */
 214         access_list_add_hook(NULL);
 215         access_list_delete_hook(NULL);
 216         access_list_reset();
 217
 218         /* reverse bgp_filter_init */
 219         as_list_add_hook(NULL);
 220         as_list_delete_hook(NULL);
 221         bgp_filter_reset();
 222
 223         /* reverse prefix_list_init */
 224         prefix_list_add_hook(NULL);
 225         prefix_list_delete_hook(NULL);
 226         prefix_list_reset();
 227
 228         /* reverse community_list_init */
 229         community_list_terminate(bgp_clist);
 230
 231         bgp_vrf_terminate();
 232 #if ENABLE_BGP_VNC
 233         vnc_zebra_destroy();
 234 #endif
 235         bgp_zebra_destroy();
 236
 237         bf_free(bm->rd_idspace);
 238         list_delete(&bm->bgp);
 239
 240         bgp_lp_finish();
 241
 242         memset(bm, 0, sizeof(*bm));
 243
 244         frr_fini();
 245         exit(status);
 246 }
 247
 248 static int bgp_vrf_new(struct vrf *vrf)
 249 {
 250         if (BGP_DEBUG(zebra, ZEBRA))
 251                 zlog_debug("VRF Created: %s(%u)", vrf->name, vrf->vrf_id);
 252
 253         return 0;
 254 }
 255
 256 static int bgp_vrf_delete(struct vrf *vrf)
 257 {
 258         if (BGP_DEBUG(zebra, ZEBRA))
 259                 zlog_debug("VRF Deletion: %s(%u)", vrf->name, vrf->vrf_id);
 260
 261         return 0;
 262 }
 263
 264 static int bgp_vrf_enable(struct vrf *vrf)
 265 {
 266         struct bgp *bgp;
 267         vrf_id_t old_vrf_id;
 268
 269         if (BGP_DEBUG(zebra, ZEBRA))
 270                 zlog_debug("VRF enable add %s id %u", vrf->name, vrf->vrf_id);
 271
 272         bgp = bgp_lookup_by_name(vrf->name);
 273         if (bgp && bgp->vrf_id != vrf->vrf_id) {
 274                 if (bgp->name && strmatch(vrf->name, VRF_DEFAULT_NAME)) {
 275                         XFREE(MTYPE_BGP, bgp->name);
 276                         bgp->name = NULL;
 277                         XFREE(MTYPE_BGP, bgp->name_pretty);
 278                         bgp->name_pretty = XSTRDUP(MTYPE_BGP, "VRF default");
 279                         bgp->inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 280 #if ENABLE_BGP_VNC
 281                         if (!bgp->rfapi) {
 282                                 bgp->rfapi = bgp_rfapi_new(bgp);
 283                                 assert(bgp->rfapi);
 284                                 assert(bgp->rfapi_cfg);
 285                         }
 286 #endif /* ENABLE_BGP_VNC */
 287                 }
 288                 old_vrf_id = bgp->vrf_id;
 289                 /* We have instance configured, link to VRF and make it "up". */
 290                 bgp_vrf_link(bgp, vrf);
 291
 292                 bgp_handle_socket(bgp, vrf, old_vrf_id, true);
 293                 /* Update any redistribution if vrf_id changed */
 294                 if (old_vrf_id != bgp->vrf_id)
 295                         bgp_redistribute_redo(bgp);
 296                 bgp_instance_up(bgp);
 297                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP);
 298                 vpn_leak_zebra_vrf_label_update(bgp, AFI_IP6);
 299                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 300                                     bgp_get_default(), bgp);
 301                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 302                                     bgp_get_default(), bgp);
 303                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 304                                     bgp_get_default(), bgp);
 305                 vpn_leak_postchange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 306                                     bgp_get_default(), bgp);
 307         }
 308
 309         return 0;
 310 }
 311
 312 static int bgp_vrf_disable(struct vrf *vrf)
 313 {
 314         struct bgp *bgp;
 315         vrf_id_t old_vrf_id;
 316
 317         if (vrf->vrf_id == VRF_DEFAULT)
 318                 return 0;
 319
 320         if (BGP_DEBUG(zebra, ZEBRA))
 321                 zlog_debug("VRF disable %s id %d", vrf->name, vrf->vrf_id);
 322
 323         bgp = bgp_lookup_by_name(vrf->name);
 324         if (bgp) {
 325
 326                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP);
 327                 vpn_leak_zebra_vrf_label_withdraw(bgp, AFI_IP6);
 328                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP,
 329                                    bgp_get_default(), bgp);
 330                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP,
 331                                    bgp_get_default(), bgp);
 332                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, AFI_IP6,
 333                                    bgp_get_default(), bgp);
 334                 vpn_leak_prechange(BGP_VPN_POLICY_DIR_FROMVPN, AFI_IP6,
 335                                    bgp_get_default(), bgp);
 336
 337                 old_vrf_id = bgp->vrf_id;
 338                 bgp_handle_socket(bgp, vrf, VRF_UNKNOWN, false);
 339                 /* We have instance configured, unlink from VRF and make it
 340                  * "down". */
 341                 bgp_vrf_unlink(bgp, vrf);
 342                 /* Delete any redistribute vrf bitmaps if the vrf_id changed */
 343                 if (old_vrf_id != bgp->vrf_id)
 344                         bgp_unset_redist_vrf_bitmaps(bgp, old_vrf_id);
 345                 bgp_instance_down(bgp);
 346         }
 347
 348         /* Note: This is a callback, the VRF will be deleted by the caller. */
 349         return 0;
 350 }
 351
 352 static void bgp_vrf_init(void)
 353 {
 354         vrf_init(bgp_vrf_new, bgp_vrf_enable, bgp_vrf_disable,
 355                  bgp_vrf_delete, bgp_vrf_enable);
 356 }
 357
 358 static void bgp_vrf_terminate(void)
 359 {
 360         vrf_terminate();
 361 }
 362
 363 static const struct frr_yang_module_info *const bgpd_yang_modules[] = {
 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_pthreads_run();
 492         frr_run(bm->master);
 493
 494         /* Not reached. */
 495         return (0);
 496 }