bgpd/bgp_vty.c

   1 /* BGP VTY interface.
   2  * Copyright (C) 1996, 97, 98, 99, 2000 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 "command.h"
  24 #include "lib/json.h"
  25 #include "prefix.h"
  26 #include "plist.h"
  27 #include "buffer.h"
  28 #include "linklist.h"
  29 #include "stream.h"
  30 #include "thread.h"
  31 #include "log.h"
  32 #include "memory.h"
  33 #include "memory_vty.h"
  34 #include "hash.h"
  35 #include "queue.h"
  36 #include "filter.h"
  37 #include "frrstr.h"
  38
  39 #include "bgpd/bgpd.h"
  40 #include "bgpd/bgp_advertise.h"
  41 #include "bgpd/bgp_attr.h"
  42 #include "bgpd/bgp_aspath.h"
  43 #include "bgpd/bgp_community.h"
  44 #include "bgpd/bgp_ecommunity.h"
  45 #include "bgpd/bgp_lcommunity.h"
  46 #include "bgpd/bgp_damp.h"
  47 #include "bgpd/bgp_debug.h"
  48 #include "bgpd/bgp_errors.h"
  49 #include "bgpd/bgp_fsm.h"
  50 #include "bgpd/bgp_nexthop.h"
  51 #include "bgpd/bgp_open.h"
  52 #include "bgpd/bgp_regex.h"
  53 #include "bgpd/bgp_route.h"
  54 #include "bgpd/bgp_mplsvpn.h"
  55 #include "bgpd/bgp_zebra.h"
  56 #include "bgpd/bgp_table.h"
  57 #include "bgpd/bgp_vty.h"
  58 #include "bgpd/bgp_mpath.h"
  59 #include "bgpd/bgp_packet.h"
  60 #include "bgpd/bgp_updgrp.h"
  61 #include "bgpd/bgp_bfd.h"
  62 #include "bgpd/bgp_io.h"
  63 #include "bgpd/bgp_evpn.h"
  64
  65 static struct peer_group *listen_range_exists(struct bgp *bgp,
  66                                               struct prefix *range, int exact);
  67
  68 static enum node_type bgp_node_type(afi_t afi, safi_t safi)
  69 {
  70         switch (afi) {
  71         case AFI_IP:
  72                 switch (safi) {
  73                 case SAFI_UNICAST:
  74                         return BGP_IPV4_NODE;
  75                         break;
  76                 case SAFI_MULTICAST:
  77                         return BGP_IPV4M_NODE;
  78                         break;
  79                 case SAFI_LABELED_UNICAST:
  80                         return BGP_IPV4L_NODE;
  81                         break;
  82                 case SAFI_MPLS_VPN:
  83                         return BGP_VPNV4_NODE;
  84                         break;
  85                 case SAFI_FLOWSPEC:
  86                         return BGP_FLOWSPECV4_NODE;
  87                 default:
  88                         /* not expected */
  89                         return BGP_IPV4_NODE;
  90                         break;
  91                 }
  92                 break;
  93         case AFI_IP6:
  94                 switch (safi) {
  95                 case SAFI_UNICAST:
  96                         return BGP_IPV6_NODE;
  97                         break;
  98                 case SAFI_MULTICAST:
  99                         return BGP_IPV6M_NODE;
 100                         break;
 101                 case SAFI_LABELED_UNICAST:
 102                         return BGP_IPV6L_NODE;
 103                         break;
 104                 case SAFI_MPLS_VPN:
 105                         return BGP_VPNV6_NODE;
 106                         break;
 107                 case SAFI_FLOWSPEC:
 108                         return BGP_FLOWSPECV6_NODE;
 109                 default:
 110                         /* not expected */
 111                         return BGP_IPV4_NODE;
 112                         break;
 113                 }
 114                 break;
 115         case AFI_L2VPN:
 116                 return BGP_EVPN_NODE;
 117                 break;
 118         case AFI_MAX:
 119                 // We should never be here but to clarify the switch statement..
 120                 return BGP_IPV4_NODE;
 121                 break;
 122         }
 123
 124         // Impossible to happen
 125         return BGP_IPV4_NODE;
 126 }
 127
 128 /* Utility function to get address family from current node.  */
 129 afi_t bgp_node_afi(struct vty *vty)
 130 {
 131         afi_t afi;
 132         switch (vty->node) {
 133         case BGP_IPV6_NODE:
 134         case BGP_IPV6M_NODE:
 135         case BGP_IPV6L_NODE:
 136         case BGP_VPNV6_NODE:
 137         case BGP_FLOWSPECV6_NODE:
 138                 afi = AFI_IP6;
 139                 break;
 140         case BGP_EVPN_NODE:
 141                 afi = AFI_L2VPN;
 142                 break;
 143         default:
 144                 afi = AFI_IP;
 145                 break;
 146         }
 147         return afi;
 148 }
 149
 150 /* Utility function to get subsequent address family from current
 151    node.  */
 152 safi_t bgp_node_safi(struct vty *vty)
 153 {
 154         safi_t safi;
 155         switch (vty->node) {
 156         case BGP_VPNV4_NODE:
 157         case BGP_VPNV6_NODE:
 158                 safi = SAFI_MPLS_VPN;
 159                 break;
 160         case BGP_IPV4M_NODE:
 161         case BGP_IPV6M_NODE:
 162                 safi = SAFI_MULTICAST;
 163                 break;
 164         case BGP_EVPN_NODE:
 165                 safi = SAFI_EVPN;
 166                 break;
 167         case BGP_IPV4L_NODE:
 168         case BGP_IPV6L_NODE:
 169                 safi = SAFI_LABELED_UNICAST;
 170                 break;
 171         case BGP_FLOWSPECV4_NODE:
 172         case BGP_FLOWSPECV6_NODE:
 173                 safi = SAFI_FLOWSPEC;
 174                 break;
 175         default:
 176                 safi = SAFI_UNICAST;
 177                 break;
 178         }
 179         return safi;
 180 }
 181
 182 /**
 183  * Converts an AFI in string form to afi_t
 184  *
 185  * @param afi string, one of
 186  *  - "ipv4"
 187  *  - "ipv6"
 188  *  - "l2vpn"
 189  * @return the corresponding afi_t
 190  */
 191 afi_t bgp_vty_afi_from_str(const char *afi_str)
 192 {
 193         afi_t afi = AFI_MAX; /* unknown */
 194         if (strmatch(afi_str, "ipv4"))
 195                 afi = AFI_IP;
 196         else if (strmatch(afi_str, "ipv6"))
 197                 afi = AFI_IP6;
 198         else if (strmatch(afi_str, "l2vpn"))
 199                 afi = AFI_L2VPN;
 200         return afi;
 201 }
 202
 203 int argv_find_and_parse_afi(struct cmd_token **argv, int argc, int *index,
 204                             afi_t *afi)
 205 {
 206         int ret = 0;
 207         if (argv_find(argv, argc, "ipv4", index)) {
 208                 ret = 1;
 209                 if (afi)
 210                         *afi = AFI_IP;
 211         } else if (argv_find(argv, argc, "ipv6", index)) {
 212                 ret = 1;
 213                 if (afi)
 214                         *afi = AFI_IP6;
 215         }
 216         return ret;
 217 }
 218
 219 /* supports <unicast|multicast|vpn|labeled-unicast> */
 220 safi_t bgp_vty_safi_from_str(const char *safi_str)
 221 {
 222         safi_t safi = SAFI_MAX; /* unknown */
 223         if (strmatch(safi_str, "multicast"))
 224                 safi = SAFI_MULTICAST;
 225         else if (strmatch(safi_str, "unicast"))
 226                 safi = SAFI_UNICAST;
 227         else if (strmatch(safi_str, "vpn"))
 228                 safi = SAFI_MPLS_VPN;
 229         else if (strmatch(safi_str, "evpn"))
 230                 safi = SAFI_EVPN;
 231         else if (strmatch(safi_str, "labeled-unicast"))
 232                 safi = SAFI_LABELED_UNICAST;
 233         else if (strmatch(safi_str, "flowspec"))
 234                 safi = SAFI_FLOWSPEC;
 235         return safi;
 236 }
 237
 238 int argv_find_and_parse_safi(struct cmd_token **argv, int argc, int *index,
 239                              safi_t *safi)
 240 {
 241         int ret = 0;
 242         if (argv_find(argv, argc, "unicast", index)) {
 243                 ret = 1;
 244                 if (safi)
 245                         *safi = SAFI_UNICAST;
 246         } else if (argv_find(argv, argc, "multicast", index)) {
 247                 ret = 1;
 248                 if (safi)
 249                         *safi = SAFI_MULTICAST;
 250         } else if (argv_find(argv, argc, "labeled-unicast", index)) {
 251                 ret = 1;
 252                 if (safi)
 253                         *safi = SAFI_LABELED_UNICAST;
 254         } else if (argv_find(argv, argc, "vpn", index)) {
 255                 ret = 1;
 256                 if (safi)
 257                         *safi = SAFI_MPLS_VPN;
 258         } else if (argv_find(argv, argc, "flowspec", index)) {
 259                 ret = 1;
 260                 if (safi)
 261                         *safi = SAFI_FLOWSPEC;
 262         }
 263         return ret;
 264 }
 265
 266 /*
 267  * bgp_vty_find_and_parse_afi_safi_bgp
 268  *
 269  * For a given 'show ...' command, correctly parse the afi/safi/bgp out from it
 270  * This function *assumes* that the calling function pre-sets the afi/safi/bgp
 271  * to appropriate values for the calling function.  This is to allow the
 272  * calling function to make decisions appropriate for the show command
 273  * that is being parsed.
 274  *
 275  * The show commands are generally of the form:
 276  * "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>
 277  * [<unicast|multicast|vpn|labeled-unicast>]] ..."
 278  *
 279  * Since we use argv_find if the show command in particular doesn't have:
 280  * [ip]
 281  * [<view|vrf> VIEWVRFNAME]
 282  * [<ipv4|ipv6> [<unicast|multicast|vpn|labeled-unicast>]]
 283  * The command parsing should still be ok.
 284  *
 285  * vty  -> The vty for the command so we can output some useful data in
 286  *         the event of a parse error in the vrf.
 287  * argv -> The command tokens
 288  * argc -> How many command tokens we have
 289  * idx  -> The current place in the command, generally should be 0 for this
 290  * function
 291  * afi  -> The parsed afi if it was included in the show command, returned here
 292  * safi -> The parsed safi if it was included in the show command, returned here
 293  * bgp  -> Pointer to the bgp data structure we need to fill in.
 294  *
 295  * The function returns the correct location in the parse tree for the
 296  * last token found.
 297  *
 298  * Returns 0 for failure to parse correctly, else the idx position of where
 299  * it found the last token.
 300  */
 301 int bgp_vty_find_and_parse_afi_safi_bgp(struct vty *vty,
 302                                         struct cmd_token **argv, int argc,
 303                                         int *idx, afi_t *afi, safi_t *safi,
 304                                         struct bgp **bgp, bool use_json)
 305 {
 306         char *vrf_name = NULL;
 307
 308         assert(afi);
 309         assert(safi);
 310         assert(bgp);
 311
 312         if (argv_find(argv, argc, "ip", idx))
 313                 *afi = AFI_IP;
 314
 315         if (argv_find(argv, argc, "view", idx))
 316                 vrf_name = argv[*idx + 1]->arg;
 317         else if (argv_find(argv, argc, "vrf", idx)) {
 318                 vrf_name = argv[*idx + 1]->arg;
 319                 if (strmatch(vrf_name, VRF_DEFAULT_NAME))
 320                         vrf_name = NULL;
 321         }
 322         if (vrf_name) {
 323                 if (strmatch(vrf_name, "all"))
 324                         *bgp = NULL;
 325                 else {
 326                         *bgp = bgp_lookup_by_name(vrf_name);
 327                         if (!*bgp) {
 328                                 if (use_json)
 329                                         vty_out(vty, "{}\n");
 330                                 else
 331                                         vty_out(vty, "View/Vrf %s is unknown\n",
 332                                                 vrf_name);
 333                                 *idx = 0;
 334                                 return 0;
 335                         }
 336                 }
 337         } else {
 338                 *bgp = bgp_get_default();
 339                 if (!*bgp) {
 340                         if (use_json)
 341                                 vty_out(vty, "{}\n");
 342                         else
 343                                 vty_out(vty,
 344                                         "Default BGP instance not found\n");
 345                         *idx = 0;
 346                         return 0;
 347                 }
 348         }
 349
 350         if (argv_find_and_parse_afi(argv, argc, idx, afi))
 351                 argv_find_and_parse_safi(argv, argc, idx, safi);
 352
 353         *idx += 1;
 354         return *idx;
 355 }
 356
 357 static int peer_address_self_check(struct bgp *bgp, union sockunion *su)
 358 {
 359         struct interface *ifp = NULL;
 360
 361         if (su->sa.sa_family == AF_INET)
 362                 ifp = if_lookup_by_ipv4_exact(&su->sin.sin_addr, bgp->vrf_id);
 363         else if (su->sa.sa_family == AF_INET6)
 364                 ifp = if_lookup_by_ipv6_exact(&su->sin6.sin6_addr,
 365                                               su->sin6.sin6_scope_id,
 366                                               bgp->vrf_id);
 367
 368         if (ifp)
 369                 return 1;
 370
 371         return 0;
 372 }
 373
 374 /* Utility function for looking up peer from VTY.  */
 375 /* This is used only for configuration, so disallow if attempted on
 376  * a dynamic neighbor.
 377  */
 378 static struct peer *peer_lookup_vty(struct vty *vty, const char *ip_str)
 379 {
 380         struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 381         int ret;
 382         union sockunion su;
 383         struct peer *peer;
 384
 385         if (!bgp) {
 386                 return NULL;
 387         }
 388
 389         ret = str2sockunion(ip_str, &su);
 390         if (ret < 0) {
 391                 peer = peer_lookup_by_conf_if(bgp, ip_str);
 392                 if (!peer) {
 393                         if ((peer = peer_lookup_by_hostname(bgp, ip_str))
 394                             == NULL) {
 395                                 vty_out(vty,
 396                                         "%% Malformed address or name: %s\n",
 397                                         ip_str);
 398                                 return NULL;
 399                         }
 400                 }
 401         } else {
 402                 peer = peer_lookup(bgp, &su);
 403                 if (!peer) {
 404                         vty_out(vty,
 405                                 "%% Specify remote-as or peer-group commands first\n");
 406                         return NULL;
 407                 }
 408                 if (peer_dynamic_neighbor(peer)) {
 409                         vty_out(vty,
 410                                 "%% Operation not allowed on a dynamic neighbor\n");
 411                         return NULL;
 412                 }
 413         }
 414         return peer;
 415 }
 416
 417 /* Utility function for looking up peer or peer group.  */
 418 /* This is used only for configuration, so disallow if attempted on
 419  * a dynamic neighbor.
 420  */
 421 struct peer *peer_and_group_lookup_vty(struct vty *vty, const char *peer_str)
 422 {
 423         struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 424         int ret;
 425         union sockunion su;
 426         struct peer *peer = NULL;
 427         struct peer_group *group = NULL;
 428
 429         if (!bgp) {
 430                 return NULL;
 431         }
 432
 433         ret = str2sockunion(peer_str, &su);
 434         if (ret == 0) {
 435                 /* IP address, locate peer. */
 436                 peer = peer_lookup(bgp, &su);
 437         } else {
 438                 /* Not IP, could match either peer configured on interface or a
 439                  * group. */
 440                 peer = peer_lookup_by_conf_if(bgp, peer_str);
 441                 if (!peer)
 442                         group = peer_group_lookup(bgp, peer_str);
 443         }
 444
 445         if (peer) {
 446                 if (peer_dynamic_neighbor(peer)) {
 447                         vty_out(vty,
 448                                 "%% Operation not allowed on a dynamic neighbor\n");
 449                         return NULL;
 450                 }
 451
 452                 return peer;
 453         }
 454
 455         if (group)
 456                 return group->conf;
 457
 458         vty_out(vty, "%% Specify remote-as or peer-group commands first\n");
 459
 460         return NULL;
 461 }
 462
 463 int bgp_vty_return(struct vty *vty, int ret)
 464 {
 465         const char *str = NULL;
 466
 467         switch (ret) {
 468         case BGP_ERR_INVALID_VALUE:
 469                 str = "Invalid value";
 470                 break;
 471         case BGP_ERR_INVALID_FLAG:
 472                 str = "Invalid flag";
 473                 break;
 474         case BGP_ERR_PEER_GROUP_SHUTDOWN:
 475                 str = "Peer-group has been shutdown. Activate the peer-group first";
 476                 break;
 477         case BGP_ERR_PEER_FLAG_CONFLICT:
 478                 str = "Can't set override-capability and strict-capability-match at the same time";
 479                 break;
 480         case BGP_ERR_PEER_GROUP_NO_REMOTE_AS:
 481                 str = "Specify remote-as or peer-group remote AS first";
 482                 break;
 483         case BGP_ERR_PEER_GROUP_CANT_CHANGE:
 484                 str = "Cannot change the peer-group. Deconfigure first";
 485                 break;
 486         case BGP_ERR_PEER_GROUP_MISMATCH:
 487                 str = "Peer is not a member of this peer-group";
 488                 break;
 489         case BGP_ERR_PEER_FILTER_CONFLICT:
 490                 str = "Prefix/distribute list can not co-exist";
 491                 break;
 492         case BGP_ERR_NOT_INTERNAL_PEER:
 493                 str = "Invalid command. Not an internal neighbor";
 494                 break;
 495         case BGP_ERR_REMOVE_PRIVATE_AS:
 496                 str = "remove-private-AS cannot be configured for IBGP peers";
 497                 break;
 498         case BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP:
 499                 str = "Local-AS allowed only for EBGP peers";
 500                 break;
 501         case BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS:
 502                 str = "Cannot have local-as same as BGP AS number";
 503                 break;
 504         case BGP_ERR_TCPSIG_FAILED:
 505                 str = "Error while applying TCP-Sig to session(s)";
 506                 break;
 507         case BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK:
 508                 str = "ebgp-multihop and ttl-security cannot be configured together";
 509                 break;
 510         case BGP_ERR_NO_IBGP_WITH_TTLHACK:
 511                 str = "ttl-security only allowed for EBGP peers";
 512                 break;
 513         case BGP_ERR_AS_OVERRIDE:
 514                 str = "as-override cannot be configured for IBGP peers";
 515                 break;
 516         case BGP_ERR_INVALID_DYNAMIC_NEIGHBORS_LIMIT:
 517                 str = "Invalid limit for number of dynamic neighbors";
 518                 break;
 519         case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_EXISTS:
 520                 str = "Dynamic neighbor listen range already exists";
 521                 break;
 522         case BGP_ERR_INVALID_FOR_DYNAMIC_PEER:
 523                 str = "Operation not allowed on a dynamic neighbor";
 524                 break;
 525         case BGP_ERR_INVALID_FOR_DIRECT_PEER:
 526                 str = "Operation not allowed on a directly connected neighbor";
 527                 break;
 528         case BGP_ERR_PEER_SAFI_CONFLICT:
 529                 str = "Cannot activate peer for both 'ipv4 unicast' and 'ipv4 labeled-unicast'";
 530                 break;
 531         }
 532         if (str) {
 533                 vty_out(vty, "%% %s\n", str);
 534                 return CMD_WARNING_CONFIG_FAILED;
 535         }
 536         return CMD_SUCCESS;
 537 }
 538
 539 /* BGP clear sort. */
 540 enum clear_sort {
 541         clear_all,
 542         clear_peer,
 543         clear_group,
 544         clear_external,
 545         clear_as
 546 };
 547
 548 static void bgp_clear_vty_error(struct vty *vty, struct peer *peer, afi_t afi,
 549                                 safi_t safi, int error)
 550 {
 551         switch (error) {
 552         case BGP_ERR_AF_UNCONFIGURED:
 553                 vty_out(vty,
 554                         "%%BGP: Enable %s address family for the neighbor %s\n",
 555                         afi_safi_print(afi, safi), peer->host);
 556                 break;
 557         case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
 558                 vty_out(vty,
 559                         "%%BGP: Inbound soft reconfig for %s not possible as it\n      has neither refresh capability, nor inbound soft reconfig\n",
 560                         peer->host);
 561                 break;
 562         default:
 563                 break;
 564         }
 565 }
 566
 567 /* `clear ip bgp' functions. */
 568 static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
 569                      enum clear_sort sort, enum bgp_clear_type stype,
 570                      const char *arg)
 571 {
 572         int ret;
 573         bool found = false;
 574         struct peer *peer;
 575         struct listnode *node, *nnode;
 576
 577         /* Clear all neighbors. */
 578         /*
 579          * Pass along pointer to next node to peer_clear() when walking all
 580          * nodes on the BGP instance as that may get freed if it is a
 581          * doppelganger
 582          */
 583         if (sort == clear_all) {
 584                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 585                         if (!peer->afc[afi][safi])
 586                                 continue;
 587
 588                         if (stype == BGP_CLEAR_SOFT_NONE)
 589                                 ret = peer_clear(peer, &nnode);
 590                         else
 591                                 ret = peer_clear_soft(peer, afi, safi, stype);
 592
 593                         if (ret < 0)
 594                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 595                         else
 596                                 found = true;
 597                 }
 598
 599                 /* This is to apply read-only mode on this clear. */
 600                 if (stype == BGP_CLEAR_SOFT_NONE)
 601                         bgp->update_delay_over = 0;
 602
 603                 if (!found)
 604                         vty_out(vty, "%%BGP: No %s peer configured",
 605                                 afi_safi_print(afi, safi));
 606
 607                 return CMD_SUCCESS;
 608         }
 609
 610         /* Clear specified neighbor. */
 611         if (sort == clear_peer) {
 612                 union sockunion su;
 613
 614                 /* Make sockunion for lookup. */
 615                 ret = str2sockunion(arg, &su);
 616                 if (ret < 0) {
 617                         peer = peer_lookup_by_conf_if(bgp, arg);
 618                         if (!peer) {
 619                                 peer = peer_lookup_by_hostname(bgp, arg);
 620                                 if (!peer) {
 621                                         vty_out(vty,
 622                                                 "Malformed address or name: %s\n",
 623                                                 arg);
 624                                         return CMD_WARNING;
 625                                 }
 626                         }
 627                 } else {
 628                         peer = peer_lookup(bgp, &su);
 629                         if (!peer) {
 630                                 vty_out(vty,
 631                                         "%%BGP: Unknown neighbor - \"%s\"\n",
 632                                         arg);
 633                                 return CMD_WARNING;
 634                         }
 635                 }
 636
 637                 if (!peer->afc[afi][safi])
 638                         ret = BGP_ERR_AF_UNCONFIGURED;
 639                 else if (stype == BGP_CLEAR_SOFT_NONE)
 640                         ret = peer_clear(peer, NULL);
 641                 else
 642                         ret = peer_clear_soft(peer, afi, safi, stype);
 643
 644                 if (ret < 0)
 645                         bgp_clear_vty_error(vty, peer, afi, safi, ret);
 646
 647                 return CMD_SUCCESS;
 648         }
 649
 650         /* Clear all neighbors belonging to a specific peer-group. */
 651         if (sort == clear_group) {
 652                 struct peer_group *group;
 653
 654                 group = peer_group_lookup(bgp, arg);
 655                 if (!group) {
 656                         vty_out(vty, "%%BGP: No such peer-group %s\n", arg);
 657                         return CMD_WARNING;
 658                 }
 659
 660                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
 661                         if (!peer->afc[afi][safi])
 662                                 continue;
 663
 664                         if (stype == BGP_CLEAR_SOFT_NONE)
 665                                 ret = peer_clear(peer, NULL);
 666                         else
 667                                 ret = peer_clear_soft(peer, afi, safi, stype);
 668
 669                         if (ret < 0)
 670                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 671                         else
 672                                 found = true;
 673                 }
 674
 675                 if (!found)
 676                         vty_out(vty,
 677                                 "%%BGP: No %s peer belonging to peer-group %s is configured\n",
 678                                 afi_safi_print(afi, safi), arg);
 679
 680                 return CMD_SUCCESS;
 681         }
 682
 683         /* Clear all external (eBGP) neighbors. */
 684         if (sort == clear_external) {
 685                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 686                         if (peer->sort == BGP_PEER_IBGP)
 687                                 continue;
 688
 689                         if (!peer->afc[afi][safi])
 690                                 continue;
 691
 692                         if (stype == BGP_CLEAR_SOFT_NONE)
 693                                 ret = peer_clear(peer, &nnode);
 694                         else
 695                                 ret = peer_clear_soft(peer, afi, safi, stype);
 696
 697                         if (ret < 0)
 698                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 699                         else
 700                                 found = true;
 701                 }
 702
 703                 if (!found)
 704                         vty_out(vty,
 705                                 "%%BGP: No external %s peer is configured\n",
 706                                 afi_safi_print(afi, safi));
 707
 708                 return CMD_SUCCESS;
 709         }
 710
 711         /* Clear all neighbors belonging to a specific AS. */
 712         if (sort == clear_as) {
 713                 as_t as = strtoul(arg, NULL, 10);
 714
 715                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 716                         if (peer->as != as)
 717                                 continue;
 718
 719                         if (!peer->afc[afi][safi])
 720                                 ret = BGP_ERR_AF_UNCONFIGURED;
 721                         else if (stype == BGP_CLEAR_SOFT_NONE)
 722                                 ret = peer_clear(peer, &nnode);
 723                         else
 724                                 ret = peer_clear_soft(peer, afi, safi, stype);
 725
 726                         if (ret < 0)
 727                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 728                         else
 729                                 found = true;
 730                 }
 731
 732                 if (!found)
 733                         vty_out(vty,
 734                                 "%%BGP: No %s peer is configured with AS %s\n",
 735                                 afi_safi_print(afi, safi), arg);
 736
 737                 return CMD_SUCCESS;
 738         }
 739
 740         return CMD_SUCCESS;
 741 }
 742
 743 static int bgp_clear_vty(struct vty *vty, const char *name, afi_t afi,
 744                          safi_t safi, enum clear_sort sort,
 745                          enum bgp_clear_type stype, const char *arg)
 746 {
 747         struct bgp *bgp;
 748
 749         /* BGP structure lookup. */
 750         if (name) {
 751                 bgp = bgp_lookup_by_name(name);
 752                 if (bgp == NULL) {
 753                         vty_out(vty, "Can't find BGP instance %s\n", name);
 754                         return CMD_WARNING;
 755                 }
 756         } else {
 757                 bgp = bgp_get_default();
 758                 if (bgp == NULL) {
 759                         vty_out(vty, "No BGP process is configured\n");
 760                         return CMD_WARNING;
 761                 }
 762         }
 763
 764         return bgp_clear(vty, bgp, afi, safi, sort, stype, arg);
 765 }
 766
 767 /* clear soft inbound */
 768 static void bgp_clear_star_soft_in(struct vty *vty, const char *name)
 769 {
 770         bgp_clear_vty(vty, name, AFI_IP, SAFI_UNICAST, clear_all,
 771                       BGP_CLEAR_SOFT_IN, NULL);
 772         bgp_clear_vty(vty, name, AFI_IP6, SAFI_UNICAST, clear_all,
 773                       BGP_CLEAR_SOFT_IN, NULL);
 774 }
 775
 776 /* clear soft outbound */
 777 static void bgp_clear_star_soft_out(struct vty *vty, const char *name)
 778 {
 779         bgp_clear_vty(vty, name, AFI_IP, SAFI_UNICAST, clear_all,
 780                       BGP_CLEAR_SOFT_OUT, NULL);
 781         bgp_clear_vty(vty, name, AFI_IP6, SAFI_UNICAST, clear_all,
 782                       BGP_CLEAR_SOFT_OUT, NULL);
 783 }
 784
 785
 786 #ifndef VTYSH_EXTRACT_PL
 787 #include "bgpd/bgp_vty_clippy.c"
 788 #endif
 789
 790 /* BGP global configuration.  */
 791 #if (CONFDATE > 20190601)
 792 CPP_NOTICE("bgpd: time to remove deprecated bgp multiple-instance")
 793 CPP_NOTICE("This includes BGP_OPT_MULTIPLE_INSTANCE")
 794 #endif
 795 DEFUN_HIDDEN (bgp_multiple_instance_func,
 796               bgp_multiple_instance_cmd,
 797               "bgp multiple-instance",
 798               BGP_STR
 799               "Enable bgp multiple instance\n")
 800 {
 801         bgp_option_set(BGP_OPT_MULTIPLE_INSTANCE);
 802         return CMD_SUCCESS;
 803 }
 804
 805 DEFUN_HIDDEN (no_bgp_multiple_instance,
 806        no_bgp_multiple_instance_cmd,
 807        "no bgp multiple-instance",
 808        NO_STR
 809        BGP_STR
 810        "BGP multiple instance\n")
 811 {
 812         int ret;
 813
 814         vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
 815         vty_out(vty, "if you are using this please let the developers know\n");
 816         zlog_info("Deprecated option: `bgp multiple-instance` being used");
 817         ret = bgp_option_unset(BGP_OPT_MULTIPLE_INSTANCE);
 818         if (ret < 0) {
 819                 vty_out(vty, "%% There are more than two BGP instances\n");
 820                 return CMD_WARNING_CONFIG_FAILED;
 821         }
 822         return CMD_SUCCESS;
 823 }
 824
 825 #if (CONFDATE > 20190601)
 826 CPP_NOTICE("bgpd: time to remove deprecated cli bgp config-type cisco")
 827 CPP_NOTICE("This includes BGP_OPT_CISCO_CONFIG")
 828 #endif
 829 DEFUN_HIDDEN (bgp_config_type,
 830               bgp_config_type_cmd,
 831               "bgp config-type <cisco|zebra>",
 832               BGP_STR
 833               "Configuration type\n"
 834               "cisco\n"
 835               "zebra\n")
 836 {
 837         int idx = 0;
 838         if (argv_find(argv, argc, "cisco", &idx)) {
 839                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
 840                 vty_out(vty, "if you are using this please let the developers know!\n");
 841                 zlog_info("Deprecated option: `bgp config-type cisco` being used");
 842                 bgp_option_set(BGP_OPT_CONFIG_CISCO);
 843         } else
 844                 bgp_option_unset(BGP_OPT_CONFIG_CISCO);
 845
 846         return CMD_SUCCESS;
 847 }
 848
 849 DEFUN_HIDDEN (no_bgp_config_type,
 850               no_bgp_config_type_cmd,
 851               "no bgp config-type [<cisco|zebra>]",
 852               NO_STR
 853               BGP_STR
 854               "Display configuration type\n"
 855               "cisco\n"
 856               "zebra\n")
 857 {
 858         bgp_option_unset(BGP_OPT_CONFIG_CISCO);
 859         return CMD_SUCCESS;
 860 }
 861
 862
 863 DEFUN (no_synchronization,
 864        no_synchronization_cmd,
 865        "no synchronization",
 866        NO_STR
 867        "Perform IGP synchronization\n")
 868 {
 869         return CMD_SUCCESS;
 870 }
 871
 872 DEFUN (no_auto_summary,
 873        no_auto_summary_cmd,
 874        "no auto-summary",
 875        NO_STR
 876        "Enable automatic network number summarization\n")
 877 {
 878         return CMD_SUCCESS;
 879 }
 880
 881 /* "router bgp" commands. */
 882 DEFUN_NOSH (router_bgp,
 883        router_bgp_cmd,
 884        "router bgp [(1-4294967295) [<view|vrf> VIEWVRFNAME]]",
 885        ROUTER_STR
 886        BGP_STR
 887        AS_STR
 888        BGP_INSTANCE_HELP_STR)
 889 {
 890         int idx_asn = 2;
 891         int idx_view_vrf = 3;
 892         int idx_vrf = 4;
 893         int ret;
 894         as_t as;
 895         struct bgp *bgp;
 896         const char *name = NULL;
 897         enum bgp_instance_type inst_type;
 898
 899         // "router bgp" without an ASN
 900         if (argc == 2) {
 901                 // Pending: Make VRF option available for ASN less config
 902                 bgp = bgp_get_default();
 903
 904                 if (bgp == NULL) {
 905                         vty_out(vty, "%% No BGP process is configured\n");
 906                         return CMD_WARNING_CONFIG_FAILED;
 907                 }
 908
 909                 if (listcount(bm->bgp) > 1) {
 910                         vty_out(vty, "%% Please specify ASN and VRF\n");
 911                         return CMD_WARNING_CONFIG_FAILED;
 912                 }
 913         }
 914
 915         // "router bgp X"
 916         else {
 917                 as = strtoul(argv[idx_asn]->arg, NULL, 10);
 918
 919                 inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 920                 if (argc > 3) {
 921                         name = argv[idx_vrf]->arg;
 922
 923                         if (!strcmp(argv[idx_view_vrf]->text, "vrf")) {
 924                                 if (strmatch(name, VRF_DEFAULT_NAME))
 925                                         name = NULL;
 926                                 else
 927                                         inst_type = BGP_INSTANCE_TYPE_VRF;
 928                         } else if (!strcmp(argv[idx_view_vrf]->text, "view"))
 929                                 inst_type = BGP_INSTANCE_TYPE_VIEW;
 930                 }
 931
 932                 ret = bgp_get(&bgp, &as, name, inst_type);
 933                 switch (ret) {
 934                 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET:
 935                         vty_out(vty,
 936                                 "Please specify 'bgp multiple-instance' first\n");
 937                         return CMD_WARNING_CONFIG_FAILED;
 938                 case BGP_ERR_AS_MISMATCH:
 939                         vty_out(vty, "BGP is already running; AS is %u\n", as);
 940                         return CMD_WARNING_CONFIG_FAILED;
 941                 case BGP_ERR_INSTANCE_MISMATCH:
 942                         vty_out(vty,
 943                                 "BGP instance name and AS number mismatch\n");
 944                         vty_out(vty,
 945                                 "BGP instance is already running; AS is %u\n",
 946                                 as);
 947                         return CMD_WARNING_CONFIG_FAILED;
 948                 }
 949
 950                 /*
 951                  * If we just instantiated the default instance, complete
 952                  * any pending VRF-VPN leaking that was configured via
 953                  * earlier "router bgp X vrf FOO" blocks.
 954                  */
 955                 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 956                         vpn_leak_postchange_all();
 957
 958                 /* Pending: handle when user tries to change a view to vrf n vv.
 959                  */
 960         }
 961
 962         /* unset the auto created flag as the user config is now present */
 963         UNSET_FLAG(bgp->vrf_flags, BGP_VRF_AUTO);
 964         VTY_PUSH_CONTEXT(BGP_NODE, bgp);
 965
 966         return CMD_SUCCESS;
 967 }
 968
 969 /* "no router bgp" commands. */
 970 DEFUN (no_router_bgp,
 971        no_router_bgp_cmd,
 972        "no router bgp [(1-4294967295) [<view|vrf> VIEWVRFNAME]]",
 973        NO_STR
 974        ROUTER_STR
 975        BGP_STR
 976        AS_STR
 977        BGP_INSTANCE_HELP_STR)
 978 {
 979         int idx_asn = 3;
 980         int idx_vrf = 5;
 981         as_t as;
 982         struct bgp *bgp;
 983         const char *name = NULL;
 984
 985         // "no router bgp" without an ASN
 986         if (argc == 3) {
 987                 // Pending: Make VRF option available for ASN less config
 988                 bgp = bgp_get_default();
 989
 990                 if (bgp == NULL) {
 991                         vty_out(vty, "%% No BGP process is configured\n");
 992                         return CMD_WARNING_CONFIG_FAILED;
 993                 }
 994
 995                 if (listcount(bm->bgp) > 1) {
 996                         vty_out(vty, "%% Please specify ASN and VRF\n");
 997                         return CMD_WARNING_CONFIG_FAILED;
 998                 }
 999
1000                 if (bgp->l3vni) {
1001                         vty_out(vty, "%% Please unconfigure l3vni %u",
1002                                 bgp->l3vni);
1003                         return CMD_WARNING_CONFIG_FAILED;
1004                 }
1005         } else {
1006                 as = strtoul(argv[idx_asn]->arg, NULL, 10);
1007
1008                 if (argc > 4)
1009                         name = argv[idx_vrf]->arg;
1010
1011                 /* Lookup bgp structure. */
1012                 bgp = bgp_lookup(as, name);
1013                 if (!bgp) {
1014                         vty_out(vty, "%% Can't find BGP instance\n");
1015                         return CMD_WARNING_CONFIG_FAILED;
1016                 }
1017
1018                 if (bgp->l3vni) {
1019                         vty_out(vty, "%% Please unconfigure l3vni %u",
1020                                 bgp->l3vni);
1021                         return CMD_WARNING_CONFIG_FAILED;
1022                 }
1023         }
1024
1025         bgp_delete(bgp);
1026
1027         return CMD_SUCCESS;
1028 }
1029
1030
1031 /* BGP router-id.  */
1032
1033 DEFPY (bgp_router_id,
1034        bgp_router_id_cmd,
1035        "bgp router-id A.B.C.D",
1036        BGP_STR
1037        "Override configured router identifier\n"
1038        "Manually configured router identifier\n")
1039 {
1040         VTY_DECLVAR_CONTEXT(bgp, bgp);
1041         bgp_router_id_static_set(bgp, router_id);
1042         return CMD_SUCCESS;
1043 }
1044
1045 DEFPY (no_bgp_router_id,
1046        no_bgp_router_id_cmd,
1047        "no bgp router-id [A.B.C.D]",
1048        NO_STR
1049        BGP_STR
1050        "Override configured router identifier\n"
1051        "Manually configured router identifier\n")
1052 {
1053         VTY_DECLVAR_CONTEXT(bgp, bgp);
1054
1055         if (router_id_str) {
1056                 if (!IPV4_ADDR_SAME(&bgp->router_id_static, &router_id)) {
1057                         vty_out(vty, "%% BGP router-id doesn't match\n");
1058                         return CMD_WARNING_CONFIG_FAILED;
1059                 }
1060         }
1061
1062         router_id.s_addr = 0;
1063         bgp_router_id_static_set(bgp, router_id);
1064
1065         return CMD_SUCCESS;
1066 }
1067
1068
1069 /* BGP Cluster ID.  */
1070 DEFUN (bgp_cluster_id,
1071        bgp_cluster_id_cmd,
1072        "bgp cluster-id <A.B.C.D|(1-4294967295)>",
1073        BGP_STR
1074        "Configure Route-Reflector Cluster-id\n"
1075        "Route-Reflector Cluster-id in IP address format\n"
1076        "Route-Reflector Cluster-id as 32 bit quantity\n")
1077 {
1078         VTY_DECLVAR_CONTEXT(bgp, bgp);
1079         int idx_ipv4 = 2;
1080         int ret;
1081         struct in_addr cluster;
1082
1083         ret = inet_aton(argv[idx_ipv4]->arg, &cluster);
1084         if (!ret) {
1085                 vty_out(vty, "%% Malformed bgp cluster identifier\n");
1086                 return CMD_WARNING_CONFIG_FAILED;
1087         }
1088
1089         bgp_cluster_id_set(bgp, &cluster);
1090         bgp_clear_star_soft_out(vty, bgp->name);
1091
1092         return CMD_SUCCESS;
1093 }
1094
1095 DEFUN (no_bgp_cluster_id,
1096        no_bgp_cluster_id_cmd,
1097        "no bgp cluster-id [<A.B.C.D|(1-4294967295)>]",
1098        NO_STR
1099        BGP_STR
1100        "Configure Route-Reflector Cluster-id\n"
1101        "Route-Reflector Cluster-id in IP address format\n"
1102        "Route-Reflector Cluster-id as 32 bit quantity\n")
1103 {
1104         VTY_DECLVAR_CONTEXT(bgp, bgp);
1105         bgp_cluster_id_unset(bgp);
1106         bgp_clear_star_soft_out(vty, bgp->name);
1107
1108         return CMD_SUCCESS;
1109 }
1110
1111 DEFUN (bgp_confederation_identifier,
1112        bgp_confederation_identifier_cmd,
1113        "bgp confederation identifier (1-4294967295)",
1114        "BGP specific commands\n"
1115        "AS confederation parameters\n"
1116        "AS number\n"
1117        "Set routing domain confederation AS\n")
1118 {
1119         VTY_DECLVAR_CONTEXT(bgp, bgp);
1120         int idx_number = 3;
1121         as_t as;
1122
1123         as = strtoul(argv[idx_number]->arg, NULL, 10);
1124
1125         bgp_confederation_id_set(bgp, as);
1126
1127         return CMD_SUCCESS;
1128 }
1129
1130 DEFUN (no_bgp_confederation_identifier,
1131        no_bgp_confederation_identifier_cmd,
1132        "no bgp confederation identifier [(1-4294967295)]",
1133        NO_STR
1134        "BGP specific commands\n"
1135        "AS confederation parameters\n"
1136        "AS number\n"
1137        "Set routing domain confederation AS\n")
1138 {
1139         VTY_DECLVAR_CONTEXT(bgp, bgp);
1140         bgp_confederation_id_unset(bgp);
1141
1142         return CMD_SUCCESS;
1143 }
1144
1145 DEFUN (bgp_confederation_peers,
1146        bgp_confederation_peers_cmd,
1147        "bgp confederation peers (1-4294967295)...",
1148        "BGP specific commands\n"
1149        "AS confederation parameters\n"
1150        "Peer ASs in BGP confederation\n"
1151        AS_STR)
1152 {
1153         VTY_DECLVAR_CONTEXT(bgp, bgp);
1154         int idx_asn = 3;
1155         as_t as;
1156         int i;
1157
1158         for (i = idx_asn; i < argc; i++) {
1159                 as = strtoul(argv[i]->arg, NULL, 10);
1160
1161                 if (bgp->as == as) {
1162                         vty_out(vty,
1163                                 "%% Local member-AS not allowed in confed peer list\n");
1164                         continue;
1165                 }
1166
1167                 bgp_confederation_peers_add(bgp, as);
1168         }
1169         return CMD_SUCCESS;
1170 }
1171
1172 DEFUN (no_bgp_confederation_peers,
1173        no_bgp_confederation_peers_cmd,
1174        "no bgp confederation peers (1-4294967295)...",
1175        NO_STR
1176        "BGP specific commands\n"
1177        "AS confederation parameters\n"
1178        "Peer ASs in BGP confederation\n"
1179        AS_STR)
1180 {
1181         VTY_DECLVAR_CONTEXT(bgp, bgp);
1182         int idx_asn = 4;
1183         as_t as;
1184         int i;
1185
1186         for (i = idx_asn; i < argc; i++) {
1187                 as = strtoul(argv[i]->arg, NULL, 10);
1188
1189                 bgp_confederation_peers_remove(bgp, as);
1190         }
1191         return CMD_SUCCESS;
1192 }
1193
1194 /**
1195  * Central routine for maximum-paths configuration.
1196  * @peer_type: BGP_PEER_EBGP or BGP_PEER_IBGP
1197  * @set: 1 for setting values, 0 for removing the max-paths config.
1198  */
1199 static int bgp_maxpaths_config_vty(struct vty *vty, int peer_type,
1200                                    const char *mpaths, uint16_t options,
1201                                    int set)
1202 {
1203         VTY_DECLVAR_CONTEXT(bgp, bgp);
1204         uint16_t maxpaths = 0;
1205         int ret;
1206         afi_t afi;
1207         safi_t safi;
1208
1209         afi = bgp_node_afi(vty);
1210         safi = bgp_node_safi(vty);
1211
1212         if (set) {
1213                 maxpaths = strtol(mpaths, NULL, 10);
1214                 if (maxpaths > multipath_num) {
1215                         vty_out(vty,
1216                                 "%% Maxpaths Specified: %d is > than multipath num specified on bgp command line %d",
1217                                 maxpaths, multipath_num);
1218                         return CMD_WARNING_CONFIG_FAILED;
1219                 }
1220                 ret = bgp_maximum_paths_set(bgp, afi, safi, peer_type, maxpaths,
1221                                             options);
1222         } else
1223                 ret = bgp_maximum_paths_unset(bgp, afi, safi, peer_type);
1224
1225         if (ret < 0) {
1226                 vty_out(vty,
1227                         "%% Failed to %sset maximum-paths %s %u for afi %u, safi %u\n",
1228                         (set == 1) ? "" : "un",
1229                         (peer_type == BGP_PEER_EBGP) ? "ebgp" : "ibgp",
1230                         maxpaths, afi, safi);
1231                 return CMD_WARNING_CONFIG_FAILED;
1232         }
1233
1234         bgp_recalculate_all_bestpaths(bgp);
1235
1236         return CMD_SUCCESS;
1237 }
1238
1239 DEFUN (bgp_maxmed_admin,
1240        bgp_maxmed_admin_cmd,
1241        "bgp max-med administrative ",
1242        BGP_STR
1243        "Advertise routes with max-med\n"
1244        "Administratively applied, for an indefinite period\n")
1245 {
1246         VTY_DECLVAR_CONTEXT(bgp, bgp);
1247
1248         bgp->v_maxmed_admin = 1;
1249         bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1250
1251         bgp_maxmed_update(bgp);
1252
1253         return CMD_SUCCESS;
1254 }
1255
1256 DEFUN (bgp_maxmed_admin_medv,
1257        bgp_maxmed_admin_medv_cmd,
1258        "bgp max-med administrative (0-4294967295)",
1259        BGP_STR
1260        "Advertise routes with max-med\n"
1261        "Administratively applied, for an indefinite period\n"
1262        "Max MED value to be used\n")
1263 {
1264         VTY_DECLVAR_CONTEXT(bgp, bgp);
1265         int idx_number = 3;
1266
1267         bgp->v_maxmed_admin = 1;
1268         bgp->maxmed_admin_value = strtoul(argv[idx_number]->arg, NULL, 10);
1269
1270         bgp_maxmed_update(bgp);
1271
1272         return CMD_SUCCESS;
1273 }
1274
1275 DEFUN (no_bgp_maxmed_admin,
1276        no_bgp_maxmed_admin_cmd,
1277        "no bgp max-med administrative [(0-4294967295)]",
1278        NO_STR
1279        BGP_STR
1280        "Advertise routes with max-med\n"
1281        "Administratively applied, for an indefinite period\n"
1282        "Max MED value to be used\n")
1283 {
1284         VTY_DECLVAR_CONTEXT(bgp, bgp);
1285         bgp->v_maxmed_admin = BGP_MAXMED_ADMIN_UNCONFIGURED;
1286         bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1287         bgp_maxmed_update(bgp);
1288
1289         return CMD_SUCCESS;
1290 }
1291
1292 DEFUN (bgp_maxmed_onstartup,
1293        bgp_maxmed_onstartup_cmd,
1294        "bgp max-med on-startup (5-86400) [(0-4294967295)]",
1295        BGP_STR
1296        "Advertise routes with max-med\n"
1297        "Effective on a startup\n"
1298        "Time (seconds) period for max-med\n"
1299        "Max MED value to be used\n")
1300 {
1301         VTY_DECLVAR_CONTEXT(bgp, bgp);
1302         int idx = 0;
1303
1304         argv_find(argv, argc, "(5-86400)", &idx);
1305         bgp->v_maxmed_onstartup = strtoul(argv[idx]->arg, NULL, 10);
1306         if (argv_find(argv, argc, "(0-4294967295)", &idx))
1307                 bgp->maxmed_onstartup_value = strtoul(argv[idx]->arg, NULL, 10);
1308         else
1309                 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1310
1311         bgp_maxmed_update(bgp);
1312
1313         return CMD_SUCCESS;
1314 }
1315
1316 DEFUN (no_bgp_maxmed_onstartup,
1317        no_bgp_maxmed_onstartup_cmd,
1318        "no bgp max-med on-startup [(5-86400) [(0-4294967295)]]",
1319        NO_STR
1320        BGP_STR
1321        "Advertise routes with max-med\n"
1322        "Effective on a startup\n"
1323        "Time (seconds) period for max-med\n"
1324        "Max MED value to be used\n")
1325 {
1326         VTY_DECLVAR_CONTEXT(bgp, bgp);
1327
1328         /* Cancel max-med onstartup if its on */
1329         if (bgp->t_maxmed_onstartup) {
1330                 THREAD_TIMER_OFF(bgp->t_maxmed_onstartup);
1331                 bgp->maxmed_onstartup_over = 1;
1332         }
1333
1334         bgp->v_maxmed_onstartup = BGP_MAXMED_ONSTARTUP_UNCONFIGURED;
1335         bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1336
1337         bgp_maxmed_update(bgp);
1338
1339         return CMD_SUCCESS;
1340 }
1341
1342 static int bgp_update_delay_config_vty(struct vty *vty, const char *delay,
1343                                        const char *wait)
1344 {
1345         VTY_DECLVAR_CONTEXT(bgp, bgp);
1346         uint16_t update_delay;
1347         uint16_t establish_wait;
1348
1349         update_delay = strtoul(delay, NULL, 10);
1350
1351         if (!wait) /* update-delay <delay> */
1352         {
1353                 bgp->v_update_delay = update_delay;
1354                 bgp->v_establish_wait = bgp->v_update_delay;
1355                 return CMD_SUCCESS;
1356         }
1357
1358         /* update-delay <delay> <establish-wait> */
1359         establish_wait = atoi(wait);
1360         if (update_delay < establish_wait) {
1361                 vty_out(vty,
1362                         "%%Failed: update-delay less than the establish-wait!\n");
1363                 return CMD_WARNING_CONFIG_FAILED;
1364         }
1365
1366         bgp->v_update_delay = update_delay;
1367         bgp->v_establish_wait = establish_wait;
1368
1369         return CMD_SUCCESS;
1370 }
1371
1372 static int bgp_update_delay_deconfig_vty(struct vty *vty)
1373 {
1374         VTY_DECLVAR_CONTEXT(bgp, bgp);
1375
1376         bgp->v_update_delay = BGP_UPDATE_DELAY_DEF;
1377         bgp->v_establish_wait = bgp->v_update_delay;
1378
1379         return CMD_SUCCESS;
1380 }
1381
1382 void bgp_config_write_update_delay(struct vty *vty, struct bgp *bgp)
1383 {
1384         if (bgp->v_update_delay != BGP_UPDATE_DELAY_DEF) {
1385                 vty_out(vty, " update-delay %d", bgp->v_update_delay);
1386                 if (bgp->v_update_delay != bgp->v_establish_wait)
1387                         vty_out(vty, " %d", bgp->v_establish_wait);
1388                 vty_out(vty, "\n");
1389         }
1390 }
1391
1392
1393 /* Update-delay configuration */
1394 DEFUN (bgp_update_delay,
1395        bgp_update_delay_cmd,
1396        "update-delay (0-3600)",
1397        "Force initial delay for best-path and updates\n"
1398        "Seconds\n")
1399 {
1400         int idx_number = 1;
1401         return bgp_update_delay_config_vty(vty, argv[idx_number]->arg, NULL);
1402 }
1403
1404 DEFUN (bgp_update_delay_establish_wait,
1405        bgp_update_delay_establish_wait_cmd,
1406        "update-delay (0-3600) (1-3600)",
1407        "Force initial delay for best-path and updates\n"
1408        "Seconds\n"
1409        "Seconds\n")
1410 {
1411         int idx_number = 1;
1412         int idx_number_2 = 2;
1413         return bgp_update_delay_config_vty(vty, argv[idx_number]->arg,
1414                                            argv[idx_number_2]->arg);
1415 }
1416
1417 /* Update-delay deconfiguration */
1418 DEFUN (no_bgp_update_delay,
1419        no_bgp_update_delay_cmd,
1420        "no update-delay [(0-3600) [(1-3600)]]",
1421        NO_STR
1422        "Force initial delay for best-path and updates\n"
1423        "Seconds\n"
1424        "Seconds\n")
1425 {
1426         return bgp_update_delay_deconfig_vty(vty);
1427 }
1428
1429
1430 static int bgp_wpkt_quanta_config_vty(struct vty *vty, const char *num,
1431                                       char set)
1432 {
1433         VTY_DECLVAR_CONTEXT(bgp, bgp);
1434
1435         if (set) {
1436                 uint32_t quanta = strtoul(num, NULL, 10);
1437                 atomic_store_explicit(&bgp->wpkt_quanta, quanta,
1438                                       memory_order_relaxed);
1439         } else {
1440                 atomic_store_explicit(&bgp->wpkt_quanta, BGP_WRITE_PACKET_MAX,
1441                                       memory_order_relaxed);
1442         }
1443
1444         return CMD_SUCCESS;
1445 }
1446
1447 static int bgp_rpkt_quanta_config_vty(struct vty *vty, const char *num,
1448                                       char set)
1449 {
1450         VTY_DECLVAR_CONTEXT(bgp, bgp);
1451
1452         if (set) {
1453                 uint32_t quanta = strtoul(num, NULL, 10);
1454                 atomic_store_explicit(&bgp->rpkt_quanta, quanta,
1455                                       memory_order_relaxed);
1456         } else {
1457                 atomic_store_explicit(&bgp->rpkt_quanta, BGP_READ_PACKET_MAX,
1458                                       memory_order_relaxed);
1459         }
1460
1461         return CMD_SUCCESS;
1462 }
1463
1464 void bgp_config_write_wpkt_quanta(struct vty *vty, struct bgp *bgp)
1465 {
1466         uint32_t quanta =
1467                 atomic_load_explicit(&bgp->wpkt_quanta, memory_order_relaxed);
1468         if (quanta != BGP_WRITE_PACKET_MAX)
1469                 vty_out(vty, " write-quanta %d\n", quanta);
1470 }
1471
1472 void bgp_config_write_rpkt_quanta(struct vty *vty, struct bgp *bgp)
1473 {
1474         uint32_t quanta =
1475                 atomic_load_explicit(&bgp->rpkt_quanta, memory_order_relaxed);
1476         if (quanta != BGP_READ_PACKET_MAX)
1477                 vty_out(vty, " read-quanta %d\n", quanta);
1478 }
1479
1480 /* Packet quanta configuration */
1481 DEFUN (bgp_wpkt_quanta,
1482        bgp_wpkt_quanta_cmd,
1483        "write-quanta (1-10)",
1484        "How many packets to write to peer socket per run\n"
1485        "Number of packets\n")
1486 {
1487         int idx_number = 1;
1488         return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 1);
1489 }
1490
1491 DEFUN (no_bgp_wpkt_quanta,
1492        no_bgp_wpkt_quanta_cmd,
1493        "no write-quanta (1-10)",
1494        NO_STR
1495        "How many packets to write to peer socket per I/O cycle\n"
1496        "Number of packets\n")
1497 {
1498         int idx_number = 2;
1499         return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 0);
1500 }
1501
1502 DEFUN (bgp_rpkt_quanta,
1503        bgp_rpkt_quanta_cmd,
1504        "read-quanta (1-10)",
1505        "How many packets to read from peer socket per I/O cycle\n"
1506        "Number of packets\n")
1507 {
1508         int idx_number = 1;
1509         return bgp_rpkt_quanta_config_vty(vty, argv[idx_number]->arg, 1);
1510 }
1511
1512 DEFUN (no_bgp_rpkt_quanta,
1513        no_bgp_rpkt_quanta_cmd,
1514        "no read-quanta (1-10)",
1515        NO_STR
1516        "How many packets to read from peer socket per I/O cycle\n"
1517        "Number of packets\n")
1518 {
1519         int idx_number = 2;
1520         return bgp_rpkt_quanta_config_vty(vty, argv[idx_number]->arg, 0);
1521 }
1522
1523 void bgp_config_write_coalesce_time(struct vty *vty, struct bgp *bgp)
1524 {
1525         if (!bgp->heuristic_coalesce)
1526                 vty_out(vty, " coalesce-time %u\n", bgp->coalesce_time);
1527 }
1528
1529
1530 DEFUN (bgp_coalesce_time,
1531        bgp_coalesce_time_cmd,
1532        "coalesce-time (0-4294967295)",
1533        "Subgroup coalesce timer\n"
1534        "Subgroup coalesce timer value (in ms)\n")
1535 {
1536         VTY_DECLVAR_CONTEXT(bgp, bgp);
1537
1538         int idx = 0;
1539         argv_find(argv, argc, "(0-4294967295)", &idx);
1540         bgp->heuristic_coalesce = false;
1541         bgp->coalesce_time = strtoul(argv[idx]->arg, NULL, 10);
1542         return CMD_SUCCESS;
1543 }
1544
1545 DEFUN (no_bgp_coalesce_time,
1546        no_bgp_coalesce_time_cmd,
1547        "no coalesce-time (0-4294967295)",
1548        NO_STR
1549        "Subgroup coalesce timer\n"
1550        "Subgroup coalesce timer value (in ms)\n")
1551 {
1552         VTY_DECLVAR_CONTEXT(bgp, bgp);
1553
1554         bgp->heuristic_coalesce = true;
1555         bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
1556         return CMD_SUCCESS;
1557 }
1558
1559 /* Maximum-paths configuration */
1560 DEFUN (bgp_maxpaths,
1561        bgp_maxpaths_cmd,
1562        "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
1563        "Forward packets over multiple paths\n"
1564        "Number of paths\n")
1565 {
1566         int idx_number = 1;
1567         return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP,
1568                                        argv[idx_number]->arg, 0, 1);
1569 }
1570
1571 ALIAS_HIDDEN(bgp_maxpaths, bgp_maxpaths_hidden_cmd,
1572              "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
1573              "Forward packets over multiple paths\n"
1574              "Number of paths\n")
1575
1576 DEFUN (bgp_maxpaths_ibgp,
1577        bgp_maxpaths_ibgp_cmd,
1578        "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
1579        "Forward packets over multiple paths\n"
1580        "iBGP-multipath\n"
1581        "Number of paths\n")
1582 {
1583         int idx_number = 2;
1584         return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
1585                                        argv[idx_number]->arg, 0, 1);
1586 }
1587
1588 ALIAS_HIDDEN(bgp_maxpaths_ibgp, bgp_maxpaths_ibgp_hidden_cmd,
1589              "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
1590              "Forward packets over multiple paths\n"
1591              "iBGP-multipath\n"
1592              "Number of paths\n")
1593
1594 DEFUN (bgp_maxpaths_ibgp_cluster,
1595        bgp_maxpaths_ibgp_cluster_cmd,
1596        "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM) " equal-cluster-length",
1597        "Forward packets over multiple paths\n"
1598        "iBGP-multipath\n"
1599        "Number of paths\n"
1600        "Match the cluster length\n")
1601 {
1602         int idx_number = 2;
1603         return bgp_maxpaths_config_vty(
1604                 vty, BGP_PEER_IBGP, argv[idx_number]->arg,
1605                 BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN, 1);
1606 }
1607
1608 ALIAS_HIDDEN(bgp_maxpaths_ibgp_cluster, bgp_maxpaths_ibgp_cluster_hidden_cmd,
1609              "maximum-paths ibgp " CMD_RANGE_STR(
1610                      1, MULTIPATH_NUM) " equal-cluster-length",
1611              "Forward packets over multiple paths\n"
1612              "iBGP-multipath\n"
1613              "Number of paths\n"
1614              "Match the cluster length\n")
1615
1616 DEFUN (no_bgp_maxpaths,
1617        no_bgp_maxpaths_cmd,
1618        "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
1619        NO_STR
1620        "Forward packets over multiple paths\n"
1621        "Number of paths\n")
1622 {
1623         return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, NULL, 0, 0);
1624 }
1625
1626 ALIAS_HIDDEN(no_bgp_maxpaths, no_bgp_maxpaths_hidden_cmd,
1627              "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]", NO_STR
1628              "Forward packets over multiple paths\n"
1629              "Number of paths\n")
1630
1631 DEFUN (no_bgp_maxpaths_ibgp,
1632        no_bgp_maxpaths_ibgp_cmd,
1633        "no maximum-paths ibgp [" CMD_RANGE_STR(1, MULTIPATH_NUM) " [equal-cluster-length]]",
1634        NO_STR
1635        "Forward packets over multiple paths\n"
1636        "iBGP-multipath\n"
1637        "Number of paths\n"
1638        "Match the cluster length\n")
1639 {
1640         return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, NULL, 0, 0);
1641 }
1642
1643 ALIAS_HIDDEN(no_bgp_maxpaths_ibgp, no_bgp_maxpaths_ibgp_hidden_cmd,
1644              "no maximum-paths ibgp [" CMD_RANGE_STR(
1645                      1, MULTIPATH_NUM) " [equal-cluster-length]]",
1646              NO_STR
1647              "Forward packets over multiple paths\n"
1648              "iBGP-multipath\n"
1649              "Number of paths\n"
1650              "Match the cluster length\n")
1651
1652 void bgp_config_write_maxpaths(struct vty *vty, struct bgp *bgp, afi_t afi,
1653                                safi_t safi)
1654 {
1655         if (bgp->maxpaths[afi][safi].maxpaths_ebgp != MULTIPATH_NUM) {
1656                 vty_out(vty, "  maximum-paths %d\n",
1657                         bgp->maxpaths[afi][safi].maxpaths_ebgp);
1658         }
1659
1660         if (bgp->maxpaths[afi][safi].maxpaths_ibgp != MULTIPATH_NUM) {
1661                 vty_out(vty, "  maximum-paths ibgp %d",
1662                         bgp->maxpaths[afi][safi].maxpaths_ibgp);
1663                 if (CHECK_FLAG(bgp->maxpaths[afi][safi].ibgp_flags,
1664                                BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN))
1665                         vty_out(vty, " equal-cluster-length");
1666                 vty_out(vty, "\n");
1667         }
1668 }
1669
1670 /* BGP timers.  */
1671
1672 DEFUN (bgp_timers,
1673        bgp_timers_cmd,
1674        "timers bgp (0-65535) (0-65535)",
1675        "Adjust routing timers\n"
1676        "BGP timers\n"
1677        "Keepalive interval\n"
1678        "Holdtime\n")
1679 {
1680         VTY_DECLVAR_CONTEXT(bgp, bgp);
1681         int idx_number = 2;
1682         int idx_number_2 = 3;
1683         unsigned long keepalive = 0;
1684         unsigned long holdtime = 0;
1685
1686         keepalive = strtoul(argv[idx_number]->arg, NULL, 10);
1687         holdtime = strtoul(argv[idx_number_2]->arg, NULL, 10);
1688
1689         /* Holdtime value check. */
1690         if (holdtime < 3 && holdtime != 0) {
1691                 vty_out(vty,
1692                         "%% hold time value must be either 0 or greater than 3\n");
1693                 return CMD_WARNING_CONFIG_FAILED;
1694         }
1695
1696         bgp_timers_set(bgp, keepalive, holdtime);
1697
1698         return CMD_SUCCESS;
1699 }
1700
1701 DEFUN (no_bgp_timers,
1702        no_bgp_timers_cmd,
1703        "no timers bgp [(0-65535) (0-65535)]",
1704        NO_STR
1705        "Adjust routing timers\n"
1706        "BGP timers\n"
1707        "Keepalive interval\n"
1708        "Holdtime\n")
1709 {
1710         VTY_DECLVAR_CONTEXT(bgp, bgp);
1711         bgp_timers_unset(bgp);
1712
1713         return CMD_SUCCESS;
1714 }
1715
1716
1717 DEFUN (bgp_client_to_client_reflection,
1718        bgp_client_to_client_reflection_cmd,
1719        "bgp client-to-client reflection",
1720        "BGP specific commands\n"
1721        "Configure client to client route reflection\n"
1722        "reflection of routes allowed\n")
1723 {
1724         VTY_DECLVAR_CONTEXT(bgp, bgp);
1725         bgp_flag_unset(bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1726         bgp_clear_star_soft_out(vty, bgp->name);
1727
1728         return CMD_SUCCESS;
1729 }
1730
1731 DEFUN (no_bgp_client_to_client_reflection,
1732        no_bgp_client_to_client_reflection_cmd,
1733        "no bgp client-to-client reflection",
1734        NO_STR
1735        "BGP specific commands\n"
1736        "Configure client to client route reflection\n"
1737        "reflection of routes allowed\n")
1738 {
1739         VTY_DECLVAR_CONTEXT(bgp, bgp);
1740         bgp_flag_set(bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1741         bgp_clear_star_soft_out(vty, bgp->name);
1742
1743         return CMD_SUCCESS;
1744 }
1745
1746 /* "bgp always-compare-med" configuration. */
1747 DEFUN (bgp_always_compare_med,
1748        bgp_always_compare_med_cmd,
1749        "bgp always-compare-med",
1750        "BGP specific commands\n"
1751        "Allow comparing MED from different neighbors\n")
1752 {
1753         VTY_DECLVAR_CONTEXT(bgp, bgp);
1754         bgp_flag_set(bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1755         bgp_recalculate_all_bestpaths(bgp);
1756
1757         return CMD_SUCCESS;
1758 }
1759
1760 DEFUN (no_bgp_always_compare_med,
1761        no_bgp_always_compare_med_cmd,
1762        "no bgp always-compare-med",
1763        NO_STR
1764        "BGP specific commands\n"
1765        "Allow comparing MED from different neighbors\n")
1766 {
1767         VTY_DECLVAR_CONTEXT(bgp, bgp);
1768         bgp_flag_unset(bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1769         bgp_recalculate_all_bestpaths(bgp);
1770
1771         return CMD_SUCCESS;
1772 }
1773
1774 /* "bgp deterministic-med" configuration. */
1775 DEFUN (bgp_deterministic_med,
1776        bgp_deterministic_med_cmd,
1777        "bgp deterministic-med",
1778        "BGP specific commands\n"
1779        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1780 {
1781         VTY_DECLVAR_CONTEXT(bgp, bgp);
1782
1783         if (!bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)) {
1784                 bgp_flag_set(bgp, BGP_FLAG_DETERMINISTIC_MED);
1785                 bgp_recalculate_all_bestpaths(bgp);
1786         }
1787
1788         return CMD_SUCCESS;
1789 }
1790
1791 DEFUN (no_bgp_deterministic_med,
1792        no_bgp_deterministic_med_cmd,
1793        "no bgp deterministic-med",
1794        NO_STR
1795        "BGP specific commands\n"
1796        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1797 {
1798         VTY_DECLVAR_CONTEXT(bgp, bgp);
1799         int bestpath_per_as_used;
1800         afi_t afi;
1801         safi_t safi;
1802         struct peer *peer;
1803         struct listnode *node, *nnode;
1804
1805         if (bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)) {
1806                 bestpath_per_as_used = 0;
1807
1808                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1809                         FOREACH_AFI_SAFI (afi, safi)
1810                                 if (CHECK_FLAG(
1811                                             peer->af_flags[afi][safi],
1812                                             PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS)) {
1813                                         bestpath_per_as_used = 1;
1814                                         break;
1815                                 }
1816
1817                         if (bestpath_per_as_used)
1818                                 break;
1819                 }
1820
1821                 if (bestpath_per_as_used) {
1822                         vty_out(vty,
1823                                 "bgp deterministic-med cannot be disabled while addpath-tx-bestpath-per-AS is in use\n");
1824                         return CMD_WARNING_CONFIG_FAILED;
1825                 } else {
1826                         bgp_flag_unset(bgp, BGP_FLAG_DETERMINISTIC_MED);
1827                         bgp_recalculate_all_bestpaths(bgp);
1828                 }
1829         }
1830
1831         return CMD_SUCCESS;
1832 }
1833
1834 /* "bgp graceful-restart" configuration. */
1835 DEFUN (bgp_graceful_restart,
1836        bgp_graceful_restart_cmd,
1837        "bgp graceful-restart",
1838        "BGP specific commands\n"
1839        "Graceful restart capability parameters\n")
1840 {
1841         VTY_DECLVAR_CONTEXT(bgp, bgp);
1842         bgp_flag_set(bgp, BGP_FLAG_GRACEFUL_RESTART);
1843         return CMD_SUCCESS;
1844 }
1845
1846 DEFUN (no_bgp_graceful_restart,
1847        no_bgp_graceful_restart_cmd,
1848        "no bgp graceful-restart",
1849        NO_STR
1850        "BGP specific commands\n"
1851        "Graceful restart capability parameters\n")
1852 {
1853         VTY_DECLVAR_CONTEXT(bgp, bgp);
1854         bgp_flag_unset(bgp, BGP_FLAG_GRACEFUL_RESTART);
1855         return CMD_SUCCESS;
1856 }
1857
1858 DEFUN (bgp_graceful_restart_stalepath_time,
1859        bgp_graceful_restart_stalepath_time_cmd,
1860        "bgp graceful-restart stalepath-time (1-3600)",
1861        "BGP specific commands\n"
1862        "Graceful restart capability parameters\n"
1863        "Set the max time to hold onto restarting peer's stale paths\n"
1864        "Delay value (seconds)\n")
1865 {
1866         VTY_DECLVAR_CONTEXT(bgp, bgp);
1867         int idx_number = 3;
1868         uint32_t stalepath;
1869
1870         stalepath = strtoul(argv[idx_number]->arg, NULL, 10);
1871         bgp->stalepath_time = stalepath;
1872         return CMD_SUCCESS;
1873 }
1874
1875 DEFUN (bgp_graceful_restart_restart_time,
1876        bgp_graceful_restart_restart_time_cmd,
1877        "bgp graceful-restart restart-time (1-3600)",
1878        "BGP specific commands\n"
1879        "Graceful restart capability parameters\n"
1880        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1881        "Delay value (seconds)\n")
1882 {
1883         VTY_DECLVAR_CONTEXT(bgp, bgp);
1884         int idx_number = 3;
1885         uint32_t restart;
1886
1887         restart = strtoul(argv[idx_number]->arg, NULL, 10);
1888         bgp->restart_time = restart;
1889         return CMD_SUCCESS;
1890 }
1891
1892 DEFUN (no_bgp_graceful_restart_stalepath_time,
1893        no_bgp_graceful_restart_stalepath_time_cmd,
1894        "no bgp graceful-restart stalepath-time [(1-3600)]",
1895        NO_STR
1896        "BGP specific commands\n"
1897        "Graceful restart capability parameters\n"
1898        "Set the max time to hold onto restarting peer's stale paths\n"
1899        "Delay value (seconds)\n")
1900 {
1901         VTY_DECLVAR_CONTEXT(bgp, bgp);
1902
1903         bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
1904         return CMD_SUCCESS;
1905 }
1906
1907 DEFUN (no_bgp_graceful_restart_restart_time,
1908        no_bgp_graceful_restart_restart_time_cmd,
1909        "no bgp graceful-restart restart-time [(1-3600)]",
1910        NO_STR
1911        "BGP specific commands\n"
1912        "Graceful restart capability parameters\n"
1913        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1914        "Delay value (seconds)\n")
1915 {
1916         VTY_DECLVAR_CONTEXT(bgp, bgp);
1917
1918         bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
1919         return CMD_SUCCESS;
1920 }
1921
1922 DEFUN (bgp_graceful_restart_preserve_fw,
1923        bgp_graceful_restart_preserve_fw_cmd,
1924        "bgp graceful-restart preserve-fw-state",
1925        "BGP specific commands\n"
1926        "Graceful restart capability parameters\n"
1927        "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
1928 {
1929         VTY_DECLVAR_CONTEXT(bgp, bgp);
1930         bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD);
1931         return CMD_SUCCESS;
1932 }
1933
1934 DEFUN (no_bgp_graceful_restart_preserve_fw,
1935        no_bgp_graceful_restart_preserve_fw_cmd,
1936        "no bgp graceful-restart preserve-fw-state",
1937        NO_STR
1938        "BGP specific commands\n"
1939        "Graceful restart capability parameters\n"
1940        "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
1941 {
1942         VTY_DECLVAR_CONTEXT(bgp, bgp);
1943         bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD);
1944         return CMD_SUCCESS;
1945 }
1946
1947 static void bgp_redistribute_redo(struct bgp *bgp)
1948 {
1949         afi_t afi;
1950         int i;
1951         struct list *red_list;
1952         struct listnode *node;
1953         struct bgp_redist *red;
1954
1955         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
1956                 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
1957
1958                         red_list = bgp->redist[afi][i];
1959                         if (!red_list)
1960                                 continue;
1961
1962                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
1963                                 bgp_redistribute_resend(bgp, afi, i,
1964                                                         red->instance);
1965                         }
1966                 }
1967         }
1968 }
1969
1970 /* "bgp graceful-shutdown" configuration */
1971 DEFUN (bgp_graceful_shutdown,
1972        bgp_graceful_shutdown_cmd,
1973        "bgp graceful-shutdown",
1974        BGP_STR
1975        "Graceful shutdown parameters\n")
1976 {
1977         VTY_DECLVAR_CONTEXT(bgp, bgp);
1978
1979         if (!bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
1980                 bgp_flag_set(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN);
1981                 bgp_static_redo_import_check(bgp);
1982                 bgp_redistribute_redo(bgp);
1983                 bgp_clear_star_soft_out(vty, bgp->name);
1984                 bgp_clear_star_soft_in(vty, bgp->name);
1985         }
1986
1987         return CMD_SUCCESS;
1988 }
1989
1990 DEFUN (no_bgp_graceful_shutdown,
1991        no_bgp_graceful_shutdown_cmd,
1992        "no bgp graceful-shutdown",
1993        NO_STR
1994        BGP_STR
1995        "Graceful shutdown parameters\n")
1996 {
1997         VTY_DECLVAR_CONTEXT(bgp, bgp);
1998
1999         if (bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
2000                 bgp_flag_unset(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN);
2001                 bgp_static_redo_import_check(bgp);
2002                 bgp_redistribute_redo(bgp);
2003                 bgp_clear_star_soft_out(vty, bgp->name);
2004                 bgp_clear_star_soft_in(vty, bgp->name);
2005         }
2006
2007         return CMD_SUCCESS;
2008 }
2009
2010 /* "bgp fast-external-failover" configuration. */
2011 DEFUN (bgp_fast_external_failover,
2012        bgp_fast_external_failover_cmd,
2013        "bgp fast-external-failover",
2014        BGP_STR
2015        "Immediately reset session if a link to a directly connected external peer goes down\n")
2016 {
2017         VTY_DECLVAR_CONTEXT(bgp, bgp);
2018         bgp_flag_unset(bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
2019         return CMD_SUCCESS;
2020 }
2021
2022 DEFUN (no_bgp_fast_external_failover,
2023        no_bgp_fast_external_failover_cmd,
2024        "no bgp fast-external-failover",
2025        NO_STR
2026        BGP_STR
2027        "Immediately reset session if a link to a directly connected external peer goes down\n")
2028 {
2029         VTY_DECLVAR_CONTEXT(bgp, bgp);
2030         bgp_flag_set(bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
2031         return CMD_SUCCESS;
2032 }
2033
2034 /* "bgp enforce-first-as" configuration. */
2035 #if CONFDATE > 20190517
2036 CPP_NOTICE("bgpd: remove deprecated '[no] bgp enforce-first-as' commands")
2037 #endif
2038
2039 DEFUN_HIDDEN (bgp_enforce_first_as,
2040               bgp_enforce_first_as_cmd,
2041               "[no] bgp enforce-first-as",
2042               NO_STR
2043               BGP_STR
2044               "Enforce the first AS for EBGP routes\n")
2045 {
2046         VTY_DECLVAR_CONTEXT(bgp, bgp);
2047
2048         if (strmatch(argv[0]->text, "no"))
2049                 bgp_flag_unset(bgp, BGP_FLAG_ENFORCE_FIRST_AS);
2050         else
2051                 bgp_flag_set(bgp, BGP_FLAG_ENFORCE_FIRST_AS);
2052
2053         return CMD_SUCCESS;
2054 }
2055
2056 /* "bgp bestpath compare-routerid" configuration.  */
2057 DEFUN (bgp_bestpath_compare_router_id,
2058        bgp_bestpath_compare_router_id_cmd,
2059        "bgp bestpath compare-routerid",
2060        "BGP specific commands\n"
2061        "Change the default bestpath selection\n"
2062        "Compare router-id for identical EBGP paths\n")
2063 {
2064         VTY_DECLVAR_CONTEXT(bgp, bgp);
2065         bgp_flag_set(bgp, BGP_FLAG_COMPARE_ROUTER_ID);
2066         bgp_recalculate_all_bestpaths(bgp);
2067
2068         return CMD_SUCCESS;
2069 }
2070
2071 DEFUN (no_bgp_bestpath_compare_router_id,
2072        no_bgp_bestpath_compare_router_id_cmd,
2073        "no bgp bestpath compare-routerid",
2074        NO_STR
2075        "BGP specific commands\n"
2076        "Change the default bestpath selection\n"
2077        "Compare router-id for identical EBGP paths\n")
2078 {
2079         VTY_DECLVAR_CONTEXT(bgp, bgp);
2080         bgp_flag_unset(bgp, BGP_FLAG_COMPARE_ROUTER_ID);
2081         bgp_recalculate_all_bestpaths(bgp);
2082
2083         return CMD_SUCCESS;
2084 }
2085
2086 /* "bgp bestpath as-path ignore" configuration.  */
2087 DEFUN (bgp_bestpath_aspath_ignore,
2088        bgp_bestpath_aspath_ignore_cmd,
2089        "bgp bestpath as-path ignore",
2090        "BGP specific commands\n"
2091        "Change the default bestpath selection\n"
2092        "AS-path attribute\n"
2093        "Ignore as-path length in selecting a route\n")
2094 {
2095         VTY_DECLVAR_CONTEXT(bgp, bgp);
2096         bgp_flag_set(bgp, BGP_FLAG_ASPATH_IGNORE);
2097         bgp_recalculate_all_bestpaths(bgp);
2098
2099         return CMD_SUCCESS;
2100 }
2101
2102 DEFUN (no_bgp_bestpath_aspath_ignore,
2103        no_bgp_bestpath_aspath_ignore_cmd,
2104        "no bgp bestpath as-path ignore",
2105        NO_STR
2106        "BGP specific commands\n"
2107        "Change the default bestpath selection\n"
2108        "AS-path attribute\n"
2109        "Ignore as-path length in selecting a route\n")
2110 {
2111         VTY_DECLVAR_CONTEXT(bgp, bgp);
2112         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_IGNORE);
2113         bgp_recalculate_all_bestpaths(bgp);
2114
2115         return CMD_SUCCESS;
2116 }
2117
2118 /* "bgp bestpath as-path confed" configuration.  */
2119 DEFUN (bgp_bestpath_aspath_confed,
2120        bgp_bestpath_aspath_confed_cmd,
2121        "bgp bestpath as-path confed",
2122        "BGP specific commands\n"
2123        "Change the default bestpath selection\n"
2124        "AS-path attribute\n"
2125        "Compare path lengths including confederation sets & sequences in selecting a route\n")
2126 {
2127         VTY_DECLVAR_CONTEXT(bgp, bgp);
2128         bgp_flag_set(bgp, BGP_FLAG_ASPATH_CONFED);
2129         bgp_recalculate_all_bestpaths(bgp);
2130
2131         return CMD_SUCCESS;
2132 }
2133
2134 DEFUN (no_bgp_bestpath_aspath_confed,
2135        no_bgp_bestpath_aspath_confed_cmd,
2136        "no bgp bestpath as-path confed",
2137        NO_STR
2138        "BGP specific commands\n"
2139        "Change the default bestpath selection\n"
2140        "AS-path attribute\n"
2141        "Compare path lengths including confederation sets & sequences in selecting a route\n")
2142 {
2143         VTY_DECLVAR_CONTEXT(bgp, bgp);
2144         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_CONFED);
2145         bgp_recalculate_all_bestpaths(bgp);
2146
2147         return CMD_SUCCESS;
2148 }
2149
2150 /* "bgp bestpath as-path multipath-relax" configuration.  */
2151 DEFUN (bgp_bestpath_aspath_multipath_relax,
2152        bgp_bestpath_aspath_multipath_relax_cmd,
2153        "bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2154        "BGP specific commands\n"
2155        "Change the default bestpath selection\n"
2156        "AS-path attribute\n"
2157        "Allow load sharing across routes that have different AS paths (but same length)\n"
2158        "Generate an AS_SET\n"
2159        "Do not generate an AS_SET\n")
2160 {
2161         VTY_DECLVAR_CONTEXT(bgp, bgp);
2162         int idx = 0;
2163         bgp_flag_set(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2164
2165         /* no-as-set is now the default behavior so we can silently
2166          * ignore it */
2167         if (argv_find(argv, argc, "as-set", &idx))
2168                 bgp_flag_set(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2169         else
2170                 bgp_flag_unset(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2171
2172         bgp_recalculate_all_bestpaths(bgp);
2173
2174         return CMD_SUCCESS;
2175 }
2176
2177 DEFUN (no_bgp_bestpath_aspath_multipath_relax,
2178        no_bgp_bestpath_aspath_multipath_relax_cmd,
2179        "no bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2180        NO_STR
2181        "BGP specific commands\n"
2182        "Change the default bestpath selection\n"
2183        "AS-path attribute\n"
2184        "Allow load sharing across routes that have different AS paths (but same length)\n"
2185        "Generate an AS_SET\n"
2186        "Do not generate an AS_SET\n")
2187 {
2188         VTY_DECLVAR_CONTEXT(bgp, bgp);
2189         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2190         bgp_flag_unset(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2191         bgp_recalculate_all_bestpaths(bgp);
2192
2193         return CMD_SUCCESS;
2194 }
2195
2196 /* "bgp log-neighbor-changes" configuration.  */
2197 DEFUN (bgp_log_neighbor_changes,
2198        bgp_log_neighbor_changes_cmd,
2199        "bgp log-neighbor-changes",
2200        "BGP specific commands\n"
2201        "Log neighbor up/down and reset reason\n")
2202 {
2203         VTY_DECLVAR_CONTEXT(bgp, bgp);
2204         bgp_flag_set(bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2205         return CMD_SUCCESS;
2206 }
2207
2208 DEFUN (no_bgp_log_neighbor_changes,
2209        no_bgp_log_neighbor_changes_cmd,
2210        "no bgp log-neighbor-changes",
2211        NO_STR
2212        "BGP specific commands\n"
2213        "Log neighbor up/down and reset reason\n")
2214 {
2215         VTY_DECLVAR_CONTEXT(bgp, bgp);
2216         bgp_flag_unset(bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2217         return CMD_SUCCESS;
2218 }
2219
2220 /* "bgp bestpath med" configuration. */
2221 DEFUN (bgp_bestpath_med,
2222        bgp_bestpath_med_cmd,
2223        "bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2224        "BGP specific commands\n"
2225        "Change the default bestpath selection\n"
2226        "MED attribute\n"
2227        "Compare MED among confederation paths\n"
2228        "Treat missing MED as the least preferred one\n"
2229        "Treat missing MED as the least preferred one\n"
2230        "Compare MED among confederation paths\n")
2231 {
2232         VTY_DECLVAR_CONTEXT(bgp, bgp);
2233
2234         int idx = 0;
2235         if (argv_find(argv, argc, "confed", &idx))
2236                 bgp_flag_set(bgp, BGP_FLAG_MED_CONFED);
2237         idx = 0;
2238         if (argv_find(argv, argc, "missing-as-worst", &idx))
2239                 bgp_flag_set(bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2240
2241         bgp_recalculate_all_bestpaths(bgp);
2242
2243         return CMD_SUCCESS;
2244 }
2245
2246 DEFUN (no_bgp_bestpath_med,
2247        no_bgp_bestpath_med_cmd,
2248        "no bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2249        NO_STR
2250        "BGP specific commands\n"
2251        "Change the default bestpath selection\n"
2252        "MED attribute\n"
2253        "Compare MED among confederation paths\n"
2254        "Treat missing MED as the least preferred one\n"
2255        "Treat missing MED as the least preferred one\n"
2256        "Compare MED among confederation paths\n")
2257 {
2258         VTY_DECLVAR_CONTEXT(bgp, bgp);
2259
2260         int idx = 0;
2261         if (argv_find(argv, argc, "confed", &idx))
2262                 bgp_flag_unset(bgp, BGP_FLAG_MED_CONFED);
2263         idx = 0;
2264         if (argv_find(argv, argc, "missing-as-worst", &idx))
2265                 bgp_flag_unset(bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2266
2267         bgp_recalculate_all_bestpaths(bgp);
2268
2269         return CMD_SUCCESS;
2270 }
2271
2272 /* "no bgp default ipv4-unicast". */
2273 DEFUN (no_bgp_default_ipv4_unicast,
2274        no_bgp_default_ipv4_unicast_cmd,
2275        "no bgp default ipv4-unicast",
2276        NO_STR
2277        "BGP specific commands\n"
2278        "Configure BGP defaults\n"
2279        "Activate ipv4-unicast for a peer by default\n")
2280 {
2281         VTY_DECLVAR_CONTEXT(bgp, bgp);
2282         bgp_flag_set(bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2283         return CMD_SUCCESS;
2284 }
2285
2286 DEFUN (bgp_default_ipv4_unicast,
2287        bgp_default_ipv4_unicast_cmd,
2288        "bgp default ipv4-unicast",
2289        "BGP specific commands\n"
2290        "Configure BGP defaults\n"
2291        "Activate ipv4-unicast for a peer by default\n")
2292 {
2293         VTY_DECLVAR_CONTEXT(bgp, bgp);
2294         bgp_flag_unset(bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2295         return CMD_SUCCESS;
2296 }
2297
2298 /* Display hostname in certain command outputs */
2299 DEFUN (bgp_default_show_hostname,
2300        bgp_default_show_hostname_cmd,
2301        "bgp default show-hostname",
2302        "BGP specific commands\n"
2303        "Configure BGP defaults\n"
2304        "Show hostname in certain command ouputs\n")
2305 {
2306         VTY_DECLVAR_CONTEXT(bgp, bgp);
2307         bgp_flag_set(bgp, BGP_FLAG_SHOW_HOSTNAME);
2308         return CMD_SUCCESS;
2309 }
2310
2311 DEFUN (no_bgp_default_show_hostname,
2312        no_bgp_default_show_hostname_cmd,
2313        "no bgp default show-hostname",
2314        NO_STR
2315        "BGP specific commands\n"
2316        "Configure BGP defaults\n"
2317        "Show hostname in certain command ouputs\n")
2318 {
2319         VTY_DECLVAR_CONTEXT(bgp, bgp);
2320         bgp_flag_unset(bgp, BGP_FLAG_SHOW_HOSTNAME);
2321         return CMD_SUCCESS;
2322 }
2323
2324 /* "bgp network import-check" configuration.  */
2325 DEFUN (bgp_network_import_check,
2326        bgp_network_import_check_cmd,
2327        "bgp network import-check",
2328        "BGP specific commands\n"
2329        "BGP network command\n"
2330        "Check BGP network route exists in IGP\n")
2331 {
2332         VTY_DECLVAR_CONTEXT(bgp, bgp);
2333         if (!bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK)) {
2334                 bgp_flag_set(bgp, BGP_FLAG_IMPORT_CHECK);
2335                 bgp_static_redo_import_check(bgp);
2336         }
2337
2338         return CMD_SUCCESS;
2339 }
2340
2341 ALIAS_HIDDEN(bgp_network_import_check, bgp_network_import_check_exact_cmd,
2342              "bgp network import-check exact",
2343              "BGP specific commands\n"
2344              "BGP network command\n"
2345              "Check BGP network route exists in IGP\n"
2346              "Match route precisely\n")
2347
2348 DEFUN (no_bgp_network_import_check,
2349        no_bgp_network_import_check_cmd,
2350        "no bgp network import-check",
2351        NO_STR
2352        "BGP specific commands\n"
2353        "BGP network command\n"
2354        "Check BGP network route exists in IGP\n")
2355 {
2356         VTY_DECLVAR_CONTEXT(bgp, bgp);
2357         if (bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK)) {
2358                 bgp_flag_unset(bgp, BGP_FLAG_IMPORT_CHECK);
2359                 bgp_static_redo_import_check(bgp);
2360         }
2361
2362         return CMD_SUCCESS;
2363 }
2364
2365 DEFUN (bgp_default_local_preference,
2366        bgp_default_local_preference_cmd,
2367        "bgp default local-preference (0-4294967295)",
2368        "BGP specific commands\n"
2369        "Configure BGP defaults\n"
2370        "local preference (higher=more preferred)\n"
2371        "Configure default local preference value\n")
2372 {
2373         VTY_DECLVAR_CONTEXT(bgp, bgp);
2374         int idx_number = 3;
2375         uint32_t local_pref;
2376
2377         local_pref = strtoul(argv[idx_number]->arg, NULL, 10);
2378
2379         bgp_default_local_preference_set(bgp, local_pref);
2380         bgp_clear_star_soft_in(vty, bgp->name);
2381
2382         return CMD_SUCCESS;
2383 }
2384
2385 DEFUN (no_bgp_default_local_preference,
2386        no_bgp_default_local_preference_cmd,
2387        "no bgp default local-preference [(0-4294967295)]",
2388        NO_STR
2389        "BGP specific commands\n"
2390        "Configure BGP defaults\n"
2391        "local preference (higher=more preferred)\n"
2392        "Configure default local preference value\n")
2393 {
2394         VTY_DECLVAR_CONTEXT(bgp, bgp);
2395         bgp_default_local_preference_unset(bgp);
2396         bgp_clear_star_soft_in(vty, bgp->name);
2397
2398         return CMD_SUCCESS;
2399 }
2400
2401
2402 DEFUN (bgp_default_subgroup_pkt_queue_max,
2403        bgp_default_subgroup_pkt_queue_max_cmd,
2404        "bgp default subgroup-pkt-queue-max (20-100)",
2405        "BGP specific commands\n"
2406        "Configure BGP defaults\n"
2407        "subgroup-pkt-queue-max\n"
2408        "Configure subgroup packet queue max\n")
2409 {
2410         VTY_DECLVAR_CONTEXT(bgp, bgp);
2411         int idx_number = 3;
2412         uint32_t max_size;
2413
2414         max_size = strtoul(argv[idx_number]->arg, NULL, 10);
2415
2416         bgp_default_subgroup_pkt_queue_max_set(bgp, max_size);
2417
2418         return CMD_SUCCESS;
2419 }
2420
2421 DEFUN (no_bgp_default_subgroup_pkt_queue_max,
2422        no_bgp_default_subgroup_pkt_queue_max_cmd,
2423        "no bgp default subgroup-pkt-queue-max [(20-100)]",
2424        NO_STR
2425        "BGP specific commands\n"
2426        "Configure BGP defaults\n"
2427        "subgroup-pkt-queue-max\n"
2428        "Configure subgroup packet queue max\n")
2429 {
2430         VTY_DECLVAR_CONTEXT(bgp, bgp);
2431         bgp_default_subgroup_pkt_queue_max_unset(bgp);
2432         return CMD_SUCCESS;
2433 }
2434
2435
2436 DEFUN (bgp_rr_allow_outbound_policy,
2437        bgp_rr_allow_outbound_policy_cmd,
2438        "bgp route-reflector allow-outbound-policy",
2439        "BGP specific commands\n"
2440        "Allow modifications made by out route-map\n"
2441        "on ibgp neighbors\n")
2442 {
2443         VTY_DECLVAR_CONTEXT(bgp, bgp);
2444
2445         if (!bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
2446                 bgp_flag_set(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2447                 update_group_announce_rrclients(bgp);
2448                 bgp_clear_star_soft_out(vty, bgp->name);
2449         }
2450
2451         return CMD_SUCCESS;
2452 }
2453
2454 DEFUN (no_bgp_rr_allow_outbound_policy,
2455        no_bgp_rr_allow_outbound_policy_cmd,
2456        "no bgp route-reflector allow-outbound-policy",
2457        NO_STR
2458        "BGP specific commands\n"
2459        "Allow modifications made by out route-map\n"
2460        "on ibgp neighbors\n")
2461 {
2462         VTY_DECLVAR_CONTEXT(bgp, bgp);
2463
2464         if (bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
2465                 bgp_flag_unset(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2466                 update_group_announce_rrclients(bgp);
2467                 bgp_clear_star_soft_out(vty, bgp->name);
2468         }
2469
2470         return CMD_SUCCESS;
2471 }
2472
2473 DEFUN (bgp_listen_limit,
2474        bgp_listen_limit_cmd,
2475        "bgp listen limit (1-5000)",
2476        "BGP specific commands\n"
2477        "Configure BGP defaults\n"
2478        "maximum number of BGP Dynamic Neighbors that can be created\n"
2479        "Configure Dynamic Neighbors listen limit value\n")
2480 {
2481         VTY_DECLVAR_CONTEXT(bgp, bgp);
2482         int idx_number = 3;
2483         int listen_limit;
2484
2485         listen_limit = strtoul(argv[idx_number]->arg, NULL, 10);
2486
2487         bgp_listen_limit_set(bgp, listen_limit);
2488
2489         return CMD_SUCCESS;
2490 }
2491
2492 DEFUN (no_bgp_listen_limit,
2493        no_bgp_listen_limit_cmd,
2494        "no bgp listen limit [(1-5000)]",
2495        "BGP specific commands\n"
2496        "Configure BGP defaults\n"
2497        "unset maximum number of BGP Dynamic Neighbors that can be created\n"
2498        "Configure Dynamic Neighbors listen limit value to default\n"
2499        "Configure Dynamic Neighbors listen limit value\n")
2500 {
2501         VTY_DECLVAR_CONTEXT(bgp, bgp);
2502         bgp_listen_limit_unset(bgp);
2503         return CMD_SUCCESS;
2504 }
2505
2506
2507 /*
2508  * Check if this listen range is already configured. Check for exact
2509  * match or overlap based on input.
2510  */
2511 static struct peer_group *listen_range_exists(struct bgp *bgp,
2512                                               struct prefix *range, int exact)
2513 {
2514         struct listnode *node, *nnode;
2515         struct listnode *node1, *nnode1;
2516         struct peer_group *group;
2517         struct prefix *lr;
2518         afi_t afi;
2519         int match;
2520
2521         afi = family2afi(range->family);
2522         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
2523                 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node1, nnode1,
2524                                        lr)) {
2525                         if (exact)
2526                                 match = prefix_same(range, lr);
2527                         else
2528                                 match = (prefix_match(range, lr)
2529                                          || prefix_match(lr, range));
2530                         if (match)
2531                                 return group;
2532                 }
2533         }
2534
2535         return NULL;
2536 }
2537
2538 DEFUN (bgp_listen_range,
2539        bgp_listen_range_cmd,
2540        "bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group WORD",
2541        "BGP specific commands\n"
2542        "Configure BGP dynamic neighbors listen range\n"
2543        "Configure BGP dynamic neighbors listen range\n"
2544        NEIGHBOR_ADDR_STR
2545        "Member of the peer-group\n"
2546        "Peer-group name\n")
2547 {
2548         VTY_DECLVAR_CONTEXT(bgp, bgp);
2549         struct prefix range;
2550         struct peer_group *group, *existing_group;
2551         afi_t afi;
2552         int ret;
2553         int idx = 0;
2554
2555         argv_find(argv, argc, "A.B.C.D/M", &idx);
2556         argv_find(argv, argc, "X:X::X:X/M", &idx);
2557         char *prefix = argv[idx]->arg;
2558         argv_find(argv, argc, "WORD", &idx);
2559         char *peergroup = argv[idx]->arg;
2560
2561         /* Convert IP prefix string to struct prefix. */
2562         ret = str2prefix(prefix, &range);
2563         if (!ret) {
2564                 vty_out(vty, "%% Malformed listen range\n");
2565                 return CMD_WARNING_CONFIG_FAILED;
2566         }
2567
2568         afi = family2afi(range.family);
2569
2570         if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
2571                 vty_out(vty,
2572                         "%% Malformed listen range (link-local address)\n");
2573                 return CMD_WARNING_CONFIG_FAILED;
2574         }
2575
2576         apply_mask(&range);
2577
2578         /* Check if same listen range is already configured. */
2579         existing_group = listen_range_exists(bgp, &range, 1);
2580         if (existing_group) {
2581                 if (strcmp(existing_group->name, peergroup) == 0)
2582                         return CMD_SUCCESS;
2583                 else {
2584                         vty_out(vty,
2585                                 "%% Same listen range is attached to peer-group %s\n",
2586                                 existing_group->name);
2587                         return CMD_WARNING_CONFIG_FAILED;
2588                 }
2589         }
2590
2591         /* Check if an overlapping listen range exists. */
2592         if (listen_range_exists(bgp, &range, 0)) {
2593                 vty_out(vty,
2594                         "%% Listen range overlaps with existing listen range\n");
2595                 return CMD_WARNING_CONFIG_FAILED;
2596         }
2597
2598         group = peer_group_lookup(bgp, peergroup);
2599         if (!group) {
2600                 vty_out(vty, "%% Configure the peer-group first\n");
2601                 return CMD_WARNING_CONFIG_FAILED;
2602         }
2603
2604         ret = peer_group_listen_range_add(group, &range);
2605         return bgp_vty_return(vty, ret);
2606 }
2607
2608 DEFUN (no_bgp_listen_range,
2609        no_bgp_listen_range_cmd,
2610        "no bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group WORD",
2611        NO_STR
2612        "BGP specific commands\n"
2613        "Unconfigure BGP dynamic neighbors listen range\n"
2614        "Unconfigure BGP dynamic neighbors listen range\n"
2615        NEIGHBOR_ADDR_STR
2616        "Member of the peer-group\n"
2617        "Peer-group name\n")
2618 {
2619         VTY_DECLVAR_CONTEXT(bgp, bgp);
2620         struct prefix range;
2621         struct peer_group *group;
2622         afi_t afi;
2623         int ret;
2624         int idx = 0;
2625
2626         argv_find(argv, argc, "A.B.C.D/M", &idx);
2627         argv_find(argv, argc, "X:X::X:X/M", &idx);
2628         char *prefix = argv[idx]->arg;
2629         argv_find(argv, argc, "WORD", &idx);
2630         char *peergroup = argv[idx]->arg;
2631
2632         /* Convert IP prefix string to struct prefix. */
2633         ret = str2prefix(prefix, &range);
2634         if (!ret) {
2635                 vty_out(vty, "%% Malformed listen range\n");
2636                 return CMD_WARNING_CONFIG_FAILED;
2637         }
2638
2639         afi = family2afi(range.family);
2640
2641         if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
2642                 vty_out(vty,
2643                         "%% Malformed listen range (link-local address)\n");
2644                 return CMD_WARNING_CONFIG_FAILED;
2645         }
2646
2647         apply_mask(&range);
2648
2649         group = peer_group_lookup(bgp, peergroup);
2650         if (!group) {
2651                 vty_out(vty, "%% Peer-group does not exist\n");
2652                 return CMD_WARNING_CONFIG_FAILED;
2653         }
2654
2655         ret = peer_group_listen_range_del(group, &range);
2656         return bgp_vty_return(vty, ret);
2657 }
2658
2659 void bgp_config_write_listen(struct vty *vty, struct bgp *bgp)
2660 {
2661         struct peer_group *group;
2662         struct listnode *node, *nnode, *rnode, *nrnode;
2663         struct prefix *range;
2664         afi_t afi;
2665         char buf[PREFIX2STR_BUFFER];
2666
2667         if (bgp->dynamic_neighbors_limit != BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT)
2668                 vty_out(vty, " bgp listen limit %d\n",
2669                         bgp->dynamic_neighbors_limit);
2670
2671         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
2672                 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
2673                         for (ALL_LIST_ELEMENTS(group->listen_range[afi], rnode,
2674                                                nrnode, range)) {
2675                                 prefix2str(range, buf, sizeof(buf));
2676                                 vty_out(vty,
2677                                         " bgp listen range %s peer-group %s\n",
2678                                         buf, group->name);
2679                         }
2680                 }
2681         }
2682 }
2683
2684
2685 DEFUN (bgp_disable_connected_route_check,
2686        bgp_disable_connected_route_check_cmd,
2687        "bgp disable-ebgp-connected-route-check",
2688        "BGP specific commands\n"
2689        "Disable checking if nexthop is connected on ebgp sessions\n")
2690 {
2691         VTY_DECLVAR_CONTEXT(bgp, bgp);
2692         bgp_flag_set(bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2693         bgp_clear_star_soft_in(vty, bgp->name);
2694
2695         return CMD_SUCCESS;
2696 }
2697
2698 DEFUN (no_bgp_disable_connected_route_check,
2699        no_bgp_disable_connected_route_check_cmd,
2700        "no bgp disable-ebgp-connected-route-check",
2701        NO_STR
2702        "BGP specific commands\n"
2703        "Disable checking if nexthop is connected on ebgp sessions\n")
2704 {
2705         VTY_DECLVAR_CONTEXT(bgp, bgp);
2706         bgp_flag_unset(bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2707         bgp_clear_star_soft_in(vty, bgp->name);
2708
2709         return CMD_SUCCESS;
2710 }
2711
2712
2713 static int peer_remote_as_vty(struct vty *vty, const char *peer_str,
2714                               const char *as_str, afi_t afi, safi_t safi)
2715 {
2716         VTY_DECLVAR_CONTEXT(bgp, bgp);
2717         int ret;
2718         as_t as;
2719         int as_type = AS_SPECIFIED;
2720         union sockunion su;
2721
2722         if (as_str[0] == 'i') {
2723                 as = 0;
2724                 as_type = AS_INTERNAL;
2725         } else if (as_str[0] == 'e') {
2726                 as = 0;
2727                 as_type = AS_EXTERNAL;
2728         } else {
2729                 /* Get AS number.  */
2730                 as = strtoul(as_str, NULL, 10);
2731         }
2732
2733         /* If peer is peer group, call proper function.  */
2734         ret = str2sockunion(peer_str, &su);
2735         if (ret < 0) {
2736                 /* Check for peer by interface */
2737                 ret = peer_remote_as(bgp, NULL, peer_str, &as, as_type, afi,
2738                                      safi);
2739                 if (ret < 0) {
2740                         ret = peer_group_remote_as(bgp, peer_str, &as, as_type);
2741                         if (ret < 0) {
2742                                 vty_out(vty,
2743                                         "%% Create the peer-group or interface first or specify \"interface\" keyword\n");
2744                                 vty_out(vty, "%% if using an unnumbered interface neighbor\n");
2745                                 return CMD_WARNING_CONFIG_FAILED;
2746                         }
2747                         return CMD_SUCCESS;
2748                 }
2749         } else {
2750                 if (peer_address_self_check(bgp, &su)) {
2751                         vty_out(vty,
2752                                 "%% Can not configure the local system as neighbor\n");
2753                         return CMD_WARNING_CONFIG_FAILED;
2754                 }
2755                 ret = peer_remote_as(bgp, &su, NULL, &as, as_type, afi, safi);
2756         }
2757
2758         /* This peer belongs to peer group.  */
2759         switch (ret) {
2760         case BGP_ERR_PEER_GROUP_MEMBER:
2761                 vty_out(vty,
2762                         "%% Peer-group AS %u. Cannot configure remote-as for member\n",
2763                         as);
2764                 return CMD_WARNING_CONFIG_FAILED;
2765         case BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT:
2766                 vty_out(vty,
2767                         "%% The AS# can not be changed from %u to %s, peer-group members must be all internal or all external\n",
2768                         as, as_str);
2769                 return CMD_WARNING_CONFIG_FAILED;
2770         }
2771         return bgp_vty_return(vty, ret);
2772 }
2773
2774 DEFUN (bgp_default_shutdown,
2775        bgp_default_shutdown_cmd,
2776        "[no] bgp default shutdown",
2777        NO_STR
2778        BGP_STR
2779        "Configure BGP defaults\n"
2780        "Apply administrative shutdown to newly configured peers\n")
2781 {
2782         VTY_DECLVAR_CONTEXT(bgp, bgp);
2783         bgp->autoshutdown = !strmatch(argv[0]->text, "no");
2784         return CMD_SUCCESS;
2785 }
2786
2787 DEFUN (neighbor_remote_as,
2788        neighbor_remote_as_cmd,
2789        "neighbor <A.B.C.D|X:X::X:X|WORD> remote-as <(1-4294967295)|internal|external>",
2790        NEIGHBOR_STR
2791        NEIGHBOR_ADDR_STR2
2792        "Specify a BGP neighbor\n"
2793        AS_STR
2794        "Internal BGP peer\n"
2795        "External BGP peer\n")
2796 {
2797         int idx_peer = 1;
2798         int idx_remote_as = 3;
2799         return peer_remote_as_vty(vty, argv[idx_peer]->arg,
2800                                   argv[idx_remote_as]->arg, AFI_IP,
2801                                   SAFI_UNICAST);
2802 }
2803
2804 static int peer_conf_interface_get(struct vty *vty, const char *conf_if,
2805                                    afi_t afi, safi_t safi, int v6only,
2806                                    const char *peer_group_name,
2807                                    const char *as_str)
2808 {
2809         VTY_DECLVAR_CONTEXT(bgp, bgp);
2810         as_t as = 0;
2811         int as_type = AS_UNSPECIFIED;
2812         struct peer *peer;
2813         struct peer_group *group;
2814         int ret = 0;
2815         union sockunion su;
2816
2817         group = peer_group_lookup(bgp, conf_if);
2818
2819         if (group) {
2820                 vty_out(vty, "%% Name conflict with peer-group \n");
2821                 return CMD_WARNING_CONFIG_FAILED;
2822         }
2823
2824         if (as_str) {
2825                 if (as_str[0] == 'i') {
2826                         as_type = AS_INTERNAL;
2827                 } else if (as_str[0] == 'e') {
2828                         as_type = AS_EXTERNAL;
2829                 } else {
2830                         /* Get AS number.  */
2831                         as = strtoul(as_str, NULL, 10);
2832                         as_type = AS_SPECIFIED;
2833                 }
2834         }
2835
2836         peer = peer_lookup_by_conf_if(bgp, conf_if);
2837         if (peer) {
2838                 if (as_str)
2839                         ret = peer_remote_as(bgp, NULL, conf_if, &as, as_type,
2840                                              afi, safi);
2841         } else {
2842                 if (bgp_flag_check(bgp, BGP_FLAG_NO_DEFAULT_IPV4)
2843                     && afi == AFI_IP && safi == SAFI_UNICAST)
2844                         peer = peer_create(NULL, conf_if, bgp, bgp->as, as,
2845                                            as_type, 0, 0, NULL);
2846                 else
2847                         peer = peer_create(NULL, conf_if, bgp, bgp->as, as,
2848                                            as_type, afi, safi, NULL);
2849
2850                 if (!peer) {
2851                         vty_out(vty, "%% BGP failed to create peer\n");
2852                         return CMD_WARNING_CONFIG_FAILED;
2853                 }
2854
2855                 if (v6only)
2856                         peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
2857
2858                 /* Request zebra to initiate IPv6 RAs on this interface. We do
2859                  * this
2860                  * any unnumbered peer in order to not worry about run-time
2861                  * transitions
2862                  * (e.g., peering is initially IPv4, but the IPv4 /30 or /31
2863                  * address
2864                  * gets deleted later etc.)
2865                  */
2866                 if (peer->ifp)
2867                         bgp_zebra_initiate_radv(bgp, peer);
2868         }
2869
2870         if ((v6only && !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
2871             || (!v6only && CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))) {
2872                 if (v6only)
2873                         peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
2874                 else
2875                         peer_flag_unset(peer, PEER_FLAG_IFPEER_V6ONLY);
2876
2877                 /* v6only flag changed. Reset bgp seesion */
2878                 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2879                         peer->last_reset = PEER_DOWN_V6ONLY_CHANGE;
2880                         bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2881                                         BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2882                 } else
2883                         bgp_session_reset(peer);
2884         }
2885
2886         if (!CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE)) {
2887                 SET_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE);
2888                 SET_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE);
2889                 UNSET_FLAG(peer->flags_override, PEER_FLAG_CAPABILITY_ENHE);
2890         }
2891
2892         if (peer_group_name) {
2893                 group = peer_group_lookup(bgp, peer_group_name);
2894                 if (!group) {
2895                         vty_out(vty, "%% Configure the peer-group first\n");
2896                         return CMD_WARNING_CONFIG_FAILED;
2897                 }
2898
2899                 ret = peer_group_bind(bgp, &su, peer, group, &as);
2900         }
2901
2902         return bgp_vty_return(vty, ret);
2903 }
2904
2905 DEFUN (neighbor_interface_config,
2906        neighbor_interface_config_cmd,
2907        "neighbor WORD interface [peer-group WORD]",
2908        NEIGHBOR_STR
2909        "Interface name or neighbor tag\n"
2910        "Enable BGP on interface\n"
2911        "Member of the peer-group\n"
2912        "Peer-group name\n")
2913 {
2914         int idx_word = 1;
2915         int idx_peer_group_word = 4;
2916
2917         if (argc > idx_peer_group_word)
2918                 return peer_conf_interface_get(
2919                         vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 0,
2920                         argv[idx_peer_group_word]->arg, NULL);
2921         else
2922                 return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2923                                                SAFI_UNICAST, 0, NULL, NULL);
2924 }
2925
2926 DEFUN (neighbor_interface_config_v6only,
2927        neighbor_interface_config_v6only_cmd,
2928        "neighbor WORD interface v6only [peer-group WORD]",
2929        NEIGHBOR_STR
2930        "Interface name or neighbor tag\n"
2931        "Enable BGP on interface\n"
2932        "Enable BGP with v6 link-local only\n"
2933        "Member of the peer-group\n"
2934        "Peer-group name\n")
2935 {
2936         int idx_word = 1;
2937         int idx_peer_group_word = 5;
2938
2939         if (argc > idx_peer_group_word)
2940                 return peer_conf_interface_get(
2941                         vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 1,
2942                         argv[idx_peer_group_word]->arg, NULL);
2943
2944         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2945                                        SAFI_UNICAST, 1, NULL, NULL);
2946 }
2947
2948
2949 DEFUN (neighbor_interface_config_remote_as,
2950        neighbor_interface_config_remote_as_cmd,
2951        "neighbor WORD interface remote-as <(1-4294967295)|internal|external>",
2952        NEIGHBOR_STR
2953        "Interface name or neighbor tag\n"
2954        "Enable BGP on interface\n"
2955        "Specify a BGP neighbor\n"
2956        AS_STR
2957        "Internal BGP peer\n"
2958        "External BGP peer\n")
2959 {
2960         int idx_word = 1;
2961         int idx_remote_as = 4;
2962         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2963                                        SAFI_UNICAST, 0, NULL,
2964                                        argv[idx_remote_as]->arg);
2965 }
2966
2967 DEFUN (neighbor_interface_v6only_config_remote_as,
2968        neighbor_interface_v6only_config_remote_as_cmd,
2969        "neighbor WORD interface v6only remote-as <(1-4294967295)|internal|external>",
2970        NEIGHBOR_STR
2971        "Interface name or neighbor tag\n"
2972        "Enable BGP with v6 link-local only\n"
2973        "Enable BGP on interface\n"
2974        "Specify a BGP neighbor\n"
2975        AS_STR
2976        "Internal BGP peer\n"
2977        "External BGP peer\n")
2978 {
2979         int idx_word = 1;
2980         int idx_remote_as = 5;
2981         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2982                                        SAFI_UNICAST, 1, NULL,
2983                                        argv[idx_remote_as]->arg);
2984 }
2985
2986 DEFUN (neighbor_peer_group,
2987        neighbor_peer_group_cmd,
2988        "neighbor WORD peer-group",
2989        NEIGHBOR_STR
2990        "Interface name or neighbor tag\n"
2991        "Configure peer-group\n")
2992 {
2993         VTY_DECLVAR_CONTEXT(bgp, bgp);
2994         int idx_word = 1;
2995         struct peer *peer;
2996         struct peer_group *group;
2997
2998         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
2999         if (peer) {
3000                 vty_out(vty, "%% Name conflict with interface: \n");
3001                 return CMD_WARNING_CONFIG_FAILED;
3002         }
3003
3004         group = peer_group_get(bgp, argv[idx_word]->arg);
3005         if (!group) {
3006                 vty_out(vty, "%% BGP failed to find or create peer-group\n");
3007                 return CMD_WARNING_CONFIG_FAILED;
3008         }
3009
3010         return CMD_SUCCESS;
3011 }
3012
3013 DEFUN (no_neighbor,
3014        no_neighbor_cmd,
3015        "no neighbor <WORD|<A.B.C.D|X:X::X:X> [remote-as <(1-4294967295)|internal|external>]>",
3016        NO_STR
3017        NEIGHBOR_STR
3018        NEIGHBOR_ADDR_STR2
3019        "Specify a BGP neighbor\n"
3020        AS_STR
3021        "Internal BGP peer\n"
3022        "External BGP peer\n")
3023 {
3024         VTY_DECLVAR_CONTEXT(bgp, bgp);
3025         int idx_peer = 2;
3026         int ret;
3027         union sockunion su;
3028         struct peer_group *group;
3029         struct peer *peer;
3030         struct peer *other;
3031
3032         ret = str2sockunion(argv[idx_peer]->arg, &su);
3033         if (ret < 0) {
3034                 /* look up for neighbor by interface name config. */
3035                 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
3036                 if (peer) {
3037                         /* Request zebra to terminate IPv6 RAs on this
3038                          * interface. */
3039                         if (peer->ifp)
3040                                 bgp_zebra_terminate_radv(peer->bgp, peer);
3041                         peer_delete(peer);
3042                         return CMD_SUCCESS;
3043                 }
3044
3045                 group = peer_group_lookup(bgp, argv[idx_peer]->arg);
3046                 if (group)
3047                         peer_group_delete(group);
3048                 else {
3049                         vty_out(vty, "%% Create the peer-group first\n");
3050                         return CMD_WARNING_CONFIG_FAILED;
3051                 }
3052         } else {
3053                 peer = peer_lookup(bgp, &su);
3054                 if (peer) {
3055                         if (peer_dynamic_neighbor(peer)) {
3056                                 vty_out(vty,
3057                                         "%% Operation not allowed on a dynamic neighbor\n");
3058                                 return CMD_WARNING_CONFIG_FAILED;
3059                         }
3060
3061                         other = peer->doppelganger;
3062                         peer_delete(peer);
3063                         if (other && other->status != Deleted)
3064                                 peer_delete(other);
3065                 }
3066         }
3067
3068         return CMD_SUCCESS;
3069 }
3070
3071 DEFUN (no_neighbor_interface_config,
3072        no_neighbor_interface_config_cmd,
3073        "no neighbor WORD interface [v6only] [peer-group WORD] [remote-as <(1-4294967295)|internal|external>]",
3074        NO_STR
3075        NEIGHBOR_STR
3076        "Interface name\n"
3077        "Configure BGP on interface\n"
3078        "Enable BGP with v6 link-local only\n"
3079        "Member of the peer-group\n"
3080        "Peer-group name\n"
3081        "Specify a BGP neighbor\n"
3082        AS_STR
3083        "Internal BGP peer\n"
3084        "External BGP peer\n")
3085 {
3086         VTY_DECLVAR_CONTEXT(bgp, bgp);
3087         int idx_word = 2;
3088         struct peer *peer;
3089
3090         /* look up for neighbor by interface name config. */
3091         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
3092         if (peer) {
3093                 /* Request zebra to terminate IPv6 RAs on this interface. */
3094                 if (peer->ifp)
3095                         bgp_zebra_terminate_radv(peer->bgp, peer);
3096                 peer_delete(peer);
3097         } else {
3098                 vty_out(vty, "%% Create the bgp interface first\n");
3099                 return CMD_WARNING_CONFIG_FAILED;
3100         }
3101         return CMD_SUCCESS;
3102 }
3103
3104 DEFUN (no_neighbor_peer_group,
3105        no_neighbor_peer_group_cmd,
3106        "no neighbor WORD peer-group",
3107        NO_STR
3108        NEIGHBOR_STR
3109        "Neighbor tag\n"
3110        "Configure peer-group\n")
3111 {
3112         VTY_DECLVAR_CONTEXT(bgp, bgp);
3113         int idx_word = 2;
3114         struct peer_group *group;
3115
3116         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3117         if (group)
3118                 peer_group_delete(group);
3119         else {
3120                 vty_out(vty, "%% Create the peer-group first\n");
3121                 return CMD_WARNING_CONFIG_FAILED;
3122         }
3123         return CMD_SUCCESS;
3124 }
3125
3126 DEFUN (no_neighbor_interface_peer_group_remote_as,
3127        no_neighbor_interface_peer_group_remote_as_cmd,
3128        "no neighbor WORD remote-as <(1-4294967295)|internal|external>",
3129        NO_STR
3130        NEIGHBOR_STR
3131        "Interface name or neighbor tag\n"
3132        "Specify a BGP neighbor\n"
3133        AS_STR
3134        "Internal BGP peer\n"
3135        "External BGP peer\n")
3136 {
3137         VTY_DECLVAR_CONTEXT(bgp, bgp);
3138         int idx_word = 2;
3139         struct peer_group *group;
3140         struct peer *peer;
3141
3142         /* look up for neighbor by interface name config. */
3143         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
3144         if (peer) {
3145                 peer_as_change(peer, 0, AS_SPECIFIED);
3146                 return CMD_SUCCESS;
3147         }
3148
3149         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3150         if (group)
3151                 peer_group_remote_as_delete(group);
3152         else {
3153                 vty_out(vty, "%% Create the peer-group or interface first\n");
3154                 return CMD_WARNING_CONFIG_FAILED;
3155         }
3156         return CMD_SUCCESS;
3157 }
3158
3159 DEFUN (neighbor_local_as,
3160        neighbor_local_as_cmd,
3161        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295)",
3162        NEIGHBOR_STR
3163        NEIGHBOR_ADDR_STR2
3164        "Specify a local-as number\n"
3165        "AS number used as local AS\n")
3166 {
3167         int idx_peer = 1;
3168         int idx_number = 3;
3169         struct peer *peer;
3170         int ret;
3171         as_t as;
3172
3173         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3174         if (!peer)
3175                 return CMD_WARNING_CONFIG_FAILED;
3176
3177         as = strtoul(argv[idx_number]->arg, NULL, 10);
3178         ret = peer_local_as_set(peer, as, 0, 0);
3179         return bgp_vty_return(vty, ret);
3180 }
3181
3182 DEFUN (neighbor_local_as_no_prepend,
3183        neighbor_local_as_no_prepend_cmd,
3184        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend",
3185        NEIGHBOR_STR
3186        NEIGHBOR_ADDR_STR2
3187        "Specify a local-as number\n"
3188        "AS number used as local AS\n"
3189        "Do not prepend local-as to updates from ebgp peers\n")
3190 {
3191         int idx_peer = 1;
3192         int idx_number = 3;
3193         struct peer *peer;
3194         int ret;
3195         as_t as;
3196
3197         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3198         if (!peer)
3199                 return CMD_WARNING_CONFIG_FAILED;
3200
3201         as = strtoul(argv[idx_number]->arg, NULL, 10);
3202         ret = peer_local_as_set(peer, as, 1, 0);
3203         return bgp_vty_return(vty, ret);
3204 }
3205
3206 DEFUN (neighbor_local_as_no_prepend_replace_as,
3207        neighbor_local_as_no_prepend_replace_as_cmd,
3208        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend replace-as",
3209        NEIGHBOR_STR
3210        NEIGHBOR_ADDR_STR2
3211        "Specify a local-as number\n"
3212        "AS number used as local AS\n"
3213        "Do not prepend local-as to updates from ebgp peers\n"
3214        "Do not prepend local-as to updates from ibgp peers\n")
3215 {
3216         int idx_peer = 1;
3217         int idx_number = 3;
3218         struct peer *peer;
3219         int ret;
3220         as_t as;
3221
3222         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3223         if (!peer)
3224                 return CMD_WARNING_CONFIG_FAILED;
3225
3226         as = strtoul(argv[idx_number]->arg, NULL, 10);
3227         ret = peer_local_as_set(peer, as, 1, 1);
3228         return bgp_vty_return(vty, ret);
3229 }
3230
3231 DEFUN (no_neighbor_local_as,
3232        no_neighbor_local_as_cmd,
3233        "no neighbor <A.B.C.D|X:X::X:X|WORD> local-as [(1-4294967295) [no-prepend [replace-as]]]",
3234        NO_STR
3235        NEIGHBOR_STR
3236        NEIGHBOR_ADDR_STR2
3237        "Specify a local-as number\n"
3238        "AS number used as local AS\n"
3239        "Do not prepend local-as to updates from ebgp peers\n"
3240        "Do not prepend local-as to updates from ibgp peers\n")
3241 {
3242         int idx_peer = 2;
3243         struct peer *peer;
3244         int ret;
3245
3246         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3247         if (!peer)
3248                 return CMD_WARNING_CONFIG_FAILED;
3249
3250         ret = peer_local_as_unset(peer);
3251         return bgp_vty_return(vty, ret);
3252 }
3253
3254
3255 DEFUN (neighbor_solo,
3256        neighbor_solo_cmd,
3257        "neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3258        NEIGHBOR_STR
3259        NEIGHBOR_ADDR_STR2
3260        "Solo peer - part of its own update group\n")
3261 {
3262         int idx_peer = 1;
3263         struct peer *peer;
3264         int ret;
3265
3266         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3267         if (!peer)
3268                 return CMD_WARNING_CONFIG_FAILED;
3269
3270         ret = update_group_adjust_soloness(peer, 1);
3271         return bgp_vty_return(vty, ret);
3272 }
3273
3274 DEFUN (no_neighbor_solo,
3275        no_neighbor_solo_cmd,
3276        "no neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3277        NO_STR
3278        NEIGHBOR_STR
3279        NEIGHBOR_ADDR_STR2
3280        "Solo peer - part of its own update group\n")
3281 {
3282         int idx_peer = 2;
3283         struct peer *peer;
3284         int ret;
3285
3286         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3287         if (!peer)
3288                 return CMD_WARNING_CONFIG_FAILED;
3289
3290         ret = update_group_adjust_soloness(peer, 0);
3291         return bgp_vty_return(vty, ret);
3292 }
3293
3294 DEFUN (neighbor_password,
3295        neighbor_password_cmd,
3296        "neighbor <A.B.C.D|X:X::X:X|WORD> password LINE",
3297        NEIGHBOR_STR
3298        NEIGHBOR_ADDR_STR2
3299        "Set a password\n"
3300        "The password\n")
3301 {
3302         int idx_peer = 1;
3303         int idx_line = 3;
3304         struct peer *peer;
3305         int ret;
3306
3307         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3308         if (!peer)
3309                 return CMD_WARNING_CONFIG_FAILED;
3310
3311         ret = peer_password_set(peer, argv[idx_line]->arg);
3312         return bgp_vty_return(vty, ret);
3313 }
3314
3315 DEFUN (no_neighbor_password,
3316        no_neighbor_password_cmd,
3317        "no neighbor <A.B.C.D|X:X::X:X|WORD> password [LINE]",
3318        NO_STR
3319        NEIGHBOR_STR
3320        NEIGHBOR_ADDR_STR2
3321        "Set a password\n"
3322        "The password\n")
3323 {
3324         int idx_peer = 2;
3325         struct peer *peer;
3326         int ret;
3327
3328         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3329         if (!peer)
3330                 return CMD_WARNING_CONFIG_FAILED;
3331
3332         ret = peer_password_unset(peer);
3333         return bgp_vty_return(vty, ret);
3334 }
3335
3336 DEFUN (neighbor_activate,
3337        neighbor_activate_cmd,
3338        "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3339        NEIGHBOR_STR
3340        NEIGHBOR_ADDR_STR2
3341        "Enable the Address Family for this Neighbor\n")
3342 {
3343         int idx_peer = 1;
3344         int ret;
3345         struct peer *peer;
3346
3347         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3348         if (!peer)
3349                 return CMD_WARNING_CONFIG_FAILED;
3350
3351         ret = peer_activate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
3352         return bgp_vty_return(vty, ret);
3353 }
3354
3355 ALIAS_HIDDEN(neighbor_activate, neighbor_activate_hidden_cmd,
3356              "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3357              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3358              "Enable the Address Family for this Neighbor\n")
3359
3360 DEFUN (no_neighbor_activate,
3361        no_neighbor_activate_cmd,
3362        "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3363        NO_STR
3364        NEIGHBOR_STR
3365        NEIGHBOR_ADDR_STR2
3366        "Enable the Address Family for this Neighbor\n")
3367 {
3368         int idx_peer = 2;
3369         int ret;
3370         struct peer *peer;
3371
3372         /* Lookup peer. */
3373         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3374         if (!peer)
3375                 return CMD_WARNING_CONFIG_FAILED;
3376
3377         ret = peer_deactivate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
3378         return bgp_vty_return(vty, ret);
3379 }
3380
3381 ALIAS_HIDDEN(no_neighbor_activate, no_neighbor_activate_hidden_cmd,
3382              "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3383              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3384              "Enable the Address Family for this Neighbor\n")
3385
3386 DEFUN (neighbor_set_peer_group,
3387        neighbor_set_peer_group_cmd,
3388        "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3389        NEIGHBOR_STR
3390        NEIGHBOR_ADDR_STR2
3391        "Member of the peer-group\n"
3392        "Peer-group name\n")
3393 {
3394         VTY_DECLVAR_CONTEXT(bgp, bgp);
3395         int idx_peer = 1;
3396         int idx_word = 3;
3397         int ret;
3398         as_t as;
3399         union sockunion su;
3400         struct peer *peer;
3401         struct peer_group *group;
3402
3403         ret = str2sockunion(argv[idx_peer]->arg, &su);
3404         if (ret < 0) {
3405                 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
3406                 if (!peer) {
3407                         vty_out(vty, "%% Malformed address or name: %s\n",
3408                                 argv[idx_peer]->arg);
3409                         return CMD_WARNING_CONFIG_FAILED;
3410                 }
3411         } else {
3412                 if (peer_address_self_check(bgp, &su)) {
3413                         vty_out(vty,
3414                                 "%% Can not configure the local system as neighbor\n");
3415                         return CMD_WARNING_CONFIG_FAILED;
3416                 }
3417
3418                 /* Disallow for dynamic neighbor. */
3419                 peer = peer_lookup(bgp, &su);
3420                 if (peer && peer_dynamic_neighbor(peer)) {
3421                         vty_out(vty,
3422                                 "%% Operation not allowed on a dynamic neighbor\n");
3423                         return CMD_WARNING_CONFIG_FAILED;
3424                 }
3425         }
3426
3427         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3428         if (!group) {
3429                 vty_out(vty, "%% Configure the peer-group first\n");
3430                 return CMD_WARNING_CONFIG_FAILED;
3431         }
3432
3433         ret = peer_group_bind(bgp, &su, peer, group, &as);
3434
3435         if (ret == BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT) {
3436                 vty_out(vty,
3437                         "%% Peer with AS %u cannot be in this peer-group, members must be all internal or all external\n",
3438                         as);
3439                 return CMD_WARNING_CONFIG_FAILED;
3440         }
3441
3442         return bgp_vty_return(vty, ret);
3443 }
3444
3445 ALIAS_HIDDEN(neighbor_set_peer_group, neighbor_set_peer_group_hidden_cmd,
3446              "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3447              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3448              "Member of the peer-group\n"
3449              "Peer-group name\n")
3450
3451 DEFUN (no_neighbor_set_peer_group,
3452        no_neighbor_set_peer_group_cmd,
3453        "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3454        NO_STR
3455        NEIGHBOR_STR
3456        NEIGHBOR_ADDR_STR2
3457        "Member of the peer-group\n"
3458        "Peer-group name\n")
3459 {
3460         VTY_DECLVAR_CONTEXT(bgp, bgp);
3461         int idx_peer = 2;
3462         int idx_word = 4;
3463         int ret;
3464         struct peer *peer;
3465         struct peer_group *group;
3466
3467         peer = peer_lookup_vty(vty, argv[idx_peer]->arg);
3468         if (!peer)
3469                 return CMD_WARNING_CONFIG_FAILED;
3470
3471         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3472         if (!group) {
3473                 vty_out(vty, "%% Configure the peer-group first\n");
3474                 return CMD_WARNING_CONFIG_FAILED;
3475         }
3476
3477         ret = peer_delete(peer);
3478
3479         return bgp_vty_return(vty, ret);
3480 }
3481
3482 ALIAS_HIDDEN(no_neighbor_set_peer_group, no_neighbor_set_peer_group_hidden_cmd,
3483              "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3484              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3485              "Member of the peer-group\n"
3486              "Peer-group name\n")
3487
3488 static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
3489                                 uint32_t flag, int set)
3490 {
3491         int ret;
3492         struct peer *peer;
3493
3494         peer = peer_and_group_lookup_vty(vty, ip_str);
3495         if (!peer)
3496                 return CMD_WARNING_CONFIG_FAILED;
3497
3498         /*
3499          * If 'neighbor <interface>', then this is for directly connected peers,
3500          * we should not accept disable-connected-check.
3501          */
3502         if (peer->conf_if && (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)) {
3503                 vty_out(vty,
3504                         "%s is directly connected peer, cannot accept disable-"
3505                         "connected-check\n",
3506                         ip_str);
3507                 return CMD_WARNING_CONFIG_FAILED;
3508         }
3509
3510         if (!set && flag == PEER_FLAG_SHUTDOWN)
3511                 peer_tx_shutdown_message_unset(peer);
3512
3513         if (set)
3514                 ret = peer_flag_set(peer, flag);
3515         else
3516                 ret = peer_flag_unset(peer, flag);
3517
3518         return bgp_vty_return(vty, ret);
3519 }
3520
3521 static int peer_flag_set_vty(struct vty *vty, const char *ip_str, uint32_t flag)
3522 {
3523         return peer_flag_modify_vty(vty, ip_str, flag, 1);
3524 }
3525
3526 static int peer_flag_unset_vty(struct vty *vty, const char *ip_str,
3527                                uint32_t flag)
3528 {
3529         return peer_flag_modify_vty(vty, ip_str, flag, 0);
3530 }
3531
3532 /* neighbor passive. */
3533 DEFUN (neighbor_passive,
3534        neighbor_passive_cmd,
3535        "neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3536        NEIGHBOR_STR
3537        NEIGHBOR_ADDR_STR2
3538        "Don't send open messages to this neighbor\n")
3539 {
3540         int idx_peer = 1;
3541         return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3542 }
3543
3544 DEFUN (no_neighbor_passive,
3545        no_neighbor_passive_cmd,
3546        "no neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3547        NO_STR
3548        NEIGHBOR_STR
3549        NEIGHBOR_ADDR_STR2
3550        "Don't send open messages to this neighbor\n")
3551 {
3552         int idx_peer = 2;
3553         return peer_flag_unset_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3554 }
3555
3556 /* neighbor shutdown. */
3557 DEFUN (neighbor_shutdown_msg,
3558        neighbor_shutdown_msg_cmd,
3559        "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3560        NEIGHBOR_STR
3561        NEIGHBOR_ADDR_STR2
3562        "Administratively shut down this neighbor\n"
3563        "Add a shutdown message (draft-ietf-idr-shutdown-06)\n"
3564        "Shutdown message\n")
3565 {
3566         int idx_peer = 1;
3567
3568         if (argc >= 5) {
3569                 struct peer *peer =
3570                         peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3571                 char *message;
3572
3573                 if (!peer)
3574                         return CMD_WARNING_CONFIG_FAILED;
3575                 message = argv_concat(argv, argc, 4);
3576                 peer_tx_shutdown_message_set(peer, message);
3577                 XFREE(MTYPE_TMP, message);
3578         }
3579
3580         return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
3581 }
3582
3583 ALIAS(neighbor_shutdown_msg, neighbor_shutdown_cmd,
3584       "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3585       NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3586       "Administratively shut down this neighbor\n")
3587
3588 DEFUN (no_neighbor_shutdown_msg,
3589        no_neighbor_shutdown_msg_cmd,
3590        "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3591        NO_STR
3592        NEIGHBOR_STR
3593        NEIGHBOR_ADDR_STR2
3594        "Administratively shut down this neighbor\n"
3595        "Remove a shutdown message (draft-ietf-idr-shutdown-06)\n"
3596        "Shutdown message\n")
3597 {
3598         int idx_peer = 2;
3599
3600         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3601                                    PEER_FLAG_SHUTDOWN);
3602 }
3603
3604 ALIAS(no_neighbor_shutdown_msg, no_neighbor_shutdown_cmd,
3605       "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3606       NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3607       "Administratively shut down this neighbor\n")
3608
3609 /* neighbor capability dynamic. */
3610 DEFUN (neighbor_capability_dynamic,
3611        neighbor_capability_dynamic_cmd,
3612        "neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3613        NEIGHBOR_STR
3614        NEIGHBOR_ADDR_STR2
3615        "Advertise capability to the peer\n"
3616        "Advertise dynamic capability to this neighbor\n")
3617 {
3618         int idx_peer = 1;
3619         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3620                                  PEER_FLAG_DYNAMIC_CAPABILITY);
3621 }
3622
3623 DEFUN (no_neighbor_capability_dynamic,
3624        no_neighbor_capability_dynamic_cmd,
3625        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3626        NO_STR
3627        NEIGHBOR_STR
3628        NEIGHBOR_ADDR_STR2
3629        "Advertise capability to the peer\n"
3630        "Advertise dynamic capability to this neighbor\n")
3631 {
3632         int idx_peer = 2;
3633         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3634                                    PEER_FLAG_DYNAMIC_CAPABILITY);
3635 }
3636
3637 /* neighbor dont-capability-negotiate */
3638 DEFUN (neighbor_dont_capability_negotiate,
3639        neighbor_dont_capability_negotiate_cmd,
3640        "neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3641        NEIGHBOR_STR
3642        NEIGHBOR_ADDR_STR2
3643        "Do not perform capability negotiation\n")
3644 {
3645         int idx_peer = 1;
3646         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3647                                  PEER_FLAG_DONT_CAPABILITY);
3648 }
3649
3650 DEFUN (no_neighbor_dont_capability_negotiate,
3651        no_neighbor_dont_capability_negotiate_cmd,
3652        "no neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3653        NO_STR
3654        NEIGHBOR_STR
3655        NEIGHBOR_ADDR_STR2
3656        "Do not perform capability negotiation\n")
3657 {
3658         int idx_peer = 2;
3659         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3660                                    PEER_FLAG_DONT_CAPABILITY);
3661 }
3662
3663 /* neighbor capability extended next hop encoding */
3664 DEFUN (neighbor_capability_enhe,
3665        neighbor_capability_enhe_cmd,
3666        "neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3667        NEIGHBOR_STR
3668        NEIGHBOR_ADDR_STR2
3669        "Advertise capability to the peer\n"
3670        "Advertise extended next-hop capability to the peer\n")
3671 {
3672         int idx_peer = 1;
3673         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3674                                  PEER_FLAG_CAPABILITY_ENHE);
3675 }
3676
3677 DEFUN (no_neighbor_capability_enhe,
3678        no_neighbor_capability_enhe_cmd,
3679        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3680        NO_STR
3681        NEIGHBOR_STR
3682        NEIGHBOR_ADDR_STR2
3683        "Advertise capability to the peer\n"
3684        "Advertise extended next-hop capability to the peer\n")
3685 {
3686         int idx_peer = 2;
3687         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3688                                    PEER_FLAG_CAPABILITY_ENHE);
3689 }
3690
3691 static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
3692                                    afi_t afi, safi_t safi, uint32_t flag,
3693                                    int set)
3694 {
3695         int ret;
3696         struct peer *peer;
3697
3698         peer = peer_and_group_lookup_vty(vty, peer_str);
3699         if (!peer)
3700                 return CMD_WARNING_CONFIG_FAILED;
3701
3702         if (set)
3703                 ret = peer_af_flag_set(peer, afi, safi, flag);
3704         else
3705                 ret = peer_af_flag_unset(peer, afi, safi, flag);
3706
3707         return bgp_vty_return(vty, ret);
3708 }
3709
3710 static int peer_af_flag_set_vty(struct vty *vty, const char *peer_str,
3711                                 afi_t afi, safi_t safi, uint32_t flag)
3712 {
3713         return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 1);
3714 }
3715
3716 static int peer_af_flag_unset_vty(struct vty *vty, const char *peer_str,
3717                                   afi_t afi, safi_t safi, uint32_t flag)
3718 {
3719         return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 0);
3720 }
3721
3722 /* neighbor capability orf prefix-list. */
3723 DEFUN (neighbor_capability_orf_prefix,
3724        neighbor_capability_orf_prefix_cmd,
3725        "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3726        NEIGHBOR_STR
3727        NEIGHBOR_ADDR_STR2
3728        "Advertise capability to the peer\n"
3729        "Advertise ORF capability to the peer\n"
3730        "Advertise prefixlist ORF capability to this neighbor\n"
3731        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3732        "Capability to RECEIVE the ORF from this neighbor\n"
3733        "Capability to SEND the ORF to this neighbor\n")
3734 {
3735         int idx_peer = 1;
3736         int idx_send_recv = 5;
3737         uint16_t flag = 0;
3738
3739         if (strmatch(argv[idx_send_recv]->text, "send"))
3740                 flag = PEER_FLAG_ORF_PREFIX_SM;
3741         else if (strmatch(argv[idx_send_recv]->text, "receive"))
3742                 flag = PEER_FLAG_ORF_PREFIX_RM;
3743         else if (strmatch(argv[idx_send_recv]->text, "both"))
3744                 flag = PEER_FLAG_ORF_PREFIX_SM | PEER_FLAG_ORF_PREFIX_RM;
3745         else {
3746                 vty_out(vty, "%% BGP invalid orf prefix-list option\n");
3747                 return CMD_WARNING_CONFIG_FAILED;
3748         }
3749
3750         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3751                                     bgp_node_safi(vty), flag);
3752 }
3753
3754 ALIAS_HIDDEN(
3755         neighbor_capability_orf_prefix,
3756         neighbor_capability_orf_prefix_hidden_cmd,
3757         "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3758         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3759         "Advertise capability to the peer\n"
3760         "Advertise ORF capability to the peer\n"
3761         "Advertise prefixlist ORF capability to this neighbor\n"
3762         "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3763         "Capability to RECEIVE the ORF from this neighbor\n"
3764         "Capability to SEND the ORF to this neighbor\n")
3765
3766 DEFUN (no_neighbor_capability_orf_prefix,
3767        no_neighbor_capability_orf_prefix_cmd,
3768        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3769        NO_STR
3770        NEIGHBOR_STR
3771        NEIGHBOR_ADDR_STR2
3772        "Advertise capability to the peer\n"
3773        "Advertise ORF capability to the peer\n"
3774        "Advertise prefixlist ORF capability to this neighbor\n"
3775        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3776        "Capability to RECEIVE the ORF from this neighbor\n"
3777        "Capability to SEND the ORF to this neighbor\n")
3778 {
3779         int idx_peer = 2;
3780         int idx_send_recv = 6;
3781         uint16_t flag = 0;
3782
3783         if (strmatch(argv[idx_send_recv]->text, "send"))
3784                 flag = PEER_FLAG_ORF_PREFIX_SM;
3785         else if (strmatch(argv[idx_send_recv]->text, "receive"))
3786                 flag = PEER_FLAG_ORF_PREFIX_RM;
3787         else if (strmatch(argv[idx_send_recv]->text, "both"))
3788                 flag = PEER_FLAG_ORF_PREFIX_SM | PEER_FLAG_ORF_PREFIX_RM;
3789         else {
3790                 vty_out(vty, "%% BGP invalid orf prefix-list option\n");
3791                 return CMD_WARNING_CONFIG_FAILED;
3792         }
3793
3794         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3795                                       bgp_node_afi(vty), bgp_node_safi(vty),
3796                                       flag);
3797 }
3798
3799 ALIAS_HIDDEN(
3800         no_neighbor_capability_orf_prefix,
3801         no_neighbor_capability_orf_prefix_hidden_cmd,
3802         "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3803         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3804         "Advertise capability to the peer\n"
3805         "Advertise ORF capability to the peer\n"
3806         "Advertise prefixlist ORF capability to this neighbor\n"
3807         "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3808         "Capability to RECEIVE the ORF from this neighbor\n"
3809         "Capability to SEND the ORF to this neighbor\n")
3810
3811 /* neighbor next-hop-self. */
3812 DEFUN (neighbor_nexthop_self,
3813        neighbor_nexthop_self_cmd,
3814        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3815        NEIGHBOR_STR
3816        NEIGHBOR_ADDR_STR2
3817        "Disable the next hop calculation for this neighbor\n")
3818 {
3819         int idx_peer = 1;
3820         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3821                                     bgp_node_safi(vty), PEER_FLAG_NEXTHOP_SELF);
3822 }
3823
3824 ALIAS_HIDDEN(neighbor_nexthop_self, neighbor_nexthop_self_hidden_cmd,
3825              "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3826              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3827              "Disable the next hop calculation for this neighbor\n")
3828
3829 /* neighbor next-hop-self. */
3830 DEFUN (neighbor_nexthop_self_force,
3831        neighbor_nexthop_self_force_cmd,
3832        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3833        NEIGHBOR_STR
3834        NEIGHBOR_ADDR_STR2
3835        "Disable the next hop calculation for this neighbor\n"
3836        "Set the next hop to self for reflected routes\n")
3837 {
3838         int idx_peer = 1;
3839         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3840                                     bgp_node_safi(vty),
3841                                     PEER_FLAG_FORCE_NEXTHOP_SELF);
3842 }
3843
3844 ALIAS_HIDDEN(neighbor_nexthop_self_force,
3845              neighbor_nexthop_self_force_hidden_cmd,
3846              "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3847              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3848              "Disable the next hop calculation for this neighbor\n"
3849              "Set the next hop to self for reflected routes\n")
3850
3851 DEFUN (no_neighbor_nexthop_self,
3852        no_neighbor_nexthop_self_cmd,
3853        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3854        NO_STR
3855        NEIGHBOR_STR
3856        NEIGHBOR_ADDR_STR2
3857        "Disable the next hop calculation for this neighbor\n")
3858 {
3859         int idx_peer = 2;
3860         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3861                                       bgp_node_afi(vty), bgp_node_safi(vty),
3862                                       PEER_FLAG_NEXTHOP_SELF);
3863 }
3864
3865 ALIAS_HIDDEN(no_neighbor_nexthop_self, no_neighbor_nexthop_self_hidden_cmd,
3866              "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3867              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3868              "Disable the next hop calculation for this neighbor\n")
3869
3870 DEFUN (no_neighbor_nexthop_self_force,
3871        no_neighbor_nexthop_self_force_cmd,
3872        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3873        NO_STR
3874        NEIGHBOR_STR
3875        NEIGHBOR_ADDR_STR2
3876        "Disable the next hop calculation for this neighbor\n"
3877        "Set the next hop to self for reflected routes\n")
3878 {
3879         int idx_peer = 2;
3880         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3881                                       bgp_node_afi(vty), bgp_node_safi(vty),
3882                                       PEER_FLAG_FORCE_NEXTHOP_SELF);
3883 }
3884
3885 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
3886              no_neighbor_nexthop_self_force_hidden_cmd,
3887              "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3888              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3889              "Disable the next hop calculation for this neighbor\n"
3890              "Set the next hop to self for reflected routes\n")
3891
3892 /* neighbor as-override */
3893 DEFUN (neighbor_as_override,
3894        neighbor_as_override_cmd,
3895        "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3896        NEIGHBOR_STR
3897        NEIGHBOR_ADDR_STR2
3898        "Override ASNs in outbound updates if aspath equals remote-as\n")
3899 {
3900         int idx_peer = 1;
3901         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3902                                     bgp_node_safi(vty), PEER_FLAG_AS_OVERRIDE);
3903 }
3904
3905 ALIAS_HIDDEN(neighbor_as_override, neighbor_as_override_hidden_cmd,
3906              "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3907              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3908              "Override ASNs in outbound updates if aspath equals remote-as\n")
3909
3910 DEFUN (no_neighbor_as_override,
3911        no_neighbor_as_override_cmd,
3912        "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3913        NO_STR
3914        NEIGHBOR_STR
3915        NEIGHBOR_ADDR_STR2
3916        "Override ASNs in outbound updates if aspath equals remote-as\n")
3917 {
3918         int idx_peer = 2;
3919         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3920                                       bgp_node_afi(vty), bgp_node_safi(vty),
3921                                       PEER_FLAG_AS_OVERRIDE);
3922 }
3923
3924 ALIAS_HIDDEN(no_neighbor_as_override, no_neighbor_as_override_hidden_cmd,
3925              "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3926              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3927              "Override ASNs in outbound updates if aspath equals remote-as\n")
3928
3929 /* neighbor remove-private-AS. */
3930 DEFUN (neighbor_remove_private_as,
3931        neighbor_remove_private_as_cmd,
3932        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3933        NEIGHBOR_STR
3934        NEIGHBOR_ADDR_STR2
3935        "Remove private ASNs in outbound updates\n")
3936 {
3937         int idx_peer = 1;
3938         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3939                                     bgp_node_safi(vty),
3940                                     PEER_FLAG_REMOVE_PRIVATE_AS);
3941 }
3942
3943 ALIAS_HIDDEN(neighbor_remove_private_as, neighbor_remove_private_as_hidden_cmd,
3944              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3945              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3946              "Remove private ASNs in outbound updates\n")
3947
3948 DEFUN (neighbor_remove_private_as_all,
3949        neighbor_remove_private_as_all_cmd,
3950        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
3951        NEIGHBOR_STR
3952        NEIGHBOR_ADDR_STR2
3953        "Remove private ASNs in outbound updates\n"
3954        "Apply to all AS numbers\n")
3955 {
3956         int idx_peer = 1;
3957         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3958                                     bgp_node_safi(vty),
3959                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
3960 }
3961
3962 ALIAS_HIDDEN(neighbor_remove_private_as_all,
3963              neighbor_remove_private_as_all_hidden_cmd,
3964              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
3965              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3966              "Remove private ASNs in outbound updates\n"
3967              "Apply to all AS numbers")
3968
3969 DEFUN (neighbor_remove_private_as_replace_as,
3970        neighbor_remove_private_as_replace_as_cmd,
3971        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
3972        NEIGHBOR_STR
3973        NEIGHBOR_ADDR_STR2
3974        "Remove private ASNs in outbound updates\n"
3975        "Replace private ASNs with our ASN in outbound updates\n")
3976 {
3977         int idx_peer = 1;
3978         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3979                                     bgp_node_safi(vty),
3980                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
3981 }
3982
3983 ALIAS_HIDDEN(neighbor_remove_private_as_replace_as,
3984              neighbor_remove_private_as_replace_as_hidden_cmd,
3985              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
3986              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3987              "Remove private ASNs in outbound updates\n"
3988              "Replace private ASNs with our ASN in outbound updates\n")
3989
3990 DEFUN (neighbor_remove_private_as_all_replace_as,
3991        neighbor_remove_private_as_all_replace_as_cmd,
3992        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
3993        NEIGHBOR_STR
3994        NEIGHBOR_ADDR_STR2
3995        "Remove private ASNs in outbound updates\n"
3996        "Apply to all AS numbers\n"
3997        "Replace private ASNs with our ASN in outbound updates\n")
3998 {
3999         int idx_peer = 1;
4000         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4001                                     bgp_node_safi(vty),
4002                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
4003 }
4004
4005 ALIAS_HIDDEN(
4006         neighbor_remove_private_as_all_replace_as,
4007         neighbor_remove_private_as_all_replace_as_hidden_cmd,
4008         "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4009         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4010         "Remove private ASNs in outbound updates\n"
4011         "Apply to all AS numbers\n"
4012         "Replace private ASNs with our ASN in outbound updates\n")
4013
4014 DEFUN (no_neighbor_remove_private_as,
4015        no_neighbor_remove_private_as_cmd,
4016        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
4017        NO_STR
4018        NEIGHBOR_STR
4019        NEIGHBOR_ADDR_STR2
4020        "Remove private ASNs in outbound updates\n")
4021 {
4022         int idx_peer = 2;
4023         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4024                                       bgp_node_afi(vty), bgp_node_safi(vty),
4025                                       PEER_FLAG_REMOVE_PRIVATE_AS);
4026 }
4027
4028 ALIAS_HIDDEN(no_neighbor_remove_private_as,
4029              no_neighbor_remove_private_as_hidden_cmd,
4030              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
4031              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4032              "Remove private ASNs in outbound updates\n")
4033
4034 DEFUN (no_neighbor_remove_private_as_all,
4035        no_neighbor_remove_private_as_all_cmd,
4036        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4037        NO_STR
4038        NEIGHBOR_STR
4039        NEIGHBOR_ADDR_STR2
4040        "Remove private ASNs in outbound updates\n"
4041        "Apply to all AS numbers\n")
4042 {
4043         int idx_peer = 2;
4044         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4045                                       bgp_node_afi(vty), bgp_node_safi(vty),
4046                                       PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
4047 }
4048
4049 ALIAS_HIDDEN(no_neighbor_remove_private_as_all,
4050              no_neighbor_remove_private_as_all_hidden_cmd,
4051              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4052              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4053              "Remove private ASNs in outbound updates\n"
4054              "Apply to all AS numbers\n")
4055
4056 DEFUN (no_neighbor_remove_private_as_replace_as,
4057        no_neighbor_remove_private_as_replace_as_cmd,
4058        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4059        NO_STR
4060        NEIGHBOR_STR
4061        NEIGHBOR_ADDR_STR2
4062        "Remove private ASNs in outbound updates\n"
4063        "Replace private ASNs with our ASN in outbound updates\n")
4064 {
4065         int idx_peer = 2;
4066         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4067                                       bgp_node_afi(vty), bgp_node_safi(vty),
4068                                       PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
4069 }
4070
4071 ALIAS_HIDDEN(no_neighbor_remove_private_as_replace_as,
4072              no_neighbor_remove_private_as_replace_as_hidden_cmd,
4073              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4074              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4075              "Remove private ASNs in outbound updates\n"
4076              "Replace private ASNs with our ASN in outbound updates\n")
4077
4078 DEFUN (no_neighbor_remove_private_as_all_replace_as,
4079        no_neighbor_remove_private_as_all_replace_as_cmd,
4080        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4081        NO_STR
4082        NEIGHBOR_STR
4083        NEIGHBOR_ADDR_STR2
4084        "Remove private ASNs in outbound updates\n"
4085        "Apply to all AS numbers\n"
4086        "Replace private ASNs with our ASN in outbound updates\n")
4087 {
4088         int idx_peer = 2;
4089         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4090                                       bgp_node_afi(vty), bgp_node_safi(vty),
4091                                       PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
4092 }
4093
4094 ALIAS_HIDDEN(
4095         no_neighbor_remove_private_as_all_replace_as,
4096         no_neighbor_remove_private_as_all_replace_as_hidden_cmd,
4097         "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4098         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4099         "Remove private ASNs in outbound updates\n"
4100         "Apply to all AS numbers\n"
4101         "Replace private ASNs with our ASN in outbound updates\n")
4102
4103
4104 /* neighbor send-community. */
4105 DEFUN (neighbor_send_community,
4106        neighbor_send_community_cmd,
4107        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4108        NEIGHBOR_STR
4109        NEIGHBOR_ADDR_STR2
4110        "Send Community attribute to this neighbor\n")
4111 {
4112         int idx_peer = 1;
4113
4114         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4115                                     bgp_node_safi(vty),
4116                                     PEER_FLAG_SEND_COMMUNITY);
4117 }
4118
4119 ALIAS_HIDDEN(neighbor_send_community, neighbor_send_community_hidden_cmd,
4120              "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4121              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4122              "Send Community attribute to this neighbor\n")
4123
4124 DEFUN (no_neighbor_send_community,
4125        no_neighbor_send_community_cmd,
4126        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4127        NO_STR
4128        NEIGHBOR_STR
4129        NEIGHBOR_ADDR_STR2
4130        "Send Community attribute to this neighbor\n")
4131 {
4132         int idx_peer = 2;
4133
4134         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4135                                       bgp_node_afi(vty), bgp_node_safi(vty),
4136                                       PEER_FLAG_SEND_COMMUNITY);
4137 }
4138
4139 ALIAS_HIDDEN(no_neighbor_send_community, no_neighbor_send_community_hidden_cmd,
4140              "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4141              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4142              "Send Community attribute to this neighbor\n")
4143
4144 /* neighbor send-community extended. */
4145 DEFUN (neighbor_send_community_type,
4146        neighbor_send_community_type_cmd,
4147        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4148        NEIGHBOR_STR
4149        NEIGHBOR_ADDR_STR2
4150        "Send Community attribute to this neighbor\n"
4151        "Send Standard and Extended Community attributes\n"
4152        "Send Standard, Large and Extended Community attributes\n"
4153        "Send Extended Community attributes\n"
4154        "Send Standard Community attributes\n"
4155        "Send Large Community attributes\n")
4156 {
4157         int idx_peer = 1;
4158         uint32_t flag = 0;
4159         const char *type = argv[argc - 1]->text;
4160
4161         if (strmatch(type, "standard")) {
4162                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4163         } else if (strmatch(type, "extended")) {
4164                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4165         } else if (strmatch(type, "large")) {
4166                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4167         } else if (strmatch(type, "both")) {
4168                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4169                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4170         } else { /* if (strmatch(type, "all")) */
4171                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4172                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4173                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4174         }
4175
4176         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4177                                     bgp_node_safi(vty), flag);
4178 }
4179
4180 ALIAS_HIDDEN(
4181         neighbor_send_community_type, neighbor_send_community_type_hidden_cmd,
4182         "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4183         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4184         "Send Community attribute to this neighbor\n"
4185         "Send Standard and Extended Community attributes\n"
4186         "Send Standard, Large and Extended Community attributes\n"
4187         "Send Extended Community attributes\n"
4188         "Send Standard Community attributes\n"
4189         "Send Large Community attributes\n")
4190
4191 DEFUN (no_neighbor_send_community_type,
4192        no_neighbor_send_community_type_cmd,
4193        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4194        NO_STR
4195        NEIGHBOR_STR
4196        NEIGHBOR_ADDR_STR2
4197        "Send Community attribute to this neighbor\n"
4198        "Send Standard and Extended Community attributes\n"
4199        "Send Standard, Large and Extended Community attributes\n"
4200        "Send Extended Community attributes\n"
4201        "Send Standard Community attributes\n"
4202        "Send Large Community attributes\n")
4203 {
4204         int idx_peer = 2;
4205         uint32_t flag = 0;
4206         const char *type = argv[argc - 1]->text;
4207
4208         if (strmatch(type, "standard")) {
4209                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4210         } else if (strmatch(type, "extended")) {
4211                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4212         } else if (strmatch(type, "large")) {
4213                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4214         } else if (strmatch(type, "both")) {
4215                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4216                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4217         } else { /* if (strmatch(type, "all")) */
4218                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4219                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4220                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4221         }
4222
4223         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4224                                       bgp_node_afi(vty), bgp_node_safi(vty),
4225                                       flag);
4226 }
4227
4228 ALIAS_HIDDEN(
4229         no_neighbor_send_community_type,
4230         no_neighbor_send_community_type_hidden_cmd,
4231         "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4232         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4233         "Send Community attribute to this neighbor\n"
4234         "Send Standard and Extended Community attributes\n"
4235         "Send Standard, Large and Extended Community attributes\n"
4236         "Send Extended Community attributes\n"
4237         "Send Standard Community attributes\n"
4238         "Send Large Community attributes\n")
4239
4240 /* neighbor soft-reconfig. */
4241 DEFUN (neighbor_soft_reconfiguration,
4242        neighbor_soft_reconfiguration_cmd,
4243        "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4244        NEIGHBOR_STR
4245        NEIGHBOR_ADDR_STR2
4246        "Per neighbor soft reconfiguration\n"
4247        "Allow inbound soft reconfiguration for this neighbor\n")
4248 {
4249         int idx_peer = 1;
4250         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4251                                     bgp_node_safi(vty),
4252                                     PEER_FLAG_SOFT_RECONFIG);
4253 }
4254
4255 ALIAS_HIDDEN(neighbor_soft_reconfiguration,
4256              neighbor_soft_reconfiguration_hidden_cmd,
4257              "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4258              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4259              "Per neighbor soft reconfiguration\n"
4260              "Allow inbound soft reconfiguration for this neighbor\n")
4261
4262 DEFUN (no_neighbor_soft_reconfiguration,
4263        no_neighbor_soft_reconfiguration_cmd,
4264        "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4265        NO_STR
4266        NEIGHBOR_STR
4267        NEIGHBOR_ADDR_STR2
4268        "Per neighbor soft reconfiguration\n"
4269        "Allow inbound soft reconfiguration for this neighbor\n")
4270 {
4271         int idx_peer = 2;
4272         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4273                                       bgp_node_afi(vty), bgp_node_safi(vty),
4274                                       PEER_FLAG_SOFT_RECONFIG);
4275 }
4276
4277 ALIAS_HIDDEN(no_neighbor_soft_reconfiguration,
4278              no_neighbor_soft_reconfiguration_hidden_cmd,
4279              "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4280              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4281              "Per neighbor soft reconfiguration\n"
4282              "Allow inbound soft reconfiguration for this neighbor\n")
4283
4284 DEFUN (neighbor_route_reflector_client,
4285        neighbor_route_reflector_client_cmd,
4286        "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4287        NEIGHBOR_STR
4288        NEIGHBOR_ADDR_STR2
4289        "Configure a neighbor as Route Reflector client\n")
4290 {
4291         int idx_peer = 1;
4292         struct peer *peer;
4293
4294
4295         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4296         if (!peer)
4297                 return CMD_WARNING_CONFIG_FAILED;
4298
4299         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4300                                     bgp_node_safi(vty),
4301                                     PEER_FLAG_REFLECTOR_CLIENT);
4302 }
4303
4304 ALIAS_HIDDEN(neighbor_route_reflector_client,
4305              neighbor_route_reflector_client_hidden_cmd,
4306              "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4307              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4308              "Configure a neighbor as Route Reflector client\n")
4309
4310 DEFUN (no_neighbor_route_reflector_client,
4311        no_neighbor_route_reflector_client_cmd,
4312        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4313        NO_STR
4314        NEIGHBOR_STR
4315        NEIGHBOR_ADDR_STR2
4316        "Configure a neighbor as Route Reflector client\n")
4317 {
4318         int idx_peer = 2;
4319         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4320                                       bgp_node_afi(vty), bgp_node_safi(vty),
4321                                       PEER_FLAG_REFLECTOR_CLIENT);
4322 }
4323
4324 ALIAS_HIDDEN(no_neighbor_route_reflector_client,
4325              no_neighbor_route_reflector_client_hidden_cmd,
4326              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4327              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4328              "Configure a neighbor as Route Reflector client\n")
4329
4330 /* neighbor route-server-client. */
4331 DEFUN (neighbor_route_server_client,
4332        neighbor_route_server_client_cmd,
4333        "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4334        NEIGHBOR_STR
4335        NEIGHBOR_ADDR_STR2
4336        "Configure a neighbor as Route Server client\n")
4337 {
4338         int idx_peer = 1;
4339         struct peer *peer;
4340
4341         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4342         if (!peer)
4343                 return CMD_WARNING_CONFIG_FAILED;
4344         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4345                                     bgp_node_safi(vty),
4346                                     PEER_FLAG_RSERVER_CLIENT);
4347 }
4348
4349 ALIAS_HIDDEN(neighbor_route_server_client,
4350              neighbor_route_server_client_hidden_cmd,
4351              "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4352              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4353              "Configure a neighbor as Route Server client\n")
4354
4355 DEFUN (no_neighbor_route_server_client,
4356        no_neighbor_route_server_client_cmd,
4357        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4358        NO_STR
4359        NEIGHBOR_STR
4360        NEIGHBOR_ADDR_STR2
4361        "Configure a neighbor as Route Server client\n")
4362 {
4363         int idx_peer = 2;
4364         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4365                                       bgp_node_afi(vty), bgp_node_safi(vty),
4366                                       PEER_FLAG_RSERVER_CLIENT);
4367 }
4368
4369 ALIAS_HIDDEN(no_neighbor_route_server_client,
4370              no_neighbor_route_server_client_hidden_cmd,
4371              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4372              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4373              "Configure a neighbor as Route Server client\n")
4374
4375 DEFUN (neighbor_nexthop_local_unchanged,
4376        neighbor_nexthop_local_unchanged_cmd,
4377        "neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4378        NEIGHBOR_STR
4379        NEIGHBOR_ADDR_STR2
4380        "Configure treatment of outgoing link-local nexthop attribute\n"
4381        "Leave link-local nexthop unchanged for this peer\n")
4382 {
4383         int idx_peer = 1;
4384         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4385                                     bgp_node_safi(vty),
4386                                     PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
4387 }
4388
4389 DEFUN (no_neighbor_nexthop_local_unchanged,
4390        no_neighbor_nexthop_local_unchanged_cmd,
4391        "no neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4392        NO_STR
4393        NEIGHBOR_STR
4394        NEIGHBOR_ADDR_STR2
4395        "Configure treatment of outgoing link-local-nexthop attribute\n"
4396        "Leave link-local nexthop unchanged for this peer\n")
4397 {
4398         int idx_peer = 2;
4399         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4400                                       bgp_node_afi(vty), bgp_node_safi(vty),
4401                                       PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
4402 }
4403
4404 DEFUN (neighbor_attr_unchanged,
4405        neighbor_attr_unchanged_cmd,
4406        "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4407        NEIGHBOR_STR
4408        NEIGHBOR_ADDR_STR2
4409        "BGP attribute is propagated unchanged to this neighbor\n"
4410        "As-path attribute\n"
4411        "Nexthop attribute\n"
4412        "Med attribute\n")
4413 {
4414         int idx = 0;
4415         char *peer_str = argv[1]->arg;
4416         struct peer *peer;
4417         uint16_t flags = 0;
4418         afi_t afi = bgp_node_afi(vty);
4419         safi_t safi = bgp_node_safi(vty);
4420
4421         peer = peer_and_group_lookup_vty(vty, peer_str);
4422         if (!peer)
4423                 return CMD_WARNING_CONFIG_FAILED;
4424
4425         if (argv_find(argv, argc, "as-path", &idx))
4426                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4427         idx = 0;
4428         if (argv_find(argv, argc, "next-hop", &idx))
4429                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4430         idx = 0;
4431         if (argv_find(argv, argc, "med", &idx))
4432                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4433
4434         /* no flags means all of them! */
4435         if (!flags) {
4436                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4437                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4438                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4439         } else {
4440                 if (!CHECK_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED)
4441                     && peer_af_flag_check(peer, afi, safi,
4442                                           PEER_FLAG_AS_PATH_UNCHANGED)) {
4443                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4444                                                PEER_FLAG_AS_PATH_UNCHANGED);
4445                 }
4446
4447                 if (!CHECK_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED)
4448                     && peer_af_flag_check(peer, afi, safi,
4449                                           PEER_FLAG_NEXTHOP_UNCHANGED)) {
4450                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4451                                                PEER_FLAG_NEXTHOP_UNCHANGED);
4452                 }
4453
4454                 if (!CHECK_FLAG(flags, PEER_FLAG_MED_UNCHANGED)
4455                     && peer_af_flag_check(peer, afi, safi,
4456                                           PEER_FLAG_MED_UNCHANGED)) {
4457                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4458                                                PEER_FLAG_MED_UNCHANGED);
4459                 }
4460         }
4461
4462         return peer_af_flag_set_vty(vty, peer_str, afi, safi, flags);
4463 }
4464
4465 ALIAS_HIDDEN(
4466         neighbor_attr_unchanged, neighbor_attr_unchanged_hidden_cmd,
4467         "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4468         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4469         "BGP attribute is propagated unchanged to this neighbor\n"
4470         "As-path attribute\n"
4471         "Nexthop attribute\n"
4472         "Med attribute\n")
4473
4474 DEFUN (no_neighbor_attr_unchanged,
4475        no_neighbor_attr_unchanged_cmd,
4476        "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4477        NO_STR
4478        NEIGHBOR_STR
4479        NEIGHBOR_ADDR_STR2
4480        "BGP attribute is propagated unchanged to this neighbor\n"
4481        "As-path attribute\n"
4482        "Nexthop attribute\n"
4483        "Med attribute\n")
4484 {
4485         int idx = 0;
4486         char *peer = argv[2]->arg;
4487         uint16_t flags = 0;
4488
4489         if (argv_find(argv, argc, "as-path", &idx))
4490                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4491         idx = 0;
4492         if (argv_find(argv, argc, "next-hop", &idx))
4493                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4494         idx = 0;
4495         if (argv_find(argv, argc, "med", &idx))
4496                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4497
4498         if (!flags) // no flags means all of them!
4499         {
4500                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4501                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4502                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4503         }
4504
4505         return peer_af_flag_unset_vty(vty, peer, bgp_node_afi(vty),
4506                                       bgp_node_safi(vty), flags);
4507 }
4508
4509 ALIAS_HIDDEN(
4510         no_neighbor_attr_unchanged, no_neighbor_attr_unchanged_hidden_cmd,
4511         "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4512         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4513         "BGP attribute is propagated unchanged to this neighbor\n"
4514         "As-path attribute\n"
4515         "Nexthop attribute\n"
4516         "Med attribute\n")
4517
4518 /* EBGP multihop configuration. */
4519 static int peer_ebgp_multihop_set_vty(struct vty *vty, const char *ip_str,
4520                                       const char *ttl_str)
4521 {
4522         struct peer *peer;
4523         unsigned int ttl;
4524
4525         peer = peer_and_group_lookup_vty(vty, ip_str);
4526         if (!peer)
4527                 return CMD_WARNING_CONFIG_FAILED;
4528
4529         if (peer->conf_if)
4530                 return bgp_vty_return(vty, BGP_ERR_INVALID_FOR_DIRECT_PEER);
4531
4532         if (!ttl_str)
4533                 ttl = MAXTTL;
4534         else
4535                 ttl = strtoul(ttl_str, NULL, 10);
4536
4537         return bgp_vty_return(vty, peer_ebgp_multihop_set(peer, ttl));
4538 }
4539
4540 static int peer_ebgp_multihop_unset_vty(struct vty *vty, const char *ip_str)
4541 {
4542         struct peer *peer;
4543
4544         peer = peer_and_group_lookup_vty(vty, ip_str);
4545         if (!peer)
4546                 return CMD_WARNING_CONFIG_FAILED;
4547
4548         return bgp_vty_return(vty, peer_ebgp_multihop_unset(peer));
4549 }
4550
4551 /* neighbor ebgp-multihop. */
4552 DEFUN (neighbor_ebgp_multihop,
4553        neighbor_ebgp_multihop_cmd,
4554        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop",
4555        NEIGHBOR_STR
4556        NEIGHBOR_ADDR_STR2
4557        "Allow EBGP neighbors not on directly connected networks\n")
4558 {
4559         int idx_peer = 1;
4560         return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg, NULL);
4561 }
4562
4563 DEFUN (neighbor_ebgp_multihop_ttl,
4564        neighbor_ebgp_multihop_ttl_cmd,
4565        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop (1-255)",
4566        NEIGHBOR_STR
4567        NEIGHBOR_ADDR_STR2
4568        "Allow EBGP neighbors not on directly connected networks\n"
4569        "maximum hop count\n")
4570 {
4571         int idx_peer = 1;
4572         int idx_number = 3;
4573         return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg,
4574                                           argv[idx_number]->arg);
4575 }
4576
4577 DEFUN (no_neighbor_ebgp_multihop,
4578        no_neighbor_ebgp_multihop_cmd,
4579        "no neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop [(1-255)]",
4580        NO_STR
4581        NEIGHBOR_STR
4582        NEIGHBOR_ADDR_STR2
4583        "Allow EBGP neighbors not on directly connected networks\n"
4584        "maximum hop count\n")
4585 {
4586         int idx_peer = 2;
4587         return peer_ebgp_multihop_unset_vty(vty, argv[idx_peer]->arg);
4588 }
4589
4590
4591 /* disable-connected-check */
4592 DEFUN (neighbor_disable_connected_check,
4593        neighbor_disable_connected_check_cmd,
4594        "neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4595        NEIGHBOR_STR
4596        NEIGHBOR_ADDR_STR2
4597        "one-hop away EBGP peer using loopback address\n"
4598        "Enforce EBGP neighbors perform multihop\n")
4599 {
4600         int idx_peer = 1;
4601         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
4602                                  PEER_FLAG_DISABLE_CONNECTED_CHECK);
4603 }
4604
4605 DEFUN (no_neighbor_disable_connected_check,
4606        no_neighbor_disable_connected_check_cmd,
4607        "no neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4608        NO_STR
4609        NEIGHBOR_STR
4610        NEIGHBOR_ADDR_STR2
4611        "one-hop away EBGP peer using loopback address\n"
4612        "Enforce EBGP neighbors perform multihop\n")
4613 {
4614         int idx_peer = 2;
4615         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
4616                                    PEER_FLAG_DISABLE_CONNECTED_CHECK);
4617 }
4618
4619
4620 /* enforce-first-as */
4621 DEFUN (neighbor_enforce_first_as,
4622        neighbor_enforce_first_as_cmd,
4623        "neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
4624        NEIGHBOR_STR
4625        NEIGHBOR_ADDR_STR2
4626        "Enforce the first AS for EBGP routes\n")
4627 {
4628         int idx_peer = 1;
4629
4630         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
4631                                  PEER_FLAG_ENFORCE_FIRST_AS);
4632 }
4633
4634 DEFUN (no_neighbor_enforce_first_as,
4635        no_neighbor_enforce_first_as_cmd,
4636        "no neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
4637        NO_STR
4638        NEIGHBOR_STR
4639        NEIGHBOR_ADDR_STR2
4640        "Enforce the first AS for EBGP routes\n")
4641 {
4642         int idx_peer = 2;
4643
4644         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
4645                                    PEER_FLAG_ENFORCE_FIRST_AS);
4646 }
4647
4648
4649 DEFUN (neighbor_description,
4650        neighbor_description_cmd,
4651        "neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
4652        NEIGHBOR_STR
4653        NEIGHBOR_ADDR_STR2
4654        "Neighbor specific description\n"
4655        "Up to 80 characters describing this neighbor\n")
4656 {
4657         int idx_peer = 1;
4658         int idx_line = 3;
4659         struct peer *peer;
4660         char *str;
4661
4662         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4663         if (!peer)
4664                 return CMD_WARNING_CONFIG_FAILED;
4665
4666         str = argv_concat(argv, argc, idx_line);
4667
4668         peer_description_set(peer, str);
4669
4670         XFREE(MTYPE_TMP, str);
4671
4672         return CMD_SUCCESS;
4673 }
4674
4675 DEFUN (no_neighbor_description,
4676        no_neighbor_description_cmd,
4677        "no neighbor <A.B.C.D|X:X::X:X|WORD> description",
4678        NO_STR
4679        NEIGHBOR_STR
4680        NEIGHBOR_ADDR_STR2
4681        "Neighbor specific description\n")
4682 {
4683         int idx_peer = 2;
4684         struct peer *peer;
4685
4686         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4687         if (!peer)
4688                 return CMD_WARNING_CONFIG_FAILED;
4689
4690         peer_description_unset(peer);
4691
4692         return CMD_SUCCESS;
4693 }
4694
4695 ALIAS(no_neighbor_description, no_neighbor_description_comment_cmd,
4696       "no neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
4697       NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4698       "Neighbor specific description\n"
4699       "Up to 80 characters describing this neighbor\n")
4700
4701 /* Neighbor update-source. */
4702 static int peer_update_source_vty(struct vty *vty, const char *peer_str,
4703                                   const char *source_str)
4704 {
4705         struct peer *peer;
4706         struct prefix p;
4707         union sockunion su;
4708
4709         peer = peer_and_group_lookup_vty(vty, peer_str);
4710         if (!peer)
4711                 return CMD_WARNING_CONFIG_FAILED;
4712
4713         if (peer->conf_if)
4714                 return CMD_WARNING;
4715
4716         if (source_str) {
4717                 if (str2sockunion(source_str, &su) == 0)
4718                         peer_update_source_addr_set(peer, &su);
4719                 else {
4720                         if (str2prefix(source_str, &p)) {
4721                                 vty_out(vty,
4722                                         "%% Invalid update-source, remove prefix length \n");
4723                                 return CMD_WARNING_CONFIG_FAILED;
4724                         } else
4725                                 peer_update_source_if_set(peer, source_str);
4726                 }
4727         } else
4728                 peer_update_source_unset(peer);
4729
4730         return CMD_SUCCESS;
4731 }
4732
4733 #define BGP_UPDATE_SOURCE_HELP_STR                                             \
4734         "IPv4 address\n"                                                       \
4735         "IPv6 address\n"                                                       \
4736         "Interface name (requires zebra to be running)\n"
4737
4738 DEFUN (neighbor_update_source,
4739        neighbor_update_source_cmd,
4740        "neighbor <A.B.C.D|X:X::X:X|WORD> update-source <A.B.C.D|X:X::X:X|WORD>",
4741        NEIGHBOR_STR
4742        NEIGHBOR_ADDR_STR2
4743        "Source of routing updates\n"
4744        BGP_UPDATE_SOURCE_HELP_STR)
4745 {
4746         int idx_peer = 1;
4747         int idx_peer_2 = 3;
4748         return peer_update_source_vty(vty, argv[idx_peer]->arg,
4749                                       argv[idx_peer_2]->arg);
4750 }
4751
4752 DEFUN (no_neighbor_update_source,
4753        no_neighbor_update_source_cmd,
4754        "no neighbor <A.B.C.D|X:X::X:X|WORD> update-source [<A.B.C.D|X:X::X:X|WORD>]",
4755        NO_STR
4756        NEIGHBOR_STR
4757        NEIGHBOR_ADDR_STR2
4758        "Source of routing updates\n"
4759        BGP_UPDATE_SOURCE_HELP_STR)
4760 {
4761         int idx_peer = 2;
4762         return peer_update_source_vty(vty, argv[idx_peer]->arg, NULL);
4763 }
4764
4765 static int peer_default_originate_set_vty(struct vty *vty, const char *peer_str,
4766                                           afi_t afi, safi_t safi,
4767                                           const char *rmap, int set)
4768 {
4769         int ret;
4770         struct peer *peer;
4771         struct route_map *route_map;
4772
4773         peer = peer_and_group_lookup_vty(vty, peer_str);
4774         if (!peer)
4775                 return CMD_WARNING_CONFIG_FAILED;
4776
4777         if (set) {
4778                 route_map = route_map_lookup_warn_noexist(vty, rmap);
4779                 ret = peer_default_originate_set(peer, afi, safi,
4780                                                  rmap, route_map);
4781         } else
4782                 ret = peer_default_originate_unset(peer, afi, safi);
4783
4784         return bgp_vty_return(vty, ret);
4785 }
4786
4787 /* neighbor default-originate. */
4788 DEFUN (neighbor_default_originate,
4789        neighbor_default_originate_cmd,
4790        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
4791        NEIGHBOR_STR
4792        NEIGHBOR_ADDR_STR2
4793        "Originate default route to this neighbor\n")
4794 {
4795         int idx_peer = 1;
4796         return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
4797                                               bgp_node_afi(vty),
4798                                               bgp_node_safi(vty), NULL, 1);
4799 }
4800
4801 ALIAS_HIDDEN(neighbor_default_originate, neighbor_default_originate_hidden_cmd,
4802              "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
4803              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4804              "Originate default route to this neighbor\n")
4805
4806 DEFUN (neighbor_default_originate_rmap,
4807        neighbor_default_originate_rmap_cmd,
4808        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map WORD",
4809        NEIGHBOR_STR
4810        NEIGHBOR_ADDR_STR2
4811        "Originate default route to this neighbor\n"
4812        "Route-map to specify criteria to originate default\n"
4813        "route-map name\n")
4814 {
4815         int idx_peer = 1;
4816         int idx_word = 4;
4817         return peer_default_originate_set_vty(
4818                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
4819                 argv[idx_word]->arg, 1);
4820 }
4821
4822 ALIAS_HIDDEN(
4823         neighbor_default_originate_rmap,
4824         neighbor_default_originate_rmap_hidden_cmd,
4825         "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map WORD",
4826         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4827         "Originate default route to this neighbor\n"
4828         "Route-map to specify criteria to originate default\n"
4829         "route-map name\n")
4830
4831 DEFUN (no_neighbor_default_originate,
4832        no_neighbor_default_originate_cmd,
4833        "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map WORD]",
4834        NO_STR
4835        NEIGHBOR_STR
4836        NEIGHBOR_ADDR_STR2
4837        "Originate default route to this neighbor\n"
4838        "Route-map to specify criteria to originate default\n"
4839        "route-map name\n")
4840 {
4841         int idx_peer = 2;
4842         return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
4843                                               bgp_node_afi(vty),
4844                                               bgp_node_safi(vty), NULL, 0);
4845 }
4846
4847 ALIAS_HIDDEN(
4848         no_neighbor_default_originate, no_neighbor_default_originate_hidden_cmd,
4849         "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map WORD]",
4850         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4851         "Originate default route to this neighbor\n"
4852         "Route-map to specify criteria to originate default\n"
4853         "route-map name\n")
4854
4855
4856 /* Set neighbor's BGP port.  */
4857 static int peer_port_vty(struct vty *vty, const char *ip_str, int afi,
4858                          const char *port_str)
4859 {
4860         struct peer *peer;
4861         uint16_t port;
4862         struct servent *sp;
4863
4864         peer = peer_lookup_vty(vty, ip_str);
4865         if (!peer)
4866                 return CMD_WARNING_CONFIG_FAILED;
4867
4868         if (!port_str) {
4869                 sp = getservbyname("bgp", "tcp");
4870                 port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs(sp->s_port);
4871         } else {
4872                 port = strtoul(port_str, NULL, 10);
4873         }
4874
4875         peer_port_set(peer, port);
4876
4877         return CMD_SUCCESS;
4878 }
4879
4880 /* Set specified peer's BGP port.  */
4881 DEFUN (neighbor_port,
4882        neighbor_port_cmd,
4883        "neighbor <A.B.C.D|X:X::X:X> port (0-65535)",
4884        NEIGHBOR_STR
4885        NEIGHBOR_ADDR_STR
4886        "Neighbor's BGP port\n"
4887        "TCP port number\n")
4888 {
4889         int idx_ip = 1;
4890         int idx_number = 3;
4891         return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP,
4892                              argv[idx_number]->arg);
4893 }
4894
4895 DEFUN (no_neighbor_port,
4896        no_neighbor_port_cmd,
4897        "no neighbor <A.B.C.D|X:X::X:X> port [(0-65535)]",
4898        NO_STR
4899        NEIGHBOR_STR
4900        NEIGHBOR_ADDR_STR
4901        "Neighbor's BGP port\n"
4902        "TCP port number\n")
4903 {
4904         int idx_ip = 2;
4905         return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP, NULL);
4906 }
4907
4908
4909 /* neighbor weight. */
4910 static int peer_weight_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
4911                                safi_t safi, const char *weight_str)
4912 {
4913         int ret;
4914         struct peer *peer;
4915         unsigned long weight;
4916
4917         peer = peer_and_group_lookup_vty(vty, ip_str);
4918         if (!peer)
4919                 return CMD_WARNING_CONFIG_FAILED;
4920
4921         weight = strtoul(weight_str, NULL, 10);
4922
4923         ret = peer_weight_set(peer, afi, safi, weight);
4924         return bgp_vty_return(vty, ret);
4925 }
4926
4927 static int peer_weight_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
4928                                  safi_t safi)
4929 {
4930         int ret;
4931         struct peer *peer;
4932
4933         peer = peer_and_group_lookup_vty(vty, ip_str);
4934         if (!peer)
4935                 return CMD_WARNING_CONFIG_FAILED;
4936
4937         ret = peer_weight_unset(peer, afi, safi);
4938         return bgp_vty_return(vty, ret);
4939 }
4940
4941 DEFUN (neighbor_weight,
4942        neighbor_weight_cmd,
4943        "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
4944        NEIGHBOR_STR
4945        NEIGHBOR_ADDR_STR2
4946        "Set default weight for routes from this neighbor\n"
4947        "default weight\n")
4948 {
4949         int idx_peer = 1;
4950         int idx_number = 3;
4951         return peer_weight_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4952                                    bgp_node_safi(vty), argv[idx_number]->arg);
4953 }
4954
4955 ALIAS_HIDDEN(neighbor_weight, neighbor_weight_hidden_cmd,
4956              "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
4957              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4958              "Set default weight for routes from this neighbor\n"
4959              "default weight\n")
4960
4961 DEFUN (no_neighbor_weight,
4962        no_neighbor_weight_cmd,
4963        "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
4964        NO_STR
4965        NEIGHBOR_STR
4966        NEIGHBOR_ADDR_STR2
4967        "Set default weight for routes from this neighbor\n"
4968        "default weight\n")
4969 {
4970         int idx_peer = 2;
4971         return peer_weight_unset_vty(vty, argv[idx_peer]->arg,
4972                                      bgp_node_afi(vty), bgp_node_safi(vty));
4973 }
4974
4975 ALIAS_HIDDEN(no_neighbor_weight, no_neighbor_weight_hidden_cmd,
4976              "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
4977              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4978              "Set default weight for routes from this neighbor\n"
4979              "default weight\n")
4980
4981
4982 /* Override capability negotiation. */
4983 DEFUN (neighbor_override_capability,
4984        neighbor_override_capability_cmd,
4985        "neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
4986        NEIGHBOR_STR
4987        NEIGHBOR_ADDR_STR2
4988        "Override capability negotiation result\n")
4989 {
4990         int idx_peer = 1;
4991         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
4992                                  PEER_FLAG_OVERRIDE_CAPABILITY);
4993 }
4994
4995 DEFUN (no_neighbor_override_capability,
4996        no_neighbor_override_capability_cmd,
4997        "no neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
4998        NO_STR
4999        NEIGHBOR_STR
5000        NEIGHBOR_ADDR_STR2
5001        "Override capability negotiation result\n")
5002 {
5003         int idx_peer = 2;
5004         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5005                                    PEER_FLAG_OVERRIDE_CAPABILITY);
5006 }
5007
5008 DEFUN (neighbor_strict_capability,
5009        neighbor_strict_capability_cmd,
5010        "neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
5011        NEIGHBOR_STR
5012        NEIGHBOR_ADDR_STR2
5013        "Strict capability negotiation match\n")
5014 {
5015         int idx_peer = 1;
5016
5017         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5018                                  PEER_FLAG_STRICT_CAP_MATCH);
5019 }
5020
5021 DEFUN (no_neighbor_strict_capability,
5022        no_neighbor_strict_capability_cmd,
5023        "no neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
5024        NO_STR
5025        NEIGHBOR_STR
5026        NEIGHBOR_ADDR_STR2
5027        "Strict capability negotiation match\n")
5028 {
5029         int idx_peer = 2;
5030
5031         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5032                                    PEER_FLAG_STRICT_CAP_MATCH);
5033 }
5034
5035 static int peer_timers_set_vty(struct vty *vty, const char *ip_str,
5036                                const char *keep_str, const char *hold_str)
5037 {
5038         int ret;
5039         struct peer *peer;
5040         uint32_t keepalive;
5041         uint32_t holdtime;
5042
5043         peer = peer_and_group_lookup_vty(vty, ip_str);
5044         if (!peer)
5045                 return CMD_WARNING_CONFIG_FAILED;
5046
5047         keepalive = strtoul(keep_str, NULL, 10);
5048         holdtime = strtoul(hold_str, NULL, 10);
5049
5050         ret = peer_timers_set(peer, keepalive, holdtime);
5051
5052         return bgp_vty_return(vty, ret);
5053 }
5054
5055 static int peer_timers_unset_vty(struct vty *vty, const char *ip_str)
5056 {
5057         int ret;
5058         struct peer *peer;
5059
5060         peer = peer_and_group_lookup_vty(vty, ip_str);
5061         if (!peer)
5062                 return CMD_WARNING_CONFIG_FAILED;
5063
5064         ret = peer_timers_unset(peer);
5065
5066         return bgp_vty_return(vty, ret);
5067 }
5068
5069 DEFUN (neighbor_timers,
5070        neighbor_timers_cmd,
5071        "neighbor <A.B.C.D|X:X::X:X|WORD> timers (0-65535) (0-65535)",
5072        NEIGHBOR_STR
5073        NEIGHBOR_ADDR_STR2
5074        "BGP per neighbor timers\n"
5075        "Keepalive interval\n"
5076        "Holdtime\n")
5077 {
5078         int idx_peer = 1;
5079         int idx_number = 3;
5080         int idx_number_2 = 4;
5081         return peer_timers_set_vty(vty, argv[idx_peer]->arg,
5082                                    argv[idx_number]->arg,
5083                                    argv[idx_number_2]->arg);
5084 }
5085
5086 DEFUN (no_neighbor_timers,
5087        no_neighbor_timers_cmd,
5088        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers [(0-65535) (0-65535)]",
5089        NO_STR
5090        NEIGHBOR_STR
5091        NEIGHBOR_ADDR_STR2
5092        "BGP per neighbor timers\n"
5093        "Keepalive interval\n"
5094        "Holdtime\n")
5095 {
5096         int idx_peer = 2;
5097         return peer_timers_unset_vty(vty, argv[idx_peer]->arg);
5098 }
5099
5100
5101 static int peer_timers_connect_set_vty(struct vty *vty, const char *ip_str,
5102                                        const char *time_str)
5103 {
5104         int ret;
5105         struct peer *peer;
5106         uint32_t connect;
5107
5108         peer = peer_and_group_lookup_vty(vty, ip_str);
5109         if (!peer)
5110                 return CMD_WARNING_CONFIG_FAILED;
5111
5112         connect = strtoul(time_str, NULL, 10);
5113
5114         ret = peer_timers_connect_set(peer, connect);
5115
5116         return bgp_vty_return(vty, ret);
5117 }
5118
5119 static int peer_timers_connect_unset_vty(struct vty *vty, const char *ip_str)
5120 {
5121         int ret;
5122         struct peer *peer;
5123
5124         peer = peer_and_group_lookup_vty(vty, ip_str);
5125         if (!peer)
5126                 return CMD_WARNING_CONFIG_FAILED;
5127
5128         ret = peer_timers_connect_unset(peer);
5129
5130         return bgp_vty_return(vty, ret);
5131 }
5132
5133 DEFUN (neighbor_timers_connect,
5134        neighbor_timers_connect_cmd,
5135        "neighbor <A.B.C.D|X:X::X:X|WORD> timers connect (1-65535)",
5136        NEIGHBOR_STR
5137        NEIGHBOR_ADDR_STR2
5138        "BGP per neighbor timers\n"
5139        "BGP connect timer\n"
5140        "Connect timer\n")
5141 {
5142         int idx_peer = 1;
5143         int idx_number = 4;
5144         return peer_timers_connect_set_vty(vty, argv[idx_peer]->arg,
5145                                            argv[idx_number]->arg);
5146 }
5147
5148 DEFUN (no_neighbor_timers_connect,
5149        no_neighbor_timers_connect_cmd,
5150        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers connect [(1-65535)]",
5151        NO_STR
5152        NEIGHBOR_STR
5153        NEIGHBOR_ADDR_STR2
5154        "BGP per neighbor timers\n"
5155        "BGP connect timer\n"
5156        "Connect timer\n")
5157 {
5158         int idx_peer = 2;
5159         return peer_timers_connect_unset_vty(vty, argv[idx_peer]->arg);
5160 }
5161
5162
5163 static int peer_advertise_interval_vty(struct vty *vty, const char *ip_str,
5164                                        const char *time_str, int set)
5165 {
5166         int ret;
5167         struct peer *peer;
5168         uint32_t routeadv = 0;
5169
5170         peer = peer_and_group_lookup_vty(vty, ip_str);
5171         if (!peer)
5172                 return CMD_WARNING_CONFIG_FAILED;
5173
5174         if (time_str)
5175                 routeadv = strtoul(time_str, NULL, 10);
5176
5177         if (set)
5178                 ret = peer_advertise_interval_set(peer, routeadv);
5179         else
5180                 ret = peer_advertise_interval_unset(peer);
5181
5182         return bgp_vty_return(vty, ret);
5183 }
5184
5185 DEFUN (neighbor_advertise_interval,
5186        neighbor_advertise_interval_cmd,
5187        "neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval (0-600)",
5188        NEIGHBOR_STR
5189        NEIGHBOR_ADDR_STR2
5190        "Minimum interval between sending BGP routing updates\n"
5191        "time in seconds\n")
5192 {
5193         int idx_peer = 1;
5194         int idx_number = 3;
5195         return peer_advertise_interval_vty(vty, argv[idx_peer]->arg,
5196                                            argv[idx_number]->arg, 1);
5197 }
5198
5199 DEFUN (no_neighbor_advertise_interval,
5200        no_neighbor_advertise_interval_cmd,
5201        "no neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval [(0-600)]",
5202        NO_STR
5203        NEIGHBOR_STR
5204        NEIGHBOR_ADDR_STR2
5205        "Minimum interval between sending BGP routing updates\n"
5206        "time in seconds\n")
5207 {
5208         int idx_peer = 2;
5209         return peer_advertise_interval_vty(vty, argv[idx_peer]->arg, NULL, 0);
5210 }
5211
5212
5213 /* Time to wait before processing route-map updates */
5214 DEFUN (bgp_set_route_map_delay_timer,
5215        bgp_set_route_map_delay_timer_cmd,
5216        "bgp route-map delay-timer (0-600)",
5217        SET_STR
5218        "BGP route-map delay timer\n"
5219        "Time in secs to wait before processing route-map changes\n"
5220        "0 disables the timer, no route updates happen when route-maps change\n")
5221 {
5222         int idx_number = 3;
5223         uint32_t rmap_delay_timer;
5224
5225         if (argv[idx_number]->arg) {
5226                 rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
5227                 bm->rmap_update_timer = rmap_delay_timer;
5228
5229                 /* if the dynamic update handling is being disabled, and a timer
5230                  * is
5231                  * running, stop the timer and act as if the timer has already
5232                  * fired.
5233                  */
5234                 if (!rmap_delay_timer && bm->t_rmap_update) {
5235                         BGP_TIMER_OFF(bm->t_rmap_update);
5236                         thread_execute(bm->master, bgp_route_map_update_timer,
5237                                        NULL, 0);
5238                 }
5239                 return CMD_SUCCESS;
5240         } else {
5241                 vty_out(vty, "%% BGP invalid route-map delay-timer\n");
5242                 return CMD_WARNING_CONFIG_FAILED;
5243         }
5244 }
5245
5246 DEFUN (no_bgp_set_route_map_delay_timer,
5247        no_bgp_set_route_map_delay_timer_cmd,
5248        "no bgp route-map delay-timer [(0-600)]",
5249        NO_STR
5250        BGP_STR
5251        "Default BGP route-map delay timer\n"
5252        "Reset to default time to wait for processing route-map changes\n"
5253        "0 disables the timer, no route updates happen when route-maps change\n")
5254 {
5255
5256         bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
5257
5258         return CMD_SUCCESS;
5259 }
5260
5261
5262 /* neighbor interface */
5263 static int peer_interface_vty(struct vty *vty, const char *ip_str,
5264                               const char *str)
5265 {
5266         struct peer *peer;
5267
5268         peer = peer_lookup_vty(vty, ip_str);
5269         if (!peer || peer->conf_if) {
5270                 vty_out(vty, "%% BGP invalid peer %s\n", ip_str);
5271                 return CMD_WARNING_CONFIG_FAILED;
5272         }
5273
5274         if (str)
5275                 peer_interface_set(peer, str);
5276         else
5277                 peer_interface_unset(peer);
5278
5279         return CMD_SUCCESS;
5280 }
5281
5282 DEFUN (neighbor_interface,
5283        neighbor_interface_cmd,
5284        "neighbor <A.B.C.D|X:X::X:X> interface WORD",
5285        NEIGHBOR_STR
5286        NEIGHBOR_ADDR_STR
5287        "Interface\n"
5288        "Interface name\n")
5289 {
5290         int idx_ip = 1;
5291         int idx_word = 3;
5292         return peer_interface_vty(vty, argv[idx_ip]->arg, argv[idx_word]->arg);
5293 }
5294
5295 DEFUN (no_neighbor_interface,
5296        no_neighbor_interface_cmd,
5297        "no neighbor <A.B.C.D|X:X::X:X|WORD> interface WORD",
5298        NO_STR
5299        NEIGHBOR_STR
5300        NEIGHBOR_ADDR_STR2
5301        "Interface\n"
5302        "Interface name\n")
5303 {
5304         int idx_peer = 2;
5305         return peer_interface_vty(vty, argv[idx_peer]->arg, NULL);
5306 }
5307
5308 DEFUN (neighbor_distribute_list,
5309        neighbor_distribute_list_cmd,
5310        "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5311        NEIGHBOR_STR
5312        NEIGHBOR_ADDR_STR2
5313        "Filter updates to/from this neighbor\n"
5314        "IP access-list number\n"
5315        "IP access-list number (expanded range)\n"
5316        "IP Access-list name\n"
5317        "Filter incoming updates\n"
5318        "Filter outgoing updates\n")
5319 {
5320         int idx_peer = 1;
5321         int idx_acl = 3;
5322         int direct, ret;
5323         struct peer *peer;
5324
5325         const char *pstr = argv[idx_peer]->arg;
5326         const char *acl = argv[idx_acl]->arg;
5327         const char *inout = argv[argc - 1]->text;
5328
5329         peer = peer_and_group_lookup_vty(vty, pstr);
5330         if (!peer)
5331                 return CMD_WARNING_CONFIG_FAILED;
5332
5333         /* Check filter direction. */
5334         direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
5335         ret = peer_distribute_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
5336                                   direct, acl);
5337
5338         return bgp_vty_return(vty, ret);
5339 }
5340
5341 ALIAS_HIDDEN(
5342         neighbor_distribute_list, neighbor_distribute_list_hidden_cmd,
5343         "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5344         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5345         "Filter updates to/from this neighbor\n"
5346         "IP access-list number\n"
5347         "IP access-list number (expanded range)\n"
5348         "IP Access-list name\n"
5349         "Filter incoming updates\n"
5350         "Filter outgoing updates\n")
5351
5352 DEFUN (no_neighbor_distribute_list,
5353        no_neighbor_distribute_list_cmd,
5354        "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5355        NO_STR
5356        NEIGHBOR_STR
5357        NEIGHBOR_ADDR_STR2
5358        "Filter updates to/from this neighbor\n"
5359        "IP access-list number\n"
5360        "IP access-list number (expanded range)\n"
5361        "IP Access-list name\n"
5362        "Filter incoming updates\n"
5363        "Filter outgoing updates\n")
5364 {
5365         int idx_peer = 2;
5366         int direct, ret;
5367         struct peer *peer;
5368
5369         const char *pstr = argv[idx_peer]->arg;
5370         const char *inout = argv[argc - 1]->text;
5371
5372         peer = peer_and_group_lookup_vty(vty, pstr);
5373         if (!peer)
5374                 return CMD_WARNING_CONFIG_FAILED;
5375
5376         /* Check filter direction. */
5377         direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
5378         ret = peer_distribute_unset(peer, bgp_node_afi(vty), bgp_node_safi(vty),
5379                                     direct);
5380
5381         return bgp_vty_return(vty, ret);
5382 }
5383
5384 ALIAS_HIDDEN(
5385         no_neighbor_distribute_list, no_neighbor_distribute_list_hidden_cmd,
5386         "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5387         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5388         "Filter updates to/from this neighbor\n"
5389         "IP access-list number\n"
5390         "IP access-list number (expanded range)\n"
5391         "IP Access-list name\n"
5392         "Filter incoming updates\n"
5393         "Filter outgoing updates\n")
5394
5395 /* Set prefix list to the peer. */
5396 static int peer_prefix_list_set_vty(struct vty *vty, const char *ip_str,
5397                                     afi_t afi, safi_t safi,
5398                                     const char *name_str,
5399                                     const char *direct_str)
5400 {
5401         int ret;
5402         int direct = FILTER_IN;
5403         struct peer *peer;
5404
5405         peer = peer_and_group_lookup_vty(vty, ip_str);
5406         if (!peer)
5407                 return CMD_WARNING_CONFIG_FAILED;
5408
5409         /* Check filter direction. */
5410         if (strncmp(direct_str, "i", 1) == 0)
5411                 direct = FILTER_IN;
5412         else if (strncmp(direct_str, "o", 1) == 0)
5413                 direct = FILTER_OUT;
5414
5415         ret = peer_prefix_list_set(peer, afi, safi, direct, name_str);
5416
5417         return bgp_vty_return(vty, ret);
5418 }
5419
5420 static int peer_prefix_list_unset_vty(struct vty *vty, const char *ip_str,
5421                                       afi_t afi, safi_t safi,
5422                                       const char *direct_str)
5423 {
5424         int ret;
5425         struct peer *peer;
5426         int direct = FILTER_IN;
5427
5428         peer = peer_and_group_lookup_vty(vty, ip_str);
5429         if (!peer)
5430                 return CMD_WARNING_CONFIG_FAILED;
5431
5432         /* Check filter direction. */
5433         if (strncmp(direct_str, "i", 1) == 0)
5434                 direct = FILTER_IN;
5435         else if (strncmp(direct_str, "o", 1) == 0)
5436                 direct = FILTER_OUT;
5437
5438         ret = peer_prefix_list_unset(peer, afi, safi, direct);
5439
5440         return bgp_vty_return(vty, ret);
5441 }
5442
5443 DEFUN (neighbor_prefix_list,
5444        neighbor_prefix_list_cmd,
5445        "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5446        NEIGHBOR_STR
5447        NEIGHBOR_ADDR_STR2
5448        "Filter updates to/from this neighbor\n"
5449        "Name of a prefix list\n"
5450        "Filter incoming updates\n"
5451        "Filter outgoing updates\n")
5452 {
5453         int idx_peer = 1;
5454         int idx_word = 3;
5455         int idx_in_out = 4;
5456         return peer_prefix_list_set_vty(
5457                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5458                 argv[idx_word]->arg, argv[idx_in_out]->arg);
5459 }
5460
5461 ALIAS_HIDDEN(neighbor_prefix_list, neighbor_prefix_list_hidden_cmd,
5462              "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5463              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5464              "Filter updates to/from this neighbor\n"
5465              "Name of a prefix list\n"
5466              "Filter incoming updates\n"
5467              "Filter outgoing updates\n")
5468
5469 DEFUN (no_neighbor_prefix_list,
5470        no_neighbor_prefix_list_cmd,
5471        "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5472        NO_STR
5473        NEIGHBOR_STR
5474        NEIGHBOR_ADDR_STR2
5475        "Filter updates to/from this neighbor\n"
5476        "Name of a prefix list\n"
5477        "Filter incoming updates\n"
5478        "Filter outgoing updates\n")
5479 {
5480         int idx_peer = 2;
5481         int idx_in_out = 5;
5482         return peer_prefix_list_unset_vty(vty, argv[idx_peer]->arg,
5483                                           bgp_node_afi(vty), bgp_node_safi(vty),
5484                                           argv[idx_in_out]->arg);
5485 }
5486
5487 ALIAS_HIDDEN(no_neighbor_prefix_list, no_neighbor_prefix_list_hidden_cmd,
5488              "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5489              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5490              "Filter updates to/from this neighbor\n"
5491              "Name of a prefix list\n"
5492              "Filter incoming updates\n"
5493              "Filter outgoing updates\n")
5494
5495 static int peer_aslist_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
5496                                safi_t safi, const char *name_str,
5497                                const char *direct_str)
5498 {
5499         int ret;
5500         struct peer *peer;
5501         int direct = FILTER_IN;
5502
5503         peer = peer_and_group_lookup_vty(vty, ip_str);
5504         if (!peer)
5505                 return CMD_WARNING_CONFIG_FAILED;
5506
5507         /* Check filter direction. */
5508         if (strncmp(direct_str, "i", 1) == 0)
5509                 direct = FILTER_IN;
5510         else if (strncmp(direct_str, "o", 1) == 0)
5511                 direct = FILTER_OUT;
5512
5513         ret = peer_aslist_set(peer, afi, safi, direct, name_str);
5514
5515         return bgp_vty_return(vty, ret);
5516 }
5517
5518 static int peer_aslist_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
5519                                  safi_t safi, const char *direct_str)
5520 {
5521         int ret;
5522         struct peer *peer;
5523         int direct = FILTER_IN;
5524
5525         peer = peer_and_group_lookup_vty(vty, ip_str);
5526         if (!peer)
5527                 return CMD_WARNING_CONFIG_FAILED;
5528
5529         /* Check filter direction. */
5530         if (strncmp(direct_str, "i", 1) == 0)
5531                 direct = FILTER_IN;
5532         else if (strncmp(direct_str, "o", 1) == 0)
5533                 direct = FILTER_OUT;
5534
5535         ret = peer_aslist_unset(peer, afi, safi, direct);
5536
5537         return bgp_vty_return(vty, ret);
5538 }
5539
5540 DEFUN (neighbor_filter_list,
5541        neighbor_filter_list_cmd,
5542        "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5543        NEIGHBOR_STR
5544        NEIGHBOR_ADDR_STR2
5545        "Establish BGP filters\n"
5546        "AS path access-list name\n"
5547        "Filter incoming routes\n"
5548        "Filter outgoing routes\n")
5549 {
5550         int idx_peer = 1;
5551         int idx_word = 3;
5552         int idx_in_out = 4;
5553         return peer_aslist_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5554                                    bgp_node_safi(vty), argv[idx_word]->arg,
5555                                    argv[idx_in_out]->arg);
5556 }
5557
5558 ALIAS_HIDDEN(neighbor_filter_list, neighbor_filter_list_hidden_cmd,
5559              "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5560              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5561              "Establish BGP filters\n"
5562              "AS path access-list name\n"
5563              "Filter incoming routes\n"
5564              "Filter outgoing routes\n")
5565
5566 DEFUN (no_neighbor_filter_list,
5567        no_neighbor_filter_list_cmd,
5568        "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5569        NO_STR
5570        NEIGHBOR_STR
5571        NEIGHBOR_ADDR_STR2
5572        "Establish BGP filters\n"
5573        "AS path access-list name\n"
5574        "Filter incoming routes\n"
5575        "Filter outgoing routes\n")
5576 {
5577         int idx_peer = 2;
5578         int idx_in_out = 5;
5579         return peer_aslist_unset_vty(vty, argv[idx_peer]->arg,
5580                                      bgp_node_afi(vty), bgp_node_safi(vty),
5581                                      argv[idx_in_out]->arg);
5582 }
5583
5584 ALIAS_HIDDEN(no_neighbor_filter_list, no_neighbor_filter_list_hidden_cmd,
5585              "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5586              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5587              "Establish BGP filters\n"
5588              "AS path access-list name\n"
5589              "Filter incoming routes\n"
5590              "Filter outgoing routes\n")
5591
5592 /* Set route-map to the peer. */
5593 static int peer_route_map_set_vty(struct vty *vty, const char *ip_str,
5594                                   afi_t afi, safi_t safi, const char *name_str,
5595                                   const char *direct_str)
5596 {
5597         int ret;
5598         struct peer *peer;
5599         int direct = RMAP_IN;
5600         struct route_map *route_map;
5601
5602         peer = peer_and_group_lookup_vty(vty, ip_str);
5603         if (!peer)
5604                 return CMD_WARNING_CONFIG_FAILED;
5605
5606         /* Check filter direction. */
5607         if (strncmp(direct_str, "in", 2) == 0)
5608                 direct = RMAP_IN;
5609         else if (strncmp(direct_str, "o", 1) == 0)
5610                 direct = RMAP_OUT;
5611
5612         route_map = route_map_lookup_warn_noexist(vty, name_str);
5613         ret = peer_route_map_set(peer, afi, safi, direct, name_str, route_map);
5614
5615         return bgp_vty_return(vty, ret);
5616 }
5617
5618 static int peer_route_map_unset_vty(struct vty *vty, const char *ip_str,
5619                                     afi_t afi, safi_t safi,
5620                                     const char *direct_str)
5621 {
5622         int ret;
5623         struct peer *peer;
5624         int direct = RMAP_IN;
5625
5626         peer = peer_and_group_lookup_vty(vty, ip_str);
5627         if (!peer)
5628                 return CMD_WARNING_CONFIG_FAILED;
5629
5630         /* Check filter direction. */
5631         if (strncmp(direct_str, "in", 2) == 0)
5632                 direct = RMAP_IN;
5633         else if (strncmp(direct_str, "o", 1) == 0)
5634                 direct = RMAP_OUT;
5635
5636         ret = peer_route_map_unset(peer, afi, safi, direct);
5637
5638         return bgp_vty_return(vty, ret);
5639 }
5640
5641 DEFUN (neighbor_route_map,
5642        neighbor_route_map_cmd,
5643        "neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5644        NEIGHBOR_STR
5645        NEIGHBOR_ADDR_STR2
5646        "Apply route map to neighbor\n"
5647        "Name of route map\n"
5648        "Apply map to incoming routes\n"
5649        "Apply map to outbound routes\n")
5650 {
5651         int idx_peer = 1;
5652         int idx_word = 3;
5653         int idx_in_out = 4;
5654         return peer_route_map_set_vty(
5655                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5656                 argv[idx_word]->arg, argv[idx_in_out]->arg);
5657 }
5658
5659 ALIAS_HIDDEN(neighbor_route_map, neighbor_route_map_hidden_cmd,
5660              "neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5661              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5662              "Apply route map to neighbor\n"
5663              "Name of route map\n"
5664              "Apply map to incoming routes\n"
5665              "Apply map to outbound routes\n")
5666
5667 DEFUN (no_neighbor_route_map,
5668        no_neighbor_route_map_cmd,
5669        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5670        NO_STR
5671        NEIGHBOR_STR
5672        NEIGHBOR_ADDR_STR2
5673        "Apply route map to neighbor\n"
5674        "Name of route map\n"
5675        "Apply map to incoming routes\n"
5676        "Apply map to outbound routes\n")
5677 {
5678         int idx_peer = 2;
5679         int idx_in_out = 5;
5680         return peer_route_map_unset_vty(vty, argv[idx_peer]->arg,
5681                                         bgp_node_afi(vty), bgp_node_safi(vty),
5682                                         argv[idx_in_out]->arg);
5683 }
5684
5685 ALIAS_HIDDEN(no_neighbor_route_map, no_neighbor_route_map_hidden_cmd,
5686              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5687              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5688              "Apply route map to neighbor\n"
5689              "Name of route map\n"
5690              "Apply map to incoming routes\n"
5691              "Apply map to outbound routes\n")
5692
5693 /* Set unsuppress-map to the peer. */
5694 static int peer_unsuppress_map_set_vty(struct vty *vty, const char *ip_str,
5695                                        afi_t afi, safi_t safi,
5696                                        const char *name_str)
5697 {
5698         int ret;
5699         struct peer *peer;
5700         struct route_map *route_map;
5701
5702         peer = peer_and_group_lookup_vty(vty, ip_str);
5703         if (!peer)
5704                 return CMD_WARNING_CONFIG_FAILED;
5705
5706         route_map = route_map_lookup_warn_noexist(vty, name_str);
5707         ret = peer_unsuppress_map_set(peer, afi, safi, name_str, route_map);
5708
5709         return bgp_vty_return(vty, ret);
5710 }
5711
5712 /* Unset route-map from the peer. */
5713 static int peer_unsuppress_map_unset_vty(struct vty *vty, const char *ip_str,
5714                                          afi_t afi, safi_t safi)
5715 {
5716         int ret;
5717         struct peer *peer;
5718
5719         peer = peer_and_group_lookup_vty(vty, ip_str);
5720         if (!peer)
5721                 return CMD_WARNING_CONFIG_FAILED;
5722
5723         ret = peer_unsuppress_map_unset(peer, afi, safi);
5724
5725         return bgp_vty_return(vty, ret);
5726 }
5727
5728 DEFUN (neighbor_unsuppress_map,
5729        neighbor_unsuppress_map_cmd,
5730        "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5731        NEIGHBOR_STR
5732        NEIGHBOR_ADDR_STR2
5733        "Route-map to selectively unsuppress suppressed routes\n"
5734        "Name of route map\n")
5735 {
5736         int idx_peer = 1;
5737         int idx_word = 3;
5738         return peer_unsuppress_map_set_vty(
5739                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5740                 argv[idx_word]->arg);
5741 }
5742
5743 ALIAS_HIDDEN(neighbor_unsuppress_map, neighbor_unsuppress_map_hidden_cmd,
5744              "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5745              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5746              "Route-map to selectively unsuppress suppressed routes\n"
5747              "Name of route map\n")
5748
5749 DEFUN (no_neighbor_unsuppress_map,
5750        no_neighbor_unsuppress_map_cmd,
5751        "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5752        NO_STR
5753        NEIGHBOR_STR
5754        NEIGHBOR_ADDR_STR2
5755        "Route-map to selectively unsuppress suppressed routes\n"
5756        "Name of route map\n")
5757 {
5758         int idx_peer = 2;
5759         return peer_unsuppress_map_unset_vty(vty, argv[idx_peer]->arg,
5760                                              bgp_node_afi(vty),
5761                                              bgp_node_safi(vty));
5762 }
5763
5764 ALIAS_HIDDEN(no_neighbor_unsuppress_map, no_neighbor_unsuppress_map_hidden_cmd,
5765              "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5766              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5767              "Route-map to selectively unsuppress suppressed routes\n"
5768              "Name of route map\n")
5769
5770 static int peer_maximum_prefix_set_vty(struct vty *vty, const char *ip_str,
5771                                        afi_t afi, safi_t safi,
5772                                        const char *num_str,
5773                                        const char *threshold_str, int warning,
5774                                        const char *restart_str)
5775 {
5776         int ret;
5777         struct peer *peer;
5778         uint32_t max;
5779         uint8_t threshold;
5780         uint16_t restart;
5781
5782         peer = peer_and_group_lookup_vty(vty, ip_str);
5783         if (!peer)
5784                 return CMD_WARNING_CONFIG_FAILED;
5785
5786         max = strtoul(num_str, NULL, 10);
5787         if (threshold_str)
5788                 threshold = atoi(threshold_str);
5789         else
5790                 threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
5791
5792         if (restart_str)
5793                 restart = atoi(restart_str);
5794         else
5795                 restart = 0;
5796
5797         ret = peer_maximum_prefix_set(peer, afi, safi, max, threshold, warning,
5798                                       restart);
5799
5800         return bgp_vty_return(vty, ret);
5801 }
5802
5803 static int peer_maximum_prefix_unset_vty(struct vty *vty, const char *ip_str,
5804                                          afi_t afi, safi_t safi)
5805 {
5806         int ret;
5807         struct peer *peer;
5808
5809         peer = peer_and_group_lookup_vty(vty, ip_str);
5810         if (!peer)
5811                 return CMD_WARNING_CONFIG_FAILED;
5812
5813         ret = peer_maximum_prefix_unset(peer, afi, safi);
5814
5815         return bgp_vty_return(vty, ret);
5816 }
5817
5818 /* Maximum number of prefix configuration.  prefix count is different
5819    for each peer configuration.  So this configuration can be set for
5820    each peer configuration. */
5821 DEFUN (neighbor_maximum_prefix,
5822        neighbor_maximum_prefix_cmd,
5823        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295)",
5824        NEIGHBOR_STR
5825        NEIGHBOR_ADDR_STR2
5826        "Maximum number of prefix accept from this peer\n"
5827        "maximum no. of prefix limit\n")
5828 {
5829         int idx_peer = 1;
5830         int idx_number = 3;
5831         return peer_maximum_prefix_set_vty(
5832                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5833                 argv[idx_number]->arg, NULL, 0, NULL);
5834 }
5835
5836 ALIAS_HIDDEN(neighbor_maximum_prefix, neighbor_maximum_prefix_hidden_cmd,
5837              "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295)",
5838              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5839              "Maximum number of prefix accept from this peer\n"
5840              "maximum no. of prefix limit\n")
5841
5842 DEFUN (neighbor_maximum_prefix_threshold,
5843        neighbor_maximum_prefix_threshold_cmd,
5844        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100)",
5845        NEIGHBOR_STR
5846        NEIGHBOR_ADDR_STR2
5847        "Maximum number of prefix accept from this peer\n"
5848        "maximum no. of prefix limit\n"
5849        "Threshold value (%) at which to generate a warning msg\n")
5850 {
5851         int idx_peer = 1;
5852         int idx_number = 3;
5853         int idx_number_2 = 4;
5854         return peer_maximum_prefix_set_vty(
5855                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5856                 argv[idx_number]->arg, argv[idx_number_2]->arg, 0, NULL);
5857 }
5858
5859 ALIAS_HIDDEN(
5860         neighbor_maximum_prefix_threshold,
5861         neighbor_maximum_prefix_threshold_hidden_cmd,
5862         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100)",
5863         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5864         "Maximum number of prefix accept from this peer\n"
5865         "maximum no. of prefix limit\n"
5866         "Threshold value (%) at which to generate a warning msg\n")
5867
5868 DEFUN (neighbor_maximum_prefix_warning,
5869        neighbor_maximum_prefix_warning_cmd,
5870        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only",
5871        NEIGHBOR_STR
5872        NEIGHBOR_ADDR_STR2
5873        "Maximum number of prefix accept from this peer\n"
5874        "maximum no. of prefix limit\n"
5875        "Only give warning message when limit is exceeded\n")
5876 {
5877         int idx_peer = 1;
5878         int idx_number = 3;
5879         return peer_maximum_prefix_set_vty(
5880                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5881                 argv[idx_number]->arg, NULL, 1, NULL);
5882 }
5883
5884 ALIAS_HIDDEN(
5885         neighbor_maximum_prefix_warning,
5886         neighbor_maximum_prefix_warning_hidden_cmd,
5887         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only",
5888         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5889         "Maximum number of prefix accept from this peer\n"
5890         "maximum no. of prefix limit\n"
5891         "Only give warning message when limit is exceeded\n")
5892
5893 DEFUN (neighbor_maximum_prefix_threshold_warning,
5894        neighbor_maximum_prefix_threshold_warning_cmd,
5895        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only",
5896        NEIGHBOR_STR
5897        NEIGHBOR_ADDR_STR2
5898        "Maximum number of prefix accept from this peer\n"
5899        "maximum no. of prefix limit\n"
5900        "Threshold value (%) at which to generate a warning msg\n"
5901        "Only give warning message when limit is exceeded\n")
5902 {
5903         int idx_peer = 1;
5904         int idx_number = 3;
5905         int idx_number_2 = 4;
5906         return peer_maximum_prefix_set_vty(
5907                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5908                 argv[idx_number]->arg, argv[idx_number_2]->arg, 1, NULL);
5909 }
5910
5911 ALIAS_HIDDEN(
5912         neighbor_maximum_prefix_threshold_warning,
5913         neighbor_maximum_prefix_threshold_warning_hidden_cmd,
5914         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only",
5915         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5916         "Maximum number of prefix accept from this peer\n"
5917         "maximum no. of prefix limit\n"
5918         "Threshold value (%) at which to generate a warning msg\n"
5919         "Only give warning message when limit is exceeded\n")
5920
5921 DEFUN (neighbor_maximum_prefix_restart,
5922        neighbor_maximum_prefix_restart_cmd,
5923        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535)",
5924        NEIGHBOR_STR
5925        NEIGHBOR_ADDR_STR2
5926        "Maximum number of prefix accept from this peer\n"
5927        "maximum no. of prefix limit\n"
5928        "Restart bgp connection after limit is exceeded\n"
5929        "Restart interval in minutes\n")
5930 {
5931         int idx_peer = 1;
5932         int idx_number = 3;
5933         int idx_number_2 = 5;
5934         return peer_maximum_prefix_set_vty(
5935                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5936                 argv[idx_number]->arg, NULL, 0, argv[idx_number_2]->arg);
5937 }
5938
5939 ALIAS_HIDDEN(
5940         neighbor_maximum_prefix_restart,
5941         neighbor_maximum_prefix_restart_hidden_cmd,
5942         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535)",
5943         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5944         "Maximum number of prefix accept from this peer\n"
5945         "maximum no. of prefix limit\n"
5946         "Restart bgp connection after limit is exceeded\n"
5947         "Restart interval in minutes\n")
5948
5949 DEFUN (neighbor_maximum_prefix_threshold_restart,
5950        neighbor_maximum_prefix_threshold_restart_cmd,
5951        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535)",
5952        NEIGHBOR_STR
5953        NEIGHBOR_ADDR_STR2
5954        "Maximum number of prefixes to accept from this peer\n"
5955        "maximum no. of prefix limit\n"
5956        "Threshold value (%) at which to generate a warning msg\n"
5957        "Restart bgp connection after limit is exceeded\n"
5958        "Restart interval in minutes\n")
5959 {
5960         int idx_peer = 1;
5961         int idx_number = 3;
5962         int idx_number_2 = 4;
5963         int idx_number_3 = 6;
5964         return peer_maximum_prefix_set_vty(
5965                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5966                 argv[idx_number]->arg, argv[idx_number_2]->arg, 0,
5967                 argv[idx_number_3]->arg);
5968 }
5969
5970 ALIAS_HIDDEN(
5971         neighbor_maximum_prefix_threshold_restart,
5972         neighbor_maximum_prefix_threshold_restart_hidden_cmd,
5973         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535)",
5974         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5975         "Maximum number of prefixes to accept from this peer\n"
5976         "maximum no. of prefix limit\n"
5977         "Threshold value (%) at which to generate a warning msg\n"
5978         "Restart bgp connection after limit is exceeded\n"
5979         "Restart interval in minutes\n")
5980
5981 DEFUN (no_neighbor_maximum_prefix,
5982        no_neighbor_maximum_prefix_cmd,
5983        "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only]]",
5984        NO_STR
5985        NEIGHBOR_STR
5986        NEIGHBOR_ADDR_STR2
5987        "Maximum number of prefixes to accept from this peer\n"
5988        "maximum no. of prefix limit\n"
5989        "Threshold value (%) at which to generate a warning msg\n"
5990        "Restart bgp connection after limit is exceeded\n"
5991        "Restart interval in minutes\n"
5992        "Only give warning message when limit is exceeded\n")
5993 {
5994         int idx_peer = 2;
5995         return peer_maximum_prefix_unset_vty(vty, argv[idx_peer]->arg,
5996                                              bgp_node_afi(vty),
5997                                              bgp_node_safi(vty));
5998 }
5999
6000 ALIAS_HIDDEN(
6001         no_neighbor_maximum_prefix, no_neighbor_maximum_prefix_hidden_cmd,
6002         "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only]]",
6003         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6004         "Maximum number of prefixes to accept from this peer\n"
6005         "maximum no. of prefix limit\n"
6006         "Threshold value (%) at which to generate a warning msg\n"
6007         "Restart bgp connection after limit is exceeded\n"
6008         "Restart interval in minutes\n"
6009         "Only give warning message when limit is exceeded\n")
6010
6011
6012 /* "neighbor allowas-in" */
6013 DEFUN (neighbor_allowas_in,
6014        neighbor_allowas_in_cmd,
6015        "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6016        NEIGHBOR_STR
6017        NEIGHBOR_ADDR_STR2
6018        "Accept as-path with my AS present in it\n"
6019        "Number of occurances of AS number\n"
6020        "Only accept my AS in the as-path if the route was originated in my AS\n")
6021 {
6022         int idx_peer = 1;
6023         int idx_number_origin = 3;
6024         int ret;
6025         int origin = 0;
6026         struct peer *peer;
6027         int allow_num = 0;
6028
6029         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6030         if (!peer)
6031                 return CMD_WARNING_CONFIG_FAILED;
6032
6033         if (argc <= idx_number_origin)
6034                 allow_num = 3;
6035         else {
6036                 if (argv[idx_number_origin]->type == WORD_TKN)
6037                         origin = 1;
6038                 else
6039                         allow_num = atoi(argv[idx_number_origin]->arg);
6040         }
6041
6042         ret = peer_allowas_in_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6043                                   allow_num, origin);
6044
6045         return bgp_vty_return(vty, ret);
6046 }
6047
6048 ALIAS_HIDDEN(
6049         neighbor_allowas_in, neighbor_allowas_in_hidden_cmd,
6050         "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6051         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6052         "Accept as-path with my AS present in it\n"
6053         "Number of occurances of AS number\n"
6054         "Only accept my AS in the as-path if the route was originated in my AS\n")
6055
6056 DEFUN (no_neighbor_allowas_in,
6057        no_neighbor_allowas_in_cmd,
6058        "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6059        NO_STR
6060        NEIGHBOR_STR
6061        NEIGHBOR_ADDR_STR2
6062        "allow local ASN appears in aspath attribute\n"
6063        "Number of occurances of AS number\n"
6064        "Only accept my AS in the as-path if the route was originated in my AS\n")
6065 {
6066         int idx_peer = 2;
6067         int ret;
6068         struct peer *peer;
6069
6070         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6071         if (!peer)
6072                 return CMD_WARNING_CONFIG_FAILED;
6073
6074         ret = peer_allowas_in_unset(peer, bgp_node_afi(vty),
6075                                     bgp_node_safi(vty));
6076
6077         return bgp_vty_return(vty, ret);
6078 }
6079
6080 ALIAS_HIDDEN(
6081         no_neighbor_allowas_in, no_neighbor_allowas_in_hidden_cmd,
6082         "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6083         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6084         "allow local ASN appears in aspath attribute\n"
6085         "Number of occurances of AS number\n"
6086         "Only accept my AS in the as-path if the route was originated in my AS\n")
6087
6088 DEFUN (neighbor_ttl_security,
6089        neighbor_ttl_security_cmd,
6090        "neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
6091        NEIGHBOR_STR
6092        NEIGHBOR_ADDR_STR2
6093        "BGP ttl-security parameters\n"
6094        "Specify the maximum number of hops to the BGP peer\n"
6095        "Number of hops to BGP peer\n")
6096 {
6097         int idx_peer = 1;
6098         int idx_number = 4;
6099         struct peer *peer;
6100         int gtsm_hops;
6101
6102         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6103         if (!peer)
6104                 return CMD_WARNING_CONFIG_FAILED;
6105
6106         gtsm_hops = strtoul(argv[idx_number]->arg, NULL, 10);
6107
6108         /*
6109          * If 'neighbor swpX', then this is for directly connected peers,
6110          * we should not accept a ttl-security hops value greater than 1.
6111          */
6112         if (peer->conf_if && (gtsm_hops > 1)) {
6113                 vty_out(vty,
6114                         "%s is directly connected peer, hops cannot exceed 1\n",
6115                         argv[idx_peer]->arg);
6116                 return CMD_WARNING_CONFIG_FAILED;
6117         }
6118
6119         return bgp_vty_return(vty, peer_ttl_security_hops_set(peer, gtsm_hops));
6120 }
6121
6122 DEFUN (no_neighbor_ttl_security,
6123        no_neighbor_ttl_security_cmd,
6124        "no neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
6125        NO_STR
6126        NEIGHBOR_STR
6127        NEIGHBOR_ADDR_STR2
6128        "BGP ttl-security parameters\n"
6129        "Specify the maximum number of hops to the BGP peer\n"
6130        "Number of hops to BGP peer\n")
6131 {
6132         int idx_peer = 2;
6133         struct peer *peer;
6134
6135         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6136         if (!peer)
6137                 return CMD_WARNING_CONFIG_FAILED;
6138
6139         return bgp_vty_return(vty, peer_ttl_security_hops_unset(peer));
6140 }
6141
6142 DEFUN (neighbor_addpath_tx_all_paths,
6143        neighbor_addpath_tx_all_paths_cmd,
6144        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6145        NEIGHBOR_STR
6146        NEIGHBOR_ADDR_STR2
6147        "Use addpath to advertise all paths to a neighbor\n")
6148 {
6149         int idx_peer = 1;
6150         struct peer *peer;
6151
6152         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6153         if (!peer)
6154                 return CMD_WARNING_CONFIG_FAILED;
6155
6156         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6157                                     bgp_node_safi(vty),
6158                                     PEER_FLAG_ADDPATH_TX_ALL_PATHS);
6159 }
6160
6161 ALIAS_HIDDEN(neighbor_addpath_tx_all_paths,
6162              neighbor_addpath_tx_all_paths_hidden_cmd,
6163              "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6164              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6165              "Use addpath to advertise all paths to a neighbor\n")
6166
6167 DEFUN (no_neighbor_addpath_tx_all_paths,
6168        no_neighbor_addpath_tx_all_paths_cmd,
6169        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6170        NO_STR
6171        NEIGHBOR_STR
6172        NEIGHBOR_ADDR_STR2
6173        "Use addpath to advertise all paths to a neighbor\n")
6174 {
6175         int idx_peer = 2;
6176         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6177                                       bgp_node_afi(vty), bgp_node_safi(vty),
6178                                       PEER_FLAG_ADDPATH_TX_ALL_PATHS);
6179 }
6180
6181 ALIAS_HIDDEN(no_neighbor_addpath_tx_all_paths,
6182              no_neighbor_addpath_tx_all_paths_hidden_cmd,
6183              "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6184              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6185              "Use addpath to advertise all paths to a neighbor\n")
6186
6187 DEFUN (neighbor_addpath_tx_bestpath_per_as,
6188        neighbor_addpath_tx_bestpath_per_as_cmd,
6189        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6190        NEIGHBOR_STR
6191        NEIGHBOR_ADDR_STR2
6192        "Use addpath to advertise the bestpath per each neighboring AS\n")
6193 {
6194         int idx_peer = 1;
6195         struct peer *peer;
6196
6197         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6198         if (!peer)
6199                 return CMD_WARNING_CONFIG_FAILED;
6200
6201         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
6202                                     bgp_node_safi(vty),
6203                                     PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS);
6204 }
6205
6206 ALIAS_HIDDEN(neighbor_addpath_tx_bestpath_per_as,
6207              neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
6208              "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6209              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6210              "Use addpath to advertise the bestpath per each neighboring AS\n")
6211
6212 DEFUN (no_neighbor_addpath_tx_bestpath_per_as,
6213        no_neighbor_addpath_tx_bestpath_per_as_cmd,
6214        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6215        NO_STR
6216        NEIGHBOR_STR
6217        NEIGHBOR_ADDR_STR2
6218        "Use addpath to advertise the bestpath per each neighboring AS\n")
6219 {
6220         int idx_peer = 2;
6221         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
6222                                       bgp_node_afi(vty), bgp_node_safi(vty),
6223                                       PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS);
6224 }
6225
6226 ALIAS_HIDDEN(no_neighbor_addpath_tx_bestpath_per_as,
6227              no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
6228              "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6229              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6230              "Use addpath to advertise the bestpath per each neighboring AS\n")
6231
6232 static int set_ecom_list(struct vty *vty, int argc, struct cmd_token **argv,
6233                          struct ecommunity **list)
6234 {
6235         struct ecommunity *ecom = NULL;
6236         struct ecommunity *ecomadd;
6237
6238         for (; argc; --argc, ++argv) {
6239
6240                 ecomadd = ecommunity_str2com(argv[0]->arg,
6241                                              ECOMMUNITY_ROUTE_TARGET, 0);
6242                 if (!ecomadd) {
6243                         vty_out(vty, "Malformed community-list value\n");
6244                         if (ecom)
6245                                 ecommunity_free(&ecom);
6246                         return CMD_WARNING_CONFIG_FAILED;
6247                 }
6248
6249                 if (ecom) {
6250                         ecommunity_merge(ecom, ecomadd);
6251                         ecommunity_free(&ecomadd);
6252                 } else {
6253                         ecom = ecomadd;
6254                 }
6255         }
6256
6257         if (*list) {
6258                 ecommunity_free(&*list);
6259         }
6260         *list = ecom;
6261
6262         return CMD_SUCCESS;
6263 }
6264
6265 /*
6266  * v2vimport is true if we are handling a `import vrf ...` command
6267  */
6268 static afi_t vpn_policy_getafi(struct vty *vty, struct bgp *bgp, bool v2vimport)
6269 {
6270         afi_t afi;
6271
6272         switch (vty->node) {
6273         case BGP_IPV4_NODE:
6274                 afi = AFI_IP;
6275                 break;
6276         case BGP_IPV6_NODE:
6277                 afi = AFI_IP6;
6278                 break;
6279         default:
6280                 vty_out(vty,
6281                         "%% context error: valid only in address-family <ipv4|ipv6> unicast block\n");
6282                 return AFI_MAX;
6283         }
6284
6285         if (!v2vimport) {
6286                 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6287                                BGP_CONFIG_VRF_TO_VRF_IMPORT)
6288                     || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6289                                   BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
6290                         vty_out(vty,
6291                                 "%% error: Please unconfigure import vrf commands before using vpn commands\n");
6292                         return AFI_MAX;
6293                 }
6294         } else {
6295                 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6296                                BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)
6297                     || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6298                                   BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
6299                         vty_out(vty,
6300                                 "%% error: Please unconfigure vpn to vrf commands before using import vrf commands\n");
6301                         return AFI_MAX;
6302                 }
6303         }
6304         return afi;
6305 }
6306
6307 DEFPY (af_rd_vpn_export,
6308        af_rd_vpn_export_cmd,
6309        "[no] rd vpn export ASN:NN_OR_IP-ADDRESS:NN$rd_str",
6310        NO_STR
6311        "Specify route distinguisher\n"
6312        "Between current address-family and vpn\n"
6313        "For routes leaked from current address-family to vpn\n"
6314        "Route Distinguisher (<as-number>:<number> | <ip-address>:<number>)\n")
6315 {
6316         VTY_DECLVAR_CONTEXT(bgp, bgp);
6317         struct prefix_rd prd;
6318         int ret;
6319         afi_t afi;
6320         int idx = 0;
6321         int yes = 1;
6322
6323         if (argv_find(argv, argc, "no", &idx))
6324                 yes = 0;
6325
6326         if (yes) {
6327                 ret = str2prefix_rd(rd_str, &prd);
6328                 if (!ret) {
6329                         vty_out(vty, "%% Malformed rd\n");
6330                         return CMD_WARNING_CONFIG_FAILED;
6331                 }
6332         }
6333
6334         afi = vpn_policy_getafi(vty, bgp, false);
6335         if (afi == AFI_MAX)
6336                 return CMD_WARNING_CONFIG_FAILED;
6337
6338         /*
6339          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6340          */
6341         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6342                            bgp_get_default(), bgp);
6343
6344         if (yes) {
6345                 bgp->vpn_policy[afi].tovpn_rd = prd;
6346                 SET_FLAG(bgp->vpn_policy[afi].flags,
6347                          BGP_VPN_POLICY_TOVPN_RD_SET);
6348         } else {
6349                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6350                            BGP_VPN_POLICY_TOVPN_RD_SET);
6351         }
6352
6353         /* post-change: re-export vpn routes */
6354         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6355                             bgp_get_default(), bgp);
6356
6357         return CMD_SUCCESS;
6358 }
6359
6360 ALIAS (af_rd_vpn_export,
6361        af_no_rd_vpn_export_cmd,
6362        "no rd vpn export",
6363        NO_STR
6364        "Specify route distinguisher\n"
6365        "Between current address-family and vpn\n"
6366        "For routes leaked from current address-family to vpn\n")
6367
6368 DEFPY (af_label_vpn_export,
6369        af_label_vpn_export_cmd,
6370        "[no] label vpn export <(0-1048575)$label_val|auto$label_auto>",
6371        NO_STR
6372        "label value for VRF\n"
6373        "Between current address-family and vpn\n"
6374        "For routes leaked from current address-family to vpn\n"
6375        "Label Value <0-1048575>\n"
6376        "Automatically assign a label\n")
6377 {
6378         VTY_DECLVAR_CONTEXT(bgp, bgp);
6379         mpls_label_t label = MPLS_LABEL_NONE;
6380         afi_t afi;
6381         int idx = 0;
6382         int yes = 1;
6383
6384         if (argv_find(argv, argc, "no", &idx))
6385                 yes = 0;
6386
6387         /* If "no ...", squash trailing parameter */
6388         if (!yes)
6389                 label_auto = NULL;
6390
6391         if (yes) {
6392                 if (!label_auto)
6393                         label = label_val; /* parser should force unsigned */
6394         }
6395
6396         afi = vpn_policy_getafi(vty, bgp, false);
6397         if (afi == AFI_MAX)
6398                 return CMD_WARNING_CONFIG_FAILED;
6399
6400
6401         if (label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
6402                                      BGP_VPN_POLICY_TOVPN_LABEL_AUTO))
6403                 /* no change */
6404                 return CMD_SUCCESS;
6405
6406         /*
6407          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6408          */
6409         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6410                            bgp_get_default(), bgp);
6411
6412         if (!label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
6413                                       BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
6414
6415                 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
6416
6417                         /*
6418                          * label has previously been automatically
6419                          * assigned by labelpool: release it
6420                          *
6421                          * NB if tovpn_label == MPLS_LABEL_NONE it
6422                          * means the automatic assignment is in flight
6423                          * and therefore the labelpool callback must
6424                          * detect that the auto label is not needed.
6425                          */
6426
6427                         bgp_lp_release(LP_TYPE_VRF,
6428                                        &bgp->vpn_policy[afi],
6429                                        bgp->vpn_policy[afi].tovpn_label);
6430                 }
6431                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6432                            BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
6433         }
6434
6435         bgp->vpn_policy[afi].tovpn_label = label;
6436         if (label_auto) {
6437                 SET_FLAG(bgp->vpn_policy[afi].flags,
6438                          BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
6439                 bgp_lp_get(LP_TYPE_VRF, &bgp->vpn_policy[afi],
6440                            vpn_leak_label_callback);
6441         }
6442
6443         /* post-change: re-export vpn routes */
6444         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6445                             bgp_get_default(), bgp);
6446
6447         return CMD_SUCCESS;
6448 }
6449
6450 ALIAS (af_label_vpn_export,
6451        af_no_label_vpn_export_cmd,
6452        "no label vpn export",
6453        NO_STR
6454        "label value for VRF\n"
6455        "Between current address-family and vpn\n"
6456        "For routes leaked from current address-family to vpn\n")
6457
6458 DEFPY (af_nexthop_vpn_export,
6459        af_nexthop_vpn_export_cmd,
6460        "[no] nexthop vpn export <A.B.C.D|X:X::X:X>$nexthop_str",
6461        NO_STR
6462        "Specify next hop to use for VRF advertised prefixes\n"
6463        "Between current address-family and vpn\n"
6464        "For routes leaked from current address-family to vpn\n"
6465        "IPv4 prefix\n"
6466        "IPv6 prefix\n")
6467 {
6468         VTY_DECLVAR_CONTEXT(bgp, bgp);
6469         afi_t afi;
6470         struct prefix p;
6471         int idx = 0;
6472         int yes = 1;
6473
6474         if (argv_find(argv, argc, "no", &idx))
6475                 yes = 0;
6476
6477         if (yes) {
6478                 if (!sockunion2hostprefix(nexthop_str, &p))
6479                         return CMD_WARNING_CONFIG_FAILED;
6480         }
6481
6482         afi = vpn_policy_getafi(vty, bgp, false);
6483         if (afi == AFI_MAX)
6484                 return CMD_WARNING_CONFIG_FAILED;
6485
6486         /*
6487          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6488          */
6489         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6490                            bgp_get_default(), bgp);
6491
6492         if (yes) {
6493                 bgp->vpn_policy[afi].tovpn_nexthop = p;
6494                 SET_FLAG(bgp->vpn_policy[afi].flags,
6495                          BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
6496         } else {
6497                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6498                            BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
6499         }
6500
6501         /* post-change: re-export vpn routes */
6502         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6503                             bgp_get_default(), bgp);
6504
6505         return CMD_SUCCESS;
6506 }
6507
6508 ALIAS (af_nexthop_vpn_export,
6509        af_no_nexthop_vpn_export_cmd,
6510        "no nexthop vpn export",
6511        NO_STR
6512        "Specify next hop to use for VRF advertised prefixes\n"
6513        "Between current address-family and vpn\n"
6514        "For routes leaked from current address-family to vpn\n")
6515
6516 static int vpn_policy_getdirs(struct vty *vty, const char *dstr, int *dodir)
6517 {
6518         if (!strcmp(dstr, "import")) {
6519                 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
6520         } else if (!strcmp(dstr, "export")) {
6521                 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
6522         } else if (!strcmp(dstr, "both")) {
6523                 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
6524                 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
6525         } else {
6526                 vty_out(vty, "%% direction parse error\n");
6527                 return CMD_WARNING_CONFIG_FAILED;
6528         }
6529         return CMD_SUCCESS;
6530 }
6531
6532 DEFPY (af_rt_vpn_imexport,
6533        af_rt_vpn_imexport_cmd,
6534        "[no] <rt|route-target> vpn <import|export|both>$direction_str RTLIST...",
6535        NO_STR
6536        "Specify route target list\n"
6537        "Specify route target list\n"
6538        "Between current address-family and vpn\n"
6539        "For routes leaked from vpn to current address-family: match any\n"
6540        "For routes leaked from current address-family to vpn: set\n"
6541        "both import: match any and export: set\n"
6542        "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6543 {
6544         VTY_DECLVAR_CONTEXT(bgp, bgp);
6545         int ret;
6546         struct ecommunity *ecom = NULL;
6547         int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
6548         vpn_policy_direction_t dir;
6549         afi_t afi;
6550         int idx = 0;
6551         int yes = 1;
6552
6553         if (argv_find(argv, argc, "no", &idx))
6554                 yes = 0;
6555
6556         afi = vpn_policy_getafi(vty, bgp, false);
6557         if (afi == AFI_MAX)
6558                 return CMD_WARNING_CONFIG_FAILED;
6559
6560         ret = vpn_policy_getdirs(vty, direction_str, dodir);
6561         if (ret != CMD_SUCCESS)
6562                 return ret;
6563
6564         if (yes) {
6565                 if (!argv_find(argv, argc, "RTLIST", &idx)) {
6566                         vty_out(vty, "%% Missing RTLIST\n");
6567                         return CMD_WARNING_CONFIG_FAILED;
6568                 }
6569                 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom);
6570                 if (ret != CMD_SUCCESS) {
6571                         return ret;
6572                 }
6573         }
6574
6575         for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
6576                 if (!dodir[dir])
6577                         continue;
6578
6579                 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6580
6581                 if (yes) {
6582                         if (bgp->vpn_policy[afi].rtlist[dir])
6583                                 ecommunity_free(
6584                                                 &bgp->vpn_policy[afi].rtlist[dir]);
6585                         bgp->vpn_policy[afi].rtlist[dir] =
6586                                 ecommunity_dup(ecom);
6587                 } else {
6588                         if (bgp->vpn_policy[afi].rtlist[dir])
6589                                 ecommunity_free(
6590                                                 &bgp->vpn_policy[afi].rtlist[dir]);
6591                         bgp->vpn_policy[afi].rtlist[dir] = NULL;
6592                 }
6593
6594                 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6595         }
6596
6597         if (ecom)
6598                 ecommunity_free(&ecom);
6599
6600         return CMD_SUCCESS;
6601 }
6602
6603 ALIAS (af_rt_vpn_imexport,
6604        af_no_rt_vpn_imexport_cmd,
6605        "no <rt|route-target> vpn <import|export|both>$direction_str",
6606        NO_STR
6607        "Specify route target list\n"
6608        "Specify route target list\n"
6609        "Between current address-family and vpn\n"
6610        "For routes leaked from vpn to current address-family\n"
6611        "For routes leaked from current address-family to vpn\n"
6612        "both import and export\n")
6613
6614 DEFPY (af_route_map_vpn_imexport,
6615        af_route_map_vpn_imexport_cmd,
6616 /* future: "route-map <vpn|evpn|vrf NAME> <import|export> RMAP" */
6617        "[no] route-map vpn <import|export>$direction_str RMAP$rmap_str",
6618        NO_STR
6619        "Specify route map\n"
6620        "Between current address-family and vpn\n"
6621        "For routes leaked from vpn to current address-family\n"
6622        "For routes leaked from current address-family to vpn\n"
6623        "name of route-map\n")
6624 {
6625         VTY_DECLVAR_CONTEXT(bgp, bgp);
6626         int ret;
6627         int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
6628         vpn_policy_direction_t dir;
6629         afi_t afi;
6630         int idx = 0;
6631         int yes = 1;
6632
6633         if (argv_find(argv, argc, "no", &idx))
6634                 yes = 0;
6635
6636         afi = vpn_policy_getafi(vty, bgp, false);
6637         if (afi == AFI_MAX)
6638                 return CMD_WARNING_CONFIG_FAILED;
6639
6640         ret = vpn_policy_getdirs(vty, direction_str, dodir);
6641         if (ret != CMD_SUCCESS)
6642                 return ret;
6643
6644         for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
6645                 if (!dodir[dir])
6646                         continue;
6647
6648                 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6649
6650                 if (yes) {
6651                         if (bgp->vpn_policy[afi].rmap_name[dir])
6652                                 XFREE(MTYPE_ROUTE_MAP_NAME,
6653                                       bgp->vpn_policy[afi].rmap_name[dir]);
6654                         bgp->vpn_policy[afi].rmap_name[dir] = XSTRDUP(
6655                                                                       MTYPE_ROUTE_MAP_NAME, rmap_str);
6656                         bgp->vpn_policy[afi].rmap[dir] =
6657                                 route_map_lookup_warn_noexist(vty, rmap_str);
6658                         if (!bgp->vpn_policy[afi].rmap[dir])
6659                                 return CMD_SUCCESS;
6660                 } else {
6661                         if (bgp->vpn_policy[afi].rmap_name[dir])
6662                                 XFREE(MTYPE_ROUTE_MAP_NAME,
6663                                       bgp->vpn_policy[afi].rmap_name[dir]);
6664                         bgp->vpn_policy[afi].rmap_name[dir] = NULL;
6665                         bgp->vpn_policy[afi].rmap[dir] = NULL;
6666                 }
6667
6668                 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6669         }
6670
6671         return CMD_SUCCESS;
6672 }
6673
6674 ALIAS (af_route_map_vpn_imexport,
6675        af_no_route_map_vpn_imexport_cmd,
6676        "no route-map vpn <import|export>$direction_str",
6677        NO_STR
6678        "Specify route map\n"
6679        "Between current address-family and vpn\n"
6680        "For routes leaked from vpn to current address-family\n"
6681        "For routes leaked from current address-family to vpn\n")
6682
6683 DEFPY(af_import_vrf_route_map, af_import_vrf_route_map_cmd,
6684       "[no] import vrf route-map RMAP$rmap_str",
6685       NO_STR
6686       "Import routes from another VRF\n"
6687       "Vrf routes being filtered\n"
6688       "Specify route map\n"
6689       "name of route-map\n")
6690 {
6691         VTY_DECLVAR_CONTEXT(bgp, bgp);
6692         vpn_policy_direction_t dir = BGP_VPN_POLICY_DIR_FROMVPN;
6693         afi_t afi;
6694         int idx = 0;
6695         int yes = 1;
6696         struct bgp *bgp_default;
6697
6698         if (argv_find(argv, argc, "no", &idx))
6699                 yes = 0;
6700
6701         afi = vpn_policy_getafi(vty, bgp, true);
6702         if (afi == AFI_MAX)
6703                 return CMD_WARNING_CONFIG_FAILED;
6704
6705         bgp_default = bgp_get_default();
6706         if (!bgp_default) {
6707                 int32_t ret;
6708                 as_t as = bgp->as;
6709
6710                 /* Auto-create assuming the same AS */
6711                 ret = bgp_get(&bgp_default, &as, NULL,
6712                               BGP_INSTANCE_TYPE_DEFAULT);
6713
6714                 if (ret) {
6715                         vty_out(vty,
6716                                 "VRF default is not configured as a bgp instance\n");
6717                         return CMD_WARNING;
6718                 }
6719         }
6720
6721         vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6722
6723         if (yes) {
6724                 if (bgp->vpn_policy[afi].rmap_name[dir])
6725                         XFREE(MTYPE_ROUTE_MAP_NAME,
6726                               bgp->vpn_policy[afi].rmap_name[dir]);
6727                 bgp->vpn_policy[afi].rmap_name[dir] =
6728                         XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_str);
6729                 bgp->vpn_policy[afi].rmap[dir] =
6730                         route_map_lookup_warn_noexist(vty, rmap_str);
6731                 if (!bgp->vpn_policy[afi].rmap[dir])
6732                         return CMD_SUCCESS;
6733         } else {
6734                 if (bgp->vpn_policy[afi].rmap_name[dir])
6735                         XFREE(MTYPE_ROUTE_MAP_NAME,
6736                               bgp->vpn_policy[afi].rmap_name[dir]);
6737                 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
6738                 bgp->vpn_policy[afi].rmap[dir] = NULL;
6739         }
6740
6741         vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6742
6743         return CMD_SUCCESS;
6744 }
6745
6746 ALIAS(af_import_vrf_route_map, af_no_import_vrf_route_map_cmd,
6747       "no import vrf route-map",
6748       NO_STR
6749       "Import routes from another VRF\n"
6750       "Vrf routes being filtered\n"
6751       "Specify route map\n")
6752
6753 DEFPY (bgp_imexport_vrf,
6754        bgp_imexport_vrf_cmd,
6755        "[no] import vrf NAME$import_name",
6756        NO_STR
6757        "Import routes from another VRF\n"
6758        "VRF to import from\n"
6759        "The name of the VRF\n")
6760 {
6761         VTY_DECLVAR_CONTEXT(bgp, bgp);
6762         struct listnode *node;
6763         struct bgp *vrf_bgp, *bgp_default;
6764         int32_t ret = 0;
6765         as_t as = bgp->as;
6766         bool remove = false;
6767         int32_t idx = 0;
6768         char *vname;
6769         enum bgp_instance_type bgp_type = BGP_INSTANCE_TYPE_VRF;
6770         safi_t safi;
6771         afi_t afi;
6772
6773         if (import_name == NULL) {
6774                 vty_out(vty, "%% Missing import name\n");
6775                 return CMD_WARNING;
6776         }
6777
6778         if (argv_find(argv, argc, "no", &idx))
6779                 remove = true;
6780
6781         afi = vpn_policy_getafi(vty, bgp, true);
6782         if (afi == AFI_MAX)
6783                 return CMD_WARNING_CONFIG_FAILED;
6784
6785         safi = bgp_node_safi(vty);
6786
6787         if (((BGP_INSTANCE_TYPE_DEFAULT == bgp->inst_type)
6788              && (strcmp(import_name, BGP_DEFAULT_NAME) == 0))
6789             || (bgp->name && (strcmp(import_name, bgp->name) == 0))) {
6790                 vty_out(vty, "%% Cannot %s vrf %s into itself\n",
6791                         remove ? "unimport" : "import", import_name);
6792                 return CMD_WARNING;
6793         }
6794
6795         bgp_default = bgp_get_default();
6796         if (!bgp_default) {
6797                 /* Auto-create assuming the same AS */
6798                 ret = bgp_get(&bgp_default, &as, NULL,
6799                               BGP_INSTANCE_TYPE_DEFAULT);
6800
6801                 if (ret) {
6802                         vty_out(vty,
6803                                 "VRF default is not configured as a bgp instance\n");
6804                         return CMD_WARNING;
6805                 }
6806         }
6807
6808         vrf_bgp = bgp_lookup_by_name(import_name);
6809         if (!vrf_bgp) {
6810                 if (strcmp(import_name, BGP_DEFAULT_NAME) == 0)
6811                         vrf_bgp = bgp_default;
6812                 else
6813                         /* Auto-create assuming the same AS */
6814                         ret = bgp_get(&vrf_bgp, &as, import_name, bgp_type);
6815
6816                 if (ret) {
6817                         vty_out(vty,
6818                                 "VRF %s is not configured as a bgp instance\n",
6819                                 import_name);
6820                         return CMD_WARNING;
6821                 }
6822         }
6823
6824         if (remove) {
6825                 vrf_unimport_from_vrf(bgp, vrf_bgp, afi, safi);
6826         } else {
6827                 /* Already importing from "import_vrf"? */
6828                 for (ALL_LIST_ELEMENTS_RO(bgp->vpn_policy[afi].import_vrf, node,
6829                                           vname)) {
6830                         if (strcmp(vname, import_name) == 0)
6831                                 return CMD_WARNING;
6832                 }
6833
6834                 vrf_import_from_vrf(bgp, vrf_bgp, afi, safi);
6835         }
6836
6837         return CMD_SUCCESS;
6838 }
6839
6840 /* This command is valid only in a bgp vrf instance or the default instance */
6841 DEFPY (bgp_imexport_vpn,
6842        bgp_imexport_vpn_cmd,
6843        "[no] <import|export>$direction_str vpn",
6844        NO_STR
6845        "Import routes to this address-family\n"
6846        "Export routes from this address-family\n"
6847        "to/from default instance VPN RIB\n")
6848 {
6849         VTY_DECLVAR_CONTEXT(bgp, bgp);
6850         int previous_state;
6851         afi_t afi;
6852         safi_t safi;
6853         int idx = 0;
6854         int yes = 1;
6855         int flag;
6856         vpn_policy_direction_t dir;
6857
6858         if (argv_find(argv, argc, "no", &idx))
6859                 yes = 0;
6860
6861         if (BGP_INSTANCE_TYPE_VRF != bgp->inst_type &&
6862                 BGP_INSTANCE_TYPE_DEFAULT != bgp->inst_type) {
6863
6864                 vty_out(vty, "%% import|export vpn valid only for bgp vrf or default instance\n");
6865                 return CMD_WARNING_CONFIG_FAILED;
6866         }
6867
6868         afi = bgp_node_afi(vty);
6869         safi = bgp_node_safi(vty);
6870         if ((SAFI_UNICAST != safi) || ((AFI_IP != afi) && (AFI_IP6 != afi))) {
6871                 vty_out(vty, "%% import|export vpn valid only for unicast ipv4|ipv6\n");
6872                 return CMD_WARNING_CONFIG_FAILED;
6873         }
6874
6875         if (!strcmp(direction_str, "import")) {
6876                 flag = BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT;
6877                 dir = BGP_VPN_POLICY_DIR_FROMVPN;
6878         } else if (!strcmp(direction_str, "export")) {
6879                 flag = BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT;
6880                 dir = BGP_VPN_POLICY_DIR_TOVPN;
6881         } else {
6882                 vty_out(vty, "%% unknown direction %s\n", direction_str);
6883                 return CMD_WARNING_CONFIG_FAILED;
6884         }
6885
6886         previous_state = CHECK_FLAG(bgp->af_flags[afi][safi], flag);
6887
6888         if (yes) {
6889                 SET_FLAG(bgp->af_flags[afi][safi], flag);
6890                 if (!previous_state) {
6891                         /* trigger export current vrf */
6892                         vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6893                 }
6894         } else {
6895                 if (previous_state) {
6896                         /* trigger un-export current vrf */
6897                         vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6898                 }
6899                 UNSET_FLAG(bgp->af_flags[afi][safi], flag);
6900         }
6901
6902         return CMD_SUCCESS;
6903 }
6904
6905 DEFPY (af_routetarget_import,
6906        af_routetarget_import_cmd,
6907        "[no] <rt|route-target> redirect import RTLIST...",
6908        NO_STR
6909        "Specify route target list\n"
6910        "Specify route target list\n"
6911        "Flow-spec redirect type route target\n"
6912        "Import routes to this address-family\n"
6913        "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6914 {
6915         VTY_DECLVAR_CONTEXT(bgp, bgp);
6916         int ret;
6917         struct ecommunity *ecom = NULL;
6918         afi_t afi;
6919         int idx = 0;
6920         int yes = 1;
6921
6922         if (argv_find(argv, argc, "no", &idx))
6923                 yes = 0;
6924
6925         afi = vpn_policy_getafi(vty, bgp, false);
6926         if (afi == AFI_MAX)
6927                 return CMD_WARNING_CONFIG_FAILED;
6928
6929         if (yes) {
6930                 if (!argv_find(argv, argc, "RTLIST", &idx)) {
6931                         vty_out(vty, "%% Missing RTLIST\n");
6932                         return CMD_WARNING_CONFIG_FAILED;
6933                 }
6934                 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom);
6935                 if (ret != CMD_SUCCESS)
6936                         return ret;
6937         }
6938
6939         if (yes) {
6940                 if (bgp->vpn_policy[afi].import_redirect_rtlist)
6941                         ecommunity_free(&bgp->vpn_policy[afi]
6942                                         .import_redirect_rtlist);
6943                 bgp->vpn_policy[afi].import_redirect_rtlist =
6944                         ecommunity_dup(ecom);
6945         } else {
6946                 if (bgp->vpn_policy[afi].import_redirect_rtlist)
6947                         ecommunity_free(&bgp->vpn_policy[afi]
6948                                         .import_redirect_rtlist);
6949                 bgp->vpn_policy[afi].import_redirect_rtlist = NULL;
6950         }
6951
6952         if (ecom)
6953                 ecommunity_free(&ecom);
6954
6955         return CMD_SUCCESS;
6956 }
6957
6958 DEFUN_NOSH (address_family_ipv4_safi,
6959         address_family_ipv4_safi_cmd,
6960         "address-family ipv4 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
6961         "Enter Address Family command mode\n"
6962         "Address Family\n"
6963         BGP_SAFI_WITH_LABEL_HELP_STR)
6964 {
6965
6966         if (argc == 3) {
6967                 VTY_DECLVAR_CONTEXT(bgp, bgp);
6968                 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
6969                 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
6970                     && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
6971                     && safi != SAFI_EVPN) {
6972                         vty_out(vty,
6973                                 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
6974                         return CMD_WARNING_CONFIG_FAILED;
6975                 }
6976                 vty->node = bgp_node_type(AFI_IP, safi);
6977         } else
6978                 vty->node = BGP_IPV4_NODE;
6979
6980         return CMD_SUCCESS;
6981 }
6982
6983 DEFUN_NOSH (address_family_ipv6_safi,
6984         address_family_ipv6_safi_cmd,
6985         "address-family ipv6 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
6986         "Enter Address Family command mode\n"
6987         "Address Family\n"
6988         BGP_SAFI_WITH_LABEL_HELP_STR)
6989 {
6990         if (argc == 3) {
6991                 VTY_DECLVAR_CONTEXT(bgp, bgp);
6992                 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
6993                 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
6994                     && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
6995                     && safi != SAFI_EVPN) {
6996                         vty_out(vty,
6997                                 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
6998                         return CMD_WARNING_CONFIG_FAILED;
6999                 }
7000                 vty->node = bgp_node_type(AFI_IP6, safi);
7001         } else
7002                 vty->node = BGP_IPV6_NODE;
7003
7004         return CMD_SUCCESS;
7005 }
7006
7007 #ifdef KEEP_OLD_VPN_COMMANDS
7008 DEFUN_NOSH (address_family_vpnv4,
7009        address_family_vpnv4_cmd,
7010        "address-family vpnv4 [unicast]",
7011        "Enter Address Family command mode\n"
7012        "Address Family\n"
7013        "Address Family modifier\n")
7014 {
7015         vty->node = BGP_VPNV4_NODE;
7016         return CMD_SUCCESS;
7017 }
7018
7019 DEFUN_NOSH (address_family_vpnv6,
7020        address_family_vpnv6_cmd,
7021        "address-family vpnv6 [unicast]",
7022        "Enter Address Family command mode\n"
7023        "Address Family\n"
7024        "Address Family modifier\n")
7025 {
7026         vty->node = BGP_VPNV6_NODE;
7027         return CMD_SUCCESS;
7028 }
7029 #endif
7030
7031 DEFUN_NOSH (address_family_evpn,
7032        address_family_evpn_cmd,
7033        "address-family l2vpn evpn",
7034        "Enter Address Family command mode\n"
7035        "Address Family\n"
7036        "Address Family modifier\n")
7037 {
7038         VTY_DECLVAR_CONTEXT(bgp, bgp);
7039         vty->node = BGP_EVPN_NODE;
7040         return CMD_SUCCESS;
7041 }
7042
7043 DEFUN_NOSH (exit_address_family,
7044        exit_address_family_cmd,
7045        "exit-address-family",
7046        "Exit from Address Family configuration mode\n")
7047 {
7048         if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
7049             || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
7050             || vty->node == BGP_IPV6_NODE || vty->node == BGP_IPV6M_NODE
7051             || vty->node == BGP_IPV6L_NODE || vty->node == BGP_VPNV6_NODE
7052             || vty->node == BGP_EVPN_NODE
7053             || vty->node == BGP_FLOWSPECV4_NODE
7054             || vty->node == BGP_FLOWSPECV6_NODE)
7055                 vty->node = BGP_NODE;
7056         return CMD_SUCCESS;
7057 }
7058
7059 /* Recalculate bestpath and re-advertise a prefix */
7060 static int bgp_clear_prefix(struct vty *vty, const char *view_name,
7061                             const char *ip_str, afi_t afi, safi_t safi,
7062                             struct prefix_rd *prd)
7063 {
7064         int ret;
7065         struct prefix match;
7066         struct bgp_node *rn;
7067         struct bgp_node *rm;
7068         struct bgp *bgp;
7069         struct bgp_table *table;
7070         struct bgp_table *rib;
7071
7072         /* BGP structure lookup. */
7073         if (view_name) {
7074                 bgp = bgp_lookup_by_name(view_name);
7075                 if (bgp == NULL) {
7076                         vty_out(vty, "%% Can't find BGP instance %s\n",
7077                                 view_name);
7078                         return CMD_WARNING;
7079                 }
7080         } else {
7081                 bgp = bgp_get_default();
7082                 if (bgp == NULL) {
7083                         vty_out(vty, "%% No BGP process is configured\n");
7084                         return CMD_WARNING;
7085                 }
7086         }
7087
7088         /* Check IP address argument. */
7089         ret = str2prefix(ip_str, &match);
7090         if (!ret) {
7091                 vty_out(vty, "%% address is malformed\n");
7092                 return CMD_WARNING;
7093         }
7094
7095         match.family = afi2family(afi);
7096         rib = bgp->rib[afi][safi];
7097
7098         if (safi == SAFI_MPLS_VPN) {
7099                 for (rn = bgp_table_top(rib); rn; rn = bgp_route_next(rn)) {
7100                         if (prd && memcmp(rn->p.u.val, prd->val, 8) != 0)
7101                                 continue;
7102
7103                         if ((table = rn->info) != NULL) {
7104                                 if ((rm = bgp_node_match(table, &match))
7105                                     != NULL) {
7106                                         if (rm->p.prefixlen
7107                                             == match.prefixlen) {
7108                                                 SET_FLAG(rm->flags,
7109                                                          BGP_NODE_USER_CLEAR);
7110                                                 bgp_process(bgp, rm, afi, safi);
7111                                         }
7112                                         bgp_unlock_node(rm);
7113                                 }
7114                         }
7115                 }
7116         } else {
7117                 if ((rn = bgp_node_match(rib, &match)) != NULL) {
7118                         if (rn->p.prefixlen == match.prefixlen) {
7119                                 SET_FLAG(rn->flags, BGP_NODE_USER_CLEAR);
7120                                 bgp_process(bgp, rn, afi, safi);
7121                         }
7122                         bgp_unlock_node(rn);
7123                 }
7124         }
7125
7126         return CMD_SUCCESS;
7127 }
7128
7129 /* one clear bgp command to rule them all */
7130 DEFUN (clear_ip_bgp_all,
7131        clear_ip_bgp_all_cmd,
7132        "clear [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group WORD> [<soft [<in|out>]|in [prefix-filter]|out>]",
7133        CLEAR_STR
7134        IP_STR
7135        BGP_STR
7136        BGP_INSTANCE_HELP_STR
7137        BGP_AFI_HELP_STR
7138        BGP_SAFI_WITH_LABEL_HELP_STR
7139        "Clear all peers\n"
7140        "BGP neighbor address to clear\n"
7141        "BGP IPv6 neighbor to clear\n"
7142        "BGP neighbor on interface to clear\n"
7143        "Clear peers with the AS number\n"
7144        "Clear all external peers\n"
7145        "Clear all members of peer-group\n"
7146        "BGP peer-group name\n"
7147        BGP_SOFT_STR
7148        BGP_SOFT_IN_STR
7149        BGP_SOFT_OUT_STR
7150        BGP_SOFT_IN_STR
7151        "Push out prefix-list ORF and do inbound soft reconfig\n"
7152        BGP_SOFT_OUT_STR)
7153 {
7154         char *vrf = NULL;
7155
7156         afi_t afi = AFI_IP6;
7157         safi_t safi = SAFI_UNICAST;
7158         enum clear_sort clr_sort = clear_peer;
7159         enum bgp_clear_type clr_type;
7160         char *clr_arg = NULL;
7161
7162         int idx = 0;
7163
7164         /* clear [ip] bgp */
7165         if (argv_find(argv, argc, "ip", &idx))
7166                 afi = AFI_IP;
7167
7168         /* [<vrf> VIEWVRFNAME] */
7169         if (argv_find(argv, argc, "vrf", &idx)) {
7170                 vrf = argv[idx + 1]->arg;
7171                 idx += 2;
7172                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
7173                         vrf = NULL;
7174         } else if (argv_find(argv, argc, "view", &idx)) {
7175                 /* [<view> VIEWVRFNAME] */
7176                 vrf = argv[idx + 1]->arg;
7177                 idx += 2;
7178         }
7179         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
7180         if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
7181                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
7182
7183         /* <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group WORD> */
7184         if (argv_find(argv, argc, "*", &idx)) {
7185                 clr_sort = clear_all;
7186         } else if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7187                 clr_sort = clear_peer;
7188                 clr_arg = argv[idx]->arg;
7189         } else if (argv_find(argv, argc, "X:X::X:X", &idx)) {
7190                 clr_sort = clear_peer;
7191                 clr_arg = argv[idx]->arg;
7192         } else if (argv_find(argv, argc, "peer-group", &idx)) {
7193                 clr_sort = clear_group;
7194                 idx++;
7195                 clr_arg = argv[idx]->arg;
7196         } else if (argv_find(argv, argc, "WORD", &idx)) {
7197                 clr_sort = clear_peer;
7198                 clr_arg = argv[idx]->arg;
7199         } else if (argv_find(argv, argc, "(1-4294967295)", &idx)) {
7200                 clr_sort = clear_as;
7201                 clr_arg = argv[idx]->arg;
7202         } else if (argv_find(argv, argc, "external", &idx)) {
7203                 clr_sort = clear_external;
7204         }
7205
7206         /* [<soft [<in|out>]|in [prefix-filter]|out>] */
7207         if (argv_find(argv, argc, "soft", &idx)) {
7208                 if (argv_find(argv, argc, "in", &idx)
7209                     || argv_find(argv, argc, "out", &idx))
7210                         clr_type = strmatch(argv[idx]->text, "in")
7211                                            ? BGP_CLEAR_SOFT_IN
7212                                            : BGP_CLEAR_SOFT_OUT;
7213                 else
7214                         clr_type = BGP_CLEAR_SOFT_BOTH;
7215         } else if (argv_find(argv, argc, "in", &idx)) {
7216                 clr_type = argv_find(argv, argc, "prefix-filter", &idx)
7217                                    ? BGP_CLEAR_SOFT_IN_ORF_PREFIX
7218                                    : BGP_CLEAR_SOFT_IN;
7219         } else if (argv_find(argv, argc, "out", &idx)) {
7220                 clr_type = BGP_CLEAR_SOFT_OUT;
7221         } else
7222                 clr_type = BGP_CLEAR_SOFT_NONE;
7223
7224         return bgp_clear_vty(vty, vrf, afi, safi, clr_sort, clr_type, clr_arg);
7225 }
7226
7227 DEFUN (clear_ip_bgp_prefix,
7228        clear_ip_bgp_prefix_cmd,
7229        "clear [ip] bgp [<view|vrf> VIEWVRFNAME] prefix A.B.C.D/M",
7230        CLEAR_STR
7231        IP_STR
7232        BGP_STR
7233        BGP_INSTANCE_HELP_STR
7234        "Clear bestpath and re-advertise\n"
7235        "IPv4 prefix\n")
7236 {
7237         char *vrf = NULL;
7238         char *prefix = NULL;
7239
7240         int idx = 0;
7241
7242         /* [<view|vrf> VIEWVRFNAME] */
7243         if (argv_find(argv, argc, "vrf", &idx)) {
7244                 vrf = argv[idx + 1]->arg;
7245                 idx += 2;
7246                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
7247                         vrf = NULL;
7248         } else if (argv_find(argv, argc, "view", &idx)) {
7249                 /* [<view> VIEWVRFNAME] */
7250                 vrf = argv[idx + 1]->arg;
7251                 idx += 2;
7252         }
7253
7254         prefix = argv[argc - 1]->arg;
7255
7256         return bgp_clear_prefix(vty, vrf, prefix, AFI_IP, SAFI_UNICAST, NULL);
7257 }
7258
7259 DEFUN (clear_bgp_ipv6_safi_prefix,
7260        clear_bgp_ipv6_safi_prefix_cmd,
7261        "clear [ip] bgp ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
7262        CLEAR_STR
7263        IP_STR
7264        BGP_STR
7265        "Address Family\n"
7266        BGP_SAFI_HELP_STR
7267        "Clear bestpath and re-advertise\n"
7268        "IPv6 prefix\n")
7269 {
7270         int idx_safi = 0;
7271         int idx_ipv6_prefix = 0;
7272         safi_t safi = SAFI_UNICAST;
7273         char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
7274                 argv[idx_ipv6_prefix]->arg : NULL;
7275
7276         argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
7277         return bgp_clear_prefix(
7278                 vty, NULL, prefix, AFI_IP6,
7279                 safi, NULL);
7280 }
7281
7282 DEFUN (clear_bgp_instance_ipv6_safi_prefix,
7283        clear_bgp_instance_ipv6_safi_prefix_cmd,
7284        "clear [ip] bgp <view|vrf> VIEWVRFNAME ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
7285        CLEAR_STR
7286        IP_STR
7287        BGP_STR
7288        BGP_INSTANCE_HELP_STR
7289        "Address Family\n"
7290        BGP_SAFI_HELP_STR
7291        "Clear bestpath and re-advertise\n"
7292        "IPv6 prefix\n")
7293 {
7294         int idx_safi = 0;
7295         int idx_vrfview = 0;
7296         int idx_ipv6_prefix = 0;
7297         safi_t safi = SAFI_UNICAST;
7298         char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
7299                 argv[idx_ipv6_prefix]->arg : NULL;
7300         char *vrfview = NULL;
7301
7302         /* [<view|vrf> VIEWVRFNAME] */
7303         if (argv_find(argv, argc, "vrf", &idx_vrfview)) {
7304                 vrfview = argv[idx_vrfview + 1]->arg;
7305                 if (vrfview && strmatch(vrfview, VRF_DEFAULT_NAME))
7306                         vrfview = NULL;
7307         } else if (argv_find(argv, argc, "view", &idx_vrfview)) {
7308                 /* [<view> VIEWVRFNAME] */
7309                 vrfview = argv[idx_vrfview + 1]->arg;
7310         }
7311         argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
7312
7313         return bgp_clear_prefix(
7314                 vty, vrfview, prefix,
7315                 AFI_IP6, safi, NULL);
7316 }
7317
7318 DEFUN (show_bgp_views,
7319        show_bgp_views_cmd,
7320        "show [ip] bgp views",
7321        SHOW_STR
7322        IP_STR
7323        BGP_STR
7324        "Show the defined BGP views\n")
7325 {
7326         struct list *inst = bm->bgp;
7327         struct listnode *node;
7328         struct bgp *bgp;
7329
7330         if (!bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE)) {
7331                 vty_out(vty, "BGP Multiple Instance is not enabled\n");
7332                 return CMD_WARNING;
7333         }
7334
7335         vty_out(vty, "Defined BGP views:\n");
7336         for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
7337                 /* Skip VRFs. */
7338                 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
7339                         continue;
7340                 vty_out(vty, "\t%s (AS%u)\n", bgp->name ? bgp->name : "(null)",
7341                         bgp->as);
7342         }
7343
7344         return CMD_SUCCESS;
7345 }
7346
7347 DEFUN (show_bgp_vrfs,
7348        show_bgp_vrfs_cmd,
7349        "show [ip] bgp vrfs [json]",
7350        SHOW_STR
7351        IP_STR
7352        BGP_STR
7353        "Show BGP VRFs\n"
7354        JSON_STR)
7355 {
7356         char buf[ETHER_ADDR_STRLEN];
7357         struct list *inst = bm->bgp;
7358         struct listnode *node;
7359         struct bgp *bgp;
7360         bool uj = use_json(argc, argv);
7361         json_object *json = NULL;
7362         json_object *json_vrfs = NULL;
7363         int count = 0;
7364
7365         if (!bgp_option_check(BGP_OPT_MULTIPLE_INSTANCE)) {
7366                 vty_out(vty, "BGP Multiple Instance is not enabled\n");
7367                 return CMD_WARNING;
7368         }
7369
7370         if (uj) {
7371                 json = json_object_new_object();
7372                 json_vrfs = json_object_new_object();
7373         }
7374
7375         for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
7376                 const char *name, *type;
7377                 struct peer *peer;
7378                 struct listnode *node2, *nnode2;
7379                 int peers_cfg, peers_estb;
7380                 json_object *json_vrf = NULL;
7381
7382                 /* Skip Views. */
7383                 if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
7384                         continue;
7385
7386                 count++;
7387                 if (!uj && count == 1)
7388                         vty_out(vty,
7389                                 "%4s  %-5s  %-16s  %9s  %10s  %-37s %-10s %-15s\n",
7390                                 "Type", "Id", "routerId", "#PeersVfg",
7391                                 "#PeersEstb", "Name", "L3-VNI", "Rmac");
7392
7393                 peers_cfg = peers_estb = 0;
7394                 if (uj)
7395                         json_vrf = json_object_new_object();
7396
7397
7398                 for (ALL_LIST_ELEMENTS(bgp->peer, node2, nnode2, peer)) {
7399                         if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7400                                 continue;
7401                         peers_cfg++;
7402                         if (peer->status == Established)
7403                                 peers_estb++;
7404                 }
7405
7406                 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
7407                         name = "Default";
7408                         type = "DFLT";
7409                 } else {
7410                         name = bgp->name;
7411                         type = "VRF";
7412                 }
7413
7414
7415                 if (uj) {
7416                         int64_t vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
7417                                                     ? -1
7418                                                     : (int64_t)bgp->vrf_id;
7419                         json_object_string_add(json_vrf, "type", type);
7420                         json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
7421                         json_object_string_add(json_vrf, "routerId",
7422                                                inet_ntoa(bgp->router_id));
7423                         json_object_int_add(json_vrf, "numConfiguredPeers",
7424                                             peers_cfg);
7425                         json_object_int_add(json_vrf, "numEstablishedPeers",
7426                                             peers_estb);
7427
7428                         json_object_int_add(json_vrf, "l3vni", bgp->l3vni);
7429                         json_object_string_add(
7430                                 json_vrf, "rmac",
7431                                 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
7432                         json_object_object_add(json_vrfs, name, json_vrf);
7433                 } else
7434                         vty_out(vty,
7435                                 "%4s  %-5d  %-16s  %9u  %10u  %-37s %-10u %-15s\n",
7436                                 type,
7437                                 bgp->vrf_id == VRF_UNKNOWN ? -1
7438                                                            : (int)bgp->vrf_id,
7439                                 inet_ntoa(bgp->router_id), peers_cfg,
7440                                 peers_estb, name, bgp->l3vni,
7441                                 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
7442         }
7443
7444         if (uj) {
7445                 json_object_object_add(json, "vrfs", json_vrfs);
7446
7447                 json_object_int_add(json, "totalVrfs", count);
7448
7449                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
7450                                              json, JSON_C_TO_STRING_PRETTY));
7451                 json_object_free(json);
7452         } else {
7453                 if (count)
7454                         vty_out(vty,
7455                                 "\nTotal number of VRFs (including default): %d\n",
7456                                 count);
7457         }
7458
7459         return CMD_SUCCESS;
7460 }
7461
7462
7463 static void show_tip_entry(struct hash_backet *backet, void *args)
7464 {
7465         struct vty *vty = (struct vty *)args;
7466         struct tip_addr *tip = (struct tip_addr *)backet->data;
7467
7468         vty_out(vty, "addr: %s, count: %d\n", inet_ntoa(tip->addr),
7469                 tip->refcnt);
7470 }
7471
7472 static void bgp_show_martian_nexthops(struct vty *vty, struct bgp *bgp)
7473 {
7474         vty_out(vty, "self nexthop database:\n");
7475         bgp_nexthop_show_address_hash(vty, bgp);
7476
7477         vty_out(vty, "Tunnel-ip database:\n");
7478         hash_iterate(bgp->tip_hash,
7479                      (void (*)(struct hash_backet *, void *))show_tip_entry,
7480                      vty);
7481 }
7482
7483 DEFUN(show_bgp_martian_nexthop_db, show_bgp_martian_nexthop_db_cmd,
7484       "show bgp [<view|vrf> VIEWVRFNAME] martian next-hop",
7485       SHOW_STR BGP_STR BGP_INSTANCE_HELP_STR
7486       "martian next-hops\n"
7487       "martian next-hop database\n")
7488 {
7489         struct bgp *bgp = NULL;
7490         int idx = 0;
7491         char *name = NULL;
7492
7493         /* [<vrf> VIEWVRFNAME] */
7494         if (argv_find(argv, argc, "vrf", &idx)) {
7495                 name = argv[idx + 1]->arg;
7496                 if (name && strmatch(name, VRF_DEFAULT_NAME))
7497                         name = NULL;
7498         } else if (argv_find(argv, argc, "view", &idx))
7499                 /* [<view> VIEWVRFNAME] */
7500                 name = argv[idx + 1]->arg;
7501         if (name)
7502                 bgp = bgp_lookup_by_name(name);
7503         else
7504                 bgp = bgp_get_default();
7505
7506         if (!bgp) {
7507                 vty_out(vty, "%% No BGP process is configured\n");
7508                 return CMD_WARNING;
7509         }
7510         bgp_show_martian_nexthops(vty, bgp);
7511
7512         return CMD_SUCCESS;
7513 }
7514
7515 DEFUN (show_bgp_memory,
7516        show_bgp_memory_cmd,
7517        "show [ip] bgp memory",
7518        SHOW_STR
7519        IP_STR
7520        BGP_STR
7521        "Global BGP memory statistics\n")
7522 {
7523         char memstrbuf[MTYPE_MEMSTR_LEN];
7524         unsigned long count;
7525
7526         /* RIB related usage stats */
7527         count = mtype_stats_alloc(MTYPE_BGP_NODE);
7528         vty_out(vty, "%ld RIB nodes, using %s of memory\n", count,
7529                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7530                              count * sizeof(struct bgp_node)));
7531
7532         count = mtype_stats_alloc(MTYPE_BGP_ROUTE);
7533         vty_out(vty, "%ld BGP routes, using %s of memory\n", count,
7534                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7535                              count * sizeof(struct bgp_path_info)));
7536         if ((count = mtype_stats_alloc(MTYPE_BGP_ROUTE_EXTRA)))
7537                 vty_out(vty, "%ld BGP route ancillaries, using %s of memory\n",
7538                         count,
7539                         mtype_memstr(
7540                                 memstrbuf, sizeof(memstrbuf),
7541                                 count * sizeof(struct bgp_path_info_extra)));
7542
7543         if ((count = mtype_stats_alloc(MTYPE_BGP_STATIC)))
7544                 vty_out(vty, "%ld Static routes, using %s of memory\n", count,
7545                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7546                                      count * sizeof(struct bgp_static)));
7547
7548         if ((count = mtype_stats_alloc(MTYPE_BGP_PACKET)))
7549                 vty_out(vty, "%ld Packets, using %s of memory\n", count,
7550                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7551                                      count * sizeof(struct bpacket)));
7552
7553         /* Adj-In/Out */
7554         if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_IN)))
7555                 vty_out(vty, "%ld Adj-In entries, using %s of memory\n", count,
7556                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7557                                      count * sizeof(struct bgp_adj_in)));
7558         if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_OUT)))
7559                 vty_out(vty, "%ld Adj-Out entries, using %s of memory\n", count,
7560                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7561                                      count * sizeof(struct bgp_adj_out)));
7562
7563         if ((count = mtype_stats_alloc(MTYPE_BGP_NEXTHOP_CACHE)))
7564                 vty_out(vty, "%ld Nexthop cache entries, using %s of memory\n",
7565                         count,
7566                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7567                                      count * sizeof(struct bgp_nexthop_cache)));
7568
7569         if ((count = mtype_stats_alloc(MTYPE_BGP_DAMP_INFO)))
7570                 vty_out(vty, "%ld Dampening entries, using %s of memory\n",
7571                         count,
7572                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7573                                      count * sizeof(struct bgp_damp_info)));
7574
7575         /* Attributes */
7576         count = attr_count();
7577         vty_out(vty, "%ld BGP attributes, using %s of memory\n", count,
7578                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7579                              count * sizeof(struct attr)));
7580
7581         if ((count = attr_unknown_count()))
7582                 vty_out(vty, "%ld unknown attributes\n", count);
7583
7584         /* AS_PATH attributes */
7585         count = aspath_count();
7586         vty_out(vty, "%ld BGP AS-PATH entries, using %s of memory\n", count,
7587                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7588                              count * sizeof(struct aspath)));
7589
7590         count = mtype_stats_alloc(MTYPE_AS_SEG);
7591         vty_out(vty, "%ld BGP AS-PATH segments, using %s of memory\n", count,
7592                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7593                              count * sizeof(struct assegment)));
7594
7595         /* Other attributes */
7596         if ((count = community_count()))
7597                 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
7598                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7599                                             count * sizeof(struct community)));
7600         if ((count = mtype_stats_alloc(MTYPE_ECOMMUNITY)))
7601                 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
7602                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7603                                             count * sizeof(struct ecommunity)));
7604         if ((count = mtype_stats_alloc(MTYPE_LCOMMUNITY)))
7605                 vty_out(vty,
7606                         "%ld BGP large-community entries, using %s of memory\n",
7607                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7608                                             count * sizeof(struct lcommunity)));
7609
7610         if ((count = mtype_stats_alloc(MTYPE_CLUSTER)))
7611                 vty_out(vty, "%ld Cluster lists, using %s of memory\n", count,
7612                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7613                                      count * sizeof(struct cluster_list)));
7614
7615         /* Peer related usage */
7616         count = mtype_stats_alloc(MTYPE_BGP_PEER);
7617         vty_out(vty, "%ld peers, using %s of memory\n", count,
7618                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7619                              count * sizeof(struct peer)));
7620
7621         if ((count = mtype_stats_alloc(MTYPE_PEER_GROUP)))
7622                 vty_out(vty, "%ld peer groups, using %s of memory\n", count,
7623                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7624                                      count * sizeof(struct peer_group)));
7625
7626         /* Other */
7627         if ((count = mtype_stats_alloc(MTYPE_HASH)))
7628                 vty_out(vty, "%ld hash tables, using %s of memory\n", count,
7629                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7630                                      count * sizeof(struct hash)));
7631         if ((count = mtype_stats_alloc(MTYPE_HASH_BACKET)))
7632                 vty_out(vty, "%ld hash buckets, using %s of memory\n", count,
7633                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7634                                      count * sizeof(struct hash_backet)));
7635         if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
7636                 vty_out(vty, "%ld compiled regexes, using %s of memory\n",
7637                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7638                                             count * sizeof(regex_t)));
7639         return CMD_SUCCESS;
7640 }
7641
7642 static void bgp_show_bestpath_json(struct bgp *bgp, json_object *json)
7643 {
7644         json_object *bestpath = json_object_new_object();
7645
7646         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_IGNORE))
7647                 json_object_string_add(bestpath, "asPath", "ignore");
7648
7649         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_CONFED))
7650                 json_object_string_add(bestpath, "asPath", "confed");
7651
7652         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
7653                 if (bgp_flag_check(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET))
7654                         json_object_string_add(bestpath, "multiPathRelax",
7655                                                "as-set");
7656                 else
7657                         json_object_string_add(bestpath, "multiPathRelax",
7658                                                "true");
7659         } else
7660                 json_object_string_add(bestpath, "multiPathRelax", "false");
7661
7662         if (bgp_flag_check(bgp, BGP_FLAG_COMPARE_ROUTER_ID))
7663                 json_object_string_add(bestpath, "compareRouterId", "true");
7664         if (bgp_flag_check(bgp, BGP_FLAG_MED_CONFED)
7665             || bgp_flag_check(bgp, BGP_FLAG_MED_MISSING_AS_WORST)) {
7666                 if (bgp_flag_check(bgp, BGP_FLAG_MED_CONFED))
7667                         json_object_string_add(bestpath, "med", "confed");
7668                 if (bgp_flag_check(bgp, BGP_FLAG_MED_MISSING_AS_WORST))
7669                         json_object_string_add(bestpath, "med",
7670                                                "missing-as-worst");
7671                 else
7672                         json_object_string_add(bestpath, "med", "true");
7673         }
7674
7675         json_object_object_add(json, "bestPath", bestpath);
7676 }
7677
7678 /* Show BGP peer's summary information. */
7679 static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
7680                             bool use_json, json_object *json)
7681 {
7682         struct peer *peer;
7683         struct listnode *node, *nnode;
7684         unsigned int count = 0, dn_count = 0;
7685         char timebuf[BGP_UPTIME_LEN], dn_flag[2];
7686         char neighbor_buf[VTY_BUFSIZ];
7687         int neighbor_col_default_width = 16;
7688         int len;
7689         int max_neighbor_width = 0;
7690         int pfx_rcd_safi;
7691         json_object *json_peer = NULL;
7692         json_object *json_peers = NULL;
7693         struct peer_af *paf;
7694
7695         /* labeled-unicast routes are installed in the unicast table so in order
7696          * to
7697          * display the correct PfxRcd value we must look at SAFI_UNICAST
7698          */
7699         if (safi == SAFI_LABELED_UNICAST)
7700                 pfx_rcd_safi = SAFI_UNICAST;
7701         else
7702                 pfx_rcd_safi = safi;
7703
7704         if (use_json) {
7705                 if (json == NULL)
7706                         json = json_object_new_object();
7707
7708                 json_peers = json_object_new_object();
7709         } else {
7710                 /* Loop over all neighbors that will be displayed to determine
7711                  * how many
7712                  * characters are needed for the Neighbor column
7713                  */
7714                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
7715                         if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7716                                 continue;
7717
7718                         if (peer->afc[afi][safi]) {
7719                                 memset(dn_flag, '\0', sizeof(dn_flag));
7720                                 if (peer_dynamic_neighbor(peer))
7721                                         dn_flag[0] = '*';
7722
7723                                 if (peer->hostname
7724                                     && bgp_flag_check(bgp,
7725                                                       BGP_FLAG_SHOW_HOSTNAME))
7726                                         sprintf(neighbor_buf, "%s%s(%s) ",
7727                                                 dn_flag, peer->hostname,
7728                                                 peer->host);
7729                                 else
7730                                         sprintf(neighbor_buf, "%s%s ", dn_flag,
7731                                                 peer->host);
7732
7733                                 len = strlen(neighbor_buf);
7734
7735                                 if (len > max_neighbor_width)
7736                                         max_neighbor_width = len;
7737                         }
7738                 }
7739
7740                 /* Originally we displayed the Neighbor column as 16
7741                  * characters wide so make that the default
7742                  */
7743                 if (max_neighbor_width < neighbor_col_default_width)
7744                         max_neighbor_width = neighbor_col_default_width;
7745         }
7746
7747         for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
7748                 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7749                         continue;
7750
7751                 if (!peer->afc[afi][safi])
7752                         continue;
7753
7754                 if (!count) {
7755                         unsigned long ents;
7756                         char memstrbuf[MTYPE_MEMSTR_LEN];
7757                         int64_t vrf_id_ui;
7758
7759                         vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
7760                                             ? -1
7761                                             : (int64_t)bgp->vrf_id;
7762
7763                         /* Usage summary and header */
7764                         if (use_json) {
7765                                 json_object_string_add(
7766                                         json, "routerId",
7767                                         inet_ntoa(bgp->router_id));
7768                                 json_object_int_add(json, "as", bgp->as);
7769                                 json_object_int_add(json, "vrfId", vrf_id_ui);
7770                                 json_object_string_add(
7771                                         json, "vrfName",
7772                                         (bgp->inst_type
7773                                          == BGP_INSTANCE_TYPE_DEFAULT)
7774                                                 ? "Default"
7775                                                 : bgp->name);
7776                         } else {
7777                                 vty_out(vty,
7778                                         "BGP router identifier %s, local AS number %u vrf-id %d",
7779                                         inet_ntoa(bgp->router_id), bgp->as,
7780                                         bgp->vrf_id == VRF_UNKNOWN
7781                                                 ? -1
7782                                                 : (int)bgp->vrf_id);
7783                                 vty_out(vty, "\n");
7784                         }
7785
7786                         if (bgp_update_delay_configured(bgp)) {
7787                                 if (use_json) {
7788                                         json_object_int_add(
7789                                                 json, "updateDelayLimit",
7790                                                 bgp->v_update_delay);
7791
7792                                         if (bgp->v_update_delay
7793                                             != bgp->v_establish_wait)
7794                                                 json_object_int_add(
7795                                                         json,
7796                                                         "updateDelayEstablishWait",
7797                                                         bgp->v_establish_wait);
7798
7799                                         if (bgp_update_delay_active(bgp)) {
7800                                                 json_object_string_add(
7801                                                         json,
7802                                                         "updateDelayFirstNeighbor",
7803                                                         bgp->update_delay_begin_time);
7804                                                 json_object_boolean_true_add(
7805                                                         json,
7806                                                         "updateDelayInProgress");
7807                                         } else {
7808                                                 if (bgp->update_delay_over) {
7809                                                         json_object_string_add(
7810                                                                 json,
7811                                                                 "updateDelayFirstNeighbor",
7812                                                                 bgp->update_delay_begin_time);
7813                                                         json_object_string_add(
7814                                                                 json,
7815                                                                 "updateDelayBestpathResumed",
7816                                                                 bgp->update_delay_end_time);
7817                                                         json_object_string_add(
7818                                                                 json,
7819                                                                 "updateDelayZebraUpdateResume",
7820                                                                 bgp->update_delay_zebra_resume_time);
7821                                                         json_object_string_add(
7822                                                                 json,
7823                                                                 "updateDelayPeerUpdateResume",
7824                                                                 bgp->update_delay_peers_resume_time);
7825                                                 }
7826                                         }
7827                                 } else {
7828                                         vty_out(vty,
7829                                                 "Read-only mode update-delay limit: %d seconds\n",
7830                                                 bgp->v_update_delay);
7831                                         if (bgp->v_update_delay
7832                                             != bgp->v_establish_wait)
7833                                                 vty_out(vty,
7834                                                         "                   Establish wait: %d seconds\n",
7835                                                         bgp->v_establish_wait);
7836
7837                                         if (bgp_update_delay_active(bgp)) {
7838                                                 vty_out(vty,
7839                                                         "  First neighbor established: %s\n",
7840                                                         bgp->update_delay_begin_time);
7841                                                 vty_out(vty,
7842                                                         "  Delay in progress\n");
7843                                         } else {
7844                                                 if (bgp->update_delay_over) {
7845                                                         vty_out(vty,
7846                                                                 "  First neighbor established: %s\n",
7847                                                                 bgp->update_delay_begin_time);
7848                                                         vty_out(vty,
7849                                                                 "          Best-paths resumed: %s\n",
7850                                                                 bgp->update_delay_end_time);
7851                                                         vty_out(vty,
7852                                                                 "        zebra update resumed: %s\n",
7853                                                                 bgp->update_delay_zebra_resume_time);
7854                                                         vty_out(vty,
7855                                                                 "        peers update resumed: %s\n",
7856                                                                 bgp->update_delay_peers_resume_time);
7857                                                 }
7858                                         }
7859                                 }
7860                         }
7861
7862                         if (use_json) {
7863                                 if (bgp_maxmed_onstartup_configured(bgp)
7864                                     && bgp->maxmed_active)
7865                                         json_object_boolean_true_add(
7866                                                 json, "maxMedOnStartup");
7867                                 if (bgp->v_maxmed_admin)
7868                                         json_object_boolean_true_add(
7869                                                 json, "maxMedAdministrative");
7870
7871                                 json_object_int_add(
7872                                         json, "tableVersion",
7873                                         bgp_table_version(bgp->rib[afi][safi]));
7874
7875                                 ents = bgp_table_count(bgp->rib[afi][safi]);
7876                                 json_object_int_add(json, "ribCount", ents);
7877                                 json_object_int_add(
7878                                         json, "ribMemory",
7879                                         ents * sizeof(struct bgp_node));
7880
7881                                 ents = listcount(bgp->peer);
7882                                 json_object_int_add(json, "peerCount", ents);
7883                                 json_object_int_add(json, "peerMemory",
7884                                                     ents * sizeof(struct peer));
7885
7886                                 if ((ents = listcount(bgp->group))) {
7887                                         json_object_int_add(
7888                                                 json, "peerGroupCount", ents);
7889                                         json_object_int_add(
7890                                                 json, "peerGroupMemory",
7891                                                 ents * sizeof(struct
7892                                                               peer_group));
7893                                 }
7894
7895                                 if (CHECK_FLAG(bgp->af_flags[afi][safi],
7896                                                BGP_CONFIG_DAMPENING))
7897                                         json_object_boolean_true_add(
7898                                                 json, "dampeningEnabled");
7899                         } else {
7900                                 if (bgp_maxmed_onstartup_configured(bgp)
7901                                     && bgp->maxmed_active)
7902                                         vty_out(vty,
7903                                                 "Max-med on-startup active\n");
7904                                 if (bgp->v_maxmed_admin)
7905                                         vty_out(vty,
7906                                                 "Max-med administrative active\n");
7907
7908                                 vty_out(vty, "BGP table version %" PRIu64 "\n",
7909                                         bgp_table_version(bgp->rib[afi][safi]));
7910
7911                                 ents = bgp_table_count(bgp->rib[afi][safi]);
7912                                 vty_out(vty,
7913                                         "RIB entries %ld, using %s of memory\n",
7914                                         ents,
7915                                         mtype_memstr(memstrbuf,
7916                                                      sizeof(memstrbuf),
7917                                                      ents * sizeof(struct
7918                                                                    bgp_node)));
7919
7920                                 /* Peer related usage */
7921                                 ents = listcount(bgp->peer);
7922                                 vty_out(vty, "Peers %ld, using %s of memory\n",
7923                                         ents,
7924                                         mtype_memstr(
7925                                                 memstrbuf, sizeof(memstrbuf),
7926                                                 ents * sizeof(struct peer)));
7927
7928                                 if ((ents = listcount(bgp->group)))
7929                                         vty_out(vty,
7930                                                 "Peer groups %ld, using %s of memory\n",
7931                                                 ents,
7932                                                 mtype_memstr(
7933                                                         memstrbuf,
7934                                                         sizeof(memstrbuf),
7935                                                         ents * sizeof(struct
7936                                                                       peer_group)));
7937
7938                                 if (CHECK_FLAG(bgp->af_flags[afi][safi],
7939                                                BGP_CONFIG_DAMPENING))
7940                                         vty_out(vty, "Dampening enabled.\n");
7941                                 vty_out(vty, "\n");
7942
7943                                 /* Subtract 8 here because 'Neighbor' is
7944                                  * 8 characters */
7945                                 vty_out(vty, "Neighbor");
7946                                 vty_out(vty, "%*s", max_neighbor_width - 8,
7947                                         " ");
7948                                 vty_out(vty,
7949                                         "V         AS MsgRcvd MsgSent   TblVer  InQ OutQ  Up/Down State/PfxRcd\n");
7950                         }
7951                 }
7952
7953                 count++;
7954
7955                 if (use_json) {
7956                         json_peer = json_object_new_object();
7957
7958                         if (peer_dynamic_neighbor(peer)) {
7959                                 dn_count++;
7960                                 json_object_boolean_true_add(json_peer,
7961                                                              "dynamicPeer");
7962                         }
7963
7964                         if (peer->hostname)
7965                                 json_object_string_add(json_peer, "hostname",
7966                                                        peer->hostname);
7967
7968                         if (peer->domainname)
7969                                 json_object_string_add(json_peer, "domainname",
7970                                                        peer->domainname);
7971
7972                         json_object_int_add(json_peer, "remoteAs", peer->as);
7973                         json_object_int_add(json_peer, "version", 4);
7974                         json_object_int_add(json_peer, "msgRcvd",
7975                                             PEER_TOTAL_RX(peer));
7976                         json_object_int_add(json_peer, "msgSent",
7977                                             PEER_TOTAL_TX(peer));
7978
7979                         json_object_int_add(json_peer, "tableVersion",
7980                                             peer->version[afi][safi]);
7981                         json_object_int_add(json_peer, "outq",
7982                                             peer->obuf->count);
7983                         json_object_int_add(json_peer, "inq", 0);
7984                         peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
7985                                     use_json, json_peer);
7986                         json_object_int_add(json_peer, "prefixReceivedCount",
7987                                             peer->pcount[afi][pfx_rcd_safi]);
7988                         paf = peer_af_find(peer, afi, pfx_rcd_safi);
7989                         if (paf && PAF_SUBGRP(paf))
7990                                 json_object_int_add(json_peer,
7991                                                 "pfxSnt",
7992                                                 (PAF_SUBGRP(paf))->scount);
7993
7994                         if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
7995                                 json_object_string_add(json_peer, "state",
7996                                                        "Idle (Admin)");
7997                         else if (peer->afc_recv[afi][safi])
7998                                 json_object_string_add(
7999                                         json_peer, "state",
8000                                         lookup_msg(bgp_status_msg, peer->status,
8001                                                    NULL));
8002                         else if (CHECK_FLAG(peer->sflags,
8003                                             PEER_STATUS_PREFIX_OVERFLOW))
8004                                 json_object_string_add(json_peer, "state",
8005                                                        "Idle (PfxCt)");
8006                         else
8007                                 json_object_string_add(
8008                                         json_peer, "state",
8009                                         lookup_msg(bgp_status_msg, peer->status,
8010                                                    NULL));
8011
8012                         if (peer->conf_if)
8013                                 json_object_string_add(json_peer, "idType",
8014                                                        "interface");
8015                         else if (peer->su.sa.sa_family == AF_INET)
8016                                 json_object_string_add(json_peer, "idType",
8017                                                        "ipv4");
8018                         else if (peer->su.sa.sa_family == AF_INET6)
8019                                 json_object_string_add(json_peer, "idType",
8020                                                        "ipv6");
8021
8022                         json_object_object_add(json_peers, peer->host,
8023                                                json_peer);
8024                 } else {
8025                         memset(dn_flag, '\0', sizeof(dn_flag));
8026                         if (peer_dynamic_neighbor(peer)) {
8027                                 dn_count++;
8028                                 dn_flag[0] = '*';
8029                         }
8030
8031                         if (peer->hostname
8032                             && bgp_flag_check(bgp, BGP_FLAG_SHOW_HOSTNAME))
8033                                 len = vty_out(vty, "%s%s(%s)", dn_flag,
8034                                               peer->hostname, peer->host);
8035                         else
8036                                 len = vty_out(vty, "%s%s", dn_flag, peer->host);
8037
8038                         /* pad the neighbor column with spaces */
8039                         if (len < max_neighbor_width)
8040                                 vty_out(vty, "%*s", max_neighbor_width - len,
8041                                         " ");
8042
8043                         vty_out(vty, "4 %10u %7u %7u %8" PRIu64 " %4d %4zd %8s",
8044                                 peer->as, PEER_TOTAL_RX(peer),
8045                                 PEER_TOTAL_TX(peer), peer->version[afi][safi],
8046                                 0, peer->obuf->count,
8047                                 peer_uptime(peer->uptime, timebuf,
8048                                             BGP_UPTIME_LEN, 0, NULL));
8049
8050                         if (peer->status == Established)
8051                                 if (peer->afc_recv[afi][safi])
8052                                         vty_out(vty, " %12ld",
8053                                                 peer->pcount[afi]
8054                                                             [pfx_rcd_safi]);
8055                                 else
8056                                         vty_out(vty, " NoNeg");
8057                         else {
8058                                 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
8059                                         vty_out(vty, " Idle (Admin)");
8060                                 else if (CHECK_FLAG(
8061                                                  peer->sflags,
8062                                                  PEER_STATUS_PREFIX_OVERFLOW))
8063                                         vty_out(vty, " Idle (PfxCt)");
8064                                 else
8065                                         vty_out(vty, " %12s",
8066                                                 lookup_msg(bgp_status_msg,
8067                                                            peer->status, NULL));
8068                         }
8069                         vty_out(vty, "\n");
8070                 }
8071         }
8072
8073         if (use_json) {
8074                 json_object_object_add(json, "peers", json_peers);
8075
8076                 json_object_int_add(json, "totalPeers", count);
8077                 json_object_int_add(json, "dynamicPeers", dn_count);
8078
8079                 bgp_show_bestpath_json(bgp, json);
8080
8081                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
8082                                              json, JSON_C_TO_STRING_PRETTY));
8083                 json_object_free(json);
8084         } else {
8085                 if (count)
8086                         vty_out(vty, "\nTotal number of neighbors %d\n", count);
8087                 else {
8088                         vty_out(vty, "No %s neighbor is configured\n",
8089                                 afi_safi_print(afi, safi));
8090                 }
8091
8092                 if (dn_count) {
8093                         vty_out(vty, "* - dynamic neighbor\n");
8094                         vty_out(vty, "%d dynamic neighbor(s), limit %d\n",
8095                                 dn_count, bgp->dynamic_neighbors_limit);
8096                 }
8097         }
8098
8099         return CMD_SUCCESS;
8100 }
8101
8102 static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
8103                                       int safi, bool use_json,
8104                                       json_object *json)
8105 {
8106         int is_first = 1;
8107         int afi_wildcard = (afi == AFI_MAX);
8108         int safi_wildcard = (safi == SAFI_MAX);
8109         int is_wildcard = (afi_wildcard || safi_wildcard);
8110         bool nbr_output = false;
8111
8112         if (use_json && is_wildcard)
8113                 vty_out(vty, "{\n");
8114         if (afi_wildcard)
8115                 afi = 1; /* AFI_IP */
8116         while (afi < AFI_MAX) {
8117                 if (safi_wildcard)
8118                         safi = 1; /* SAFI_UNICAST */
8119                 while (safi < SAFI_MAX) {
8120                         if (bgp_afi_safi_peer_exists(bgp, afi, safi)) {
8121                                 nbr_output = true;
8122                                 if (is_wildcard) {
8123                                         /*
8124                                          * So limit output to those afi/safi
8125                                          * pairs that
8126                                          * actualy have something interesting in
8127                                          * them
8128                                          */
8129                                         if (use_json) {
8130                                                 json = json_object_new_object();
8131
8132                                                 if (!is_first)
8133                                                         vty_out(vty, ",\n");
8134                                                 else
8135                                                         is_first = 0;
8136
8137                                                 vty_out(vty, "\"%s\":",
8138                                                         afi_safi_json(afi,
8139                                                                       safi));
8140                                         } else {
8141                                                 vty_out(vty, "\n%s Summary:\n",
8142                                                         afi_safi_print(afi,
8143                                                                        safi));
8144                                         }
8145                                 }
8146                                 bgp_show_summary(vty, bgp, afi, safi, use_json,
8147                                                  json);
8148                         }
8149                         safi++;
8150                         if (!safi_wildcard)
8151                                 safi = SAFI_MAX;
8152                 }
8153                 afi++;
8154                 if (!afi_wildcard)
8155                         afi = AFI_MAX;
8156         }
8157
8158         if (use_json && is_wildcard)
8159                 vty_out(vty, "}\n");
8160         else if (!nbr_output) {
8161                 if (use_json)
8162                         vty_out(vty, "{}\n");
8163                 else
8164                         vty_out(vty, "%% No BGP neighbors found\n");
8165         }
8166 }
8167
8168 static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
8169                                                safi_t safi, bool use_json)
8170 {
8171         struct listnode *node, *nnode;
8172         struct bgp *bgp;
8173         json_object *json = NULL;
8174         int is_first = 1;
8175         bool nbr_output = false;
8176
8177         if (use_json)
8178                 vty_out(vty, "{\n");
8179
8180         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
8181                 nbr_output = true;
8182                 if (use_json) {
8183                         json = json_object_new_object();
8184
8185                         if (!is_first)
8186                                 vty_out(vty, ",\n");
8187                         else
8188                                 is_first = 0;
8189
8190                         vty_out(vty, "\"%s\":",
8191                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8192                                         ? "Default"
8193                                         : bgp->name);
8194                 } else {
8195                         vty_out(vty, "\nInstance %s:\n",
8196                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8197                                         ? "Default"
8198                                         : bgp->name);
8199                 }
8200                 bgp_show_summary_afi_safi(vty, bgp, afi, safi, use_json, json);
8201         }
8202
8203         if (use_json)
8204                 vty_out(vty, "}\n");
8205         else if (!nbr_output)
8206                 vty_out(vty, "%% BGP instance not found\n");
8207 }
8208
8209 int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
8210                          safi_t safi, bool use_json)
8211 {
8212         struct bgp *bgp;
8213
8214         if (name) {
8215                 if (strmatch(name, "all")) {
8216                         bgp_show_all_instances_summary_vty(vty, afi, safi,
8217                                                            use_json);
8218                         return CMD_SUCCESS;
8219                 } else {
8220                         bgp = bgp_lookup_by_name(name);
8221
8222                         if (!bgp) {
8223                                 if (use_json)
8224                                         vty_out(vty, "{}\n");
8225                                 else
8226                                         vty_out(vty,
8227                                                 "%% BGP instance not found\n");
8228                                 return CMD_WARNING;
8229                         }
8230
8231                         bgp_show_summary_afi_safi(vty, bgp, afi, safi, use_json,
8232                                                   NULL);
8233                         return CMD_SUCCESS;
8234                 }
8235         }
8236
8237         bgp = bgp_get_default();
8238
8239         if (bgp)
8240                 bgp_show_summary_afi_safi(vty, bgp, afi, safi, use_json, NULL);
8241         else {
8242                 if (use_json)
8243                         vty_out(vty, "{}\n");
8244                 else
8245                         vty_out(vty, "%% BGP instance not found\n");
8246                 return CMD_WARNING;
8247         }
8248
8249         return CMD_SUCCESS;
8250 }
8251
8252 /* `show [ip] bgp summary' commands. */
8253 DEFUN (show_ip_bgp_summary,
8254        show_ip_bgp_summary_cmd,
8255        "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] summary [json]",
8256        SHOW_STR
8257        IP_STR
8258        BGP_STR
8259        BGP_INSTANCE_HELP_STR
8260        BGP_AFI_HELP_STR
8261        BGP_SAFI_WITH_LABEL_HELP_STR
8262        "Summary of BGP neighbor status\n"
8263        JSON_STR)
8264 {
8265         char *vrf = NULL;
8266         afi_t afi = AFI_MAX;
8267         safi_t safi = SAFI_MAX;
8268
8269         int idx = 0;
8270
8271         /* show [ip] bgp */
8272         if (argv_find(argv, argc, "ip", &idx))
8273                 afi = AFI_IP;
8274         /* [<vrf> VIEWVRFNAME] */
8275         if (argv_find(argv, argc, "vrf", &idx)) {
8276                 vrf = argv[idx + 1]->arg;
8277                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
8278                         vrf = NULL;
8279         } else if (argv_find(argv, argc, "view", &idx))
8280                 /* [<view> VIEWVRFNAME] */
8281                 vrf = argv[idx + 1]->arg;
8282         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
8283         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
8284                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
8285         }
8286
8287         bool uj = use_json(argc, argv);
8288
8289         return bgp_show_summary_vty(vty, vrf, afi, safi, uj);
8290 }
8291
8292 const char *afi_safi_print(afi_t afi, safi_t safi)
8293 {
8294         if (afi == AFI_IP && safi == SAFI_UNICAST)
8295                 return "IPv4 Unicast";
8296         else if (afi == AFI_IP && safi == SAFI_MULTICAST)
8297                 return "IPv4 Multicast";
8298         else if (afi == AFI_IP && safi == SAFI_LABELED_UNICAST)
8299                 return "IPv4 Labeled Unicast";
8300         else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
8301                 return "IPv4 VPN";
8302         else if (afi == AFI_IP && safi == SAFI_ENCAP)
8303                 return "IPv4 Encap";
8304         else if (afi == AFI_IP && safi == SAFI_FLOWSPEC)
8305                 return "IPv4 Flowspec";
8306         else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
8307                 return "IPv6 Unicast";
8308         else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
8309                 return "IPv6 Multicast";
8310         else if (afi == AFI_IP6 && safi == SAFI_LABELED_UNICAST)
8311                 return "IPv6 Labeled Unicast";
8312         else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
8313                 return "IPv6 VPN";
8314         else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
8315                 return "IPv6 Encap";
8316         else if (afi == AFI_IP6 && safi == SAFI_FLOWSPEC)
8317                 return "IPv6 Flowspec";
8318         else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
8319                 return "L2VPN EVPN";
8320         else
8321                 return "Unknown";
8322 }
8323
8324 /*
8325  * Please note that we have intentionally camelCased
8326  * the return strings here.  So if you want
8327  * to use this function, please ensure you
8328  * are doing this within json output
8329  */
8330 const char *afi_safi_json(afi_t afi, safi_t safi)
8331 {
8332         if (afi == AFI_IP && safi == SAFI_UNICAST)
8333                 return "ipv4Unicast";
8334         else if (afi == AFI_IP && safi == SAFI_MULTICAST)
8335                 return "ipv4Multicast";
8336         else if (afi == AFI_IP && safi == SAFI_LABELED_UNICAST)
8337                 return "ipv4LabeledUnicast";
8338         else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
8339                 return "ipv4Vpn";
8340         else if (afi == AFI_IP && safi == SAFI_ENCAP)
8341                 return "ipv4Encap";
8342         else if (afi == AFI_IP && safi == SAFI_FLOWSPEC)
8343                 return "ipv4Flowspec";
8344         else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
8345                 return "ipv6Unicast";
8346         else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
8347                 return "ipv6Multicast";
8348         else if (afi == AFI_IP6 && safi == SAFI_LABELED_UNICAST)
8349                 return "ipv6LabeledUnicast";
8350         else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
8351                 return "ipv6Vpn";
8352         else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
8353                 return "ipv6Encap";
8354         else if (afi == AFI_IP6 && safi == SAFI_FLOWSPEC)
8355                 return "ipv6Flowspec";
8356         else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
8357                 return "l2VpnEvpn";
8358         else
8359                 return "Unknown";
8360 }
8361
8362 /* Show BGP peer's information. */
8363 enum show_type { show_all, show_peer };
8364
8365 static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
8366                                       afi_t afi, safi_t safi,
8367                                       uint16_t adv_smcap, uint16_t adv_rmcap,
8368                                       uint16_t rcv_smcap, uint16_t rcv_rmcap,
8369                                       bool use_json, json_object *json_pref)
8370 {
8371         /* Send-Mode */
8372         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
8373             || CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap)) {
8374                 if (use_json) {
8375                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
8376                             && CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8377                                 json_object_string_add(json_pref, "sendMode",
8378                                                        "advertisedAndReceived");
8379                         else if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
8380                                 json_object_string_add(json_pref, "sendMode",
8381                                                        "advertised");
8382                         else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8383                                 json_object_string_add(json_pref, "sendMode",
8384                                                        "received");
8385                 } else {
8386                         vty_out(vty, "      Send-mode: ");
8387                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
8388                                 vty_out(vty, "advertised");
8389                         if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8390                                 vty_out(vty, "%sreceived",
8391                                         CHECK_FLAG(p->af_cap[afi][safi],
8392                                                    adv_smcap)
8393                                                 ? ", "
8394                                                 : "");
8395                         vty_out(vty, "\n");
8396                 }
8397         }
8398
8399         /* Receive-Mode */
8400         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
8401             || CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap)) {
8402                 if (use_json) {
8403                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
8404                             && CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8405                                 json_object_string_add(json_pref, "recvMode",
8406                                                        "advertisedAndReceived");
8407                         else if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
8408                                 json_object_string_add(json_pref, "recvMode",
8409                                                        "advertised");
8410                         else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8411                                 json_object_string_add(json_pref, "recvMode",
8412                                                        "received");
8413                 } else {
8414                         vty_out(vty, "      Receive-mode: ");
8415                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
8416                                 vty_out(vty, "advertised");
8417                         if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8418                                 vty_out(vty, "%sreceived",
8419                                         CHECK_FLAG(p->af_cap[afi][safi],
8420                                                    adv_rmcap)
8421                                                 ? ", "
8422                                                 : "");
8423                         vty_out(vty, "\n");
8424                 }
8425         }
8426 }
8427
8428 static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
8429                               safi_t safi, bool use_json,
8430                               json_object *json_neigh)
8431 {
8432         struct bgp_filter *filter;
8433         struct peer_af *paf;
8434         char orf_pfx_name[BUFSIZ];
8435         int orf_pfx_count;
8436         json_object *json_af = NULL;
8437         json_object *json_prefA = NULL;
8438         json_object *json_prefB = NULL;
8439         json_object *json_addr = NULL;
8440
8441         if (use_json) {
8442                 json_addr = json_object_new_object();
8443                 json_af = json_object_new_object();
8444                 filter = &p->filter[afi][safi];
8445
8446                 if (peer_group_active(p))
8447                         json_object_string_add(json_addr, "peerGroupMember",
8448                                                p->group->name);
8449
8450                 paf = peer_af_find(p, afi, safi);
8451                 if (paf && PAF_SUBGRP(paf)) {
8452                         json_object_int_add(json_addr, "updateGroupId",
8453                                             PAF_UPDGRP(paf)->id);
8454                         json_object_int_add(json_addr, "subGroupId",
8455                                             PAF_SUBGRP(paf)->id);
8456                         json_object_int_add(json_addr, "packetQueueLength",
8457                                             bpacket_queue_virtual_length(paf));
8458                 }
8459
8460                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8461                     || CHECK_FLAG(p->af_cap[afi][safi],
8462                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8463                     || CHECK_FLAG(p->af_cap[afi][safi],
8464                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8465                     || CHECK_FLAG(p->af_cap[afi][safi],
8466                                   PEER_CAP_ORF_PREFIX_RM_RCV)) {
8467                         json_object_int_add(json_af, "orfType",
8468                                             ORF_TYPE_PREFIX);
8469                         json_prefA = json_object_new_object();
8470                         bgp_show_peer_afi_orf_cap(vty, p, afi, safi,
8471                                                   PEER_CAP_ORF_PREFIX_SM_ADV,
8472                                                   PEER_CAP_ORF_PREFIX_RM_ADV,
8473                                                   PEER_CAP_ORF_PREFIX_SM_RCV,
8474                                                   PEER_CAP_ORF_PREFIX_RM_RCV,
8475                                                   use_json, json_prefA);
8476                         json_object_object_add(json_af, "orfPrefixList",
8477                                                json_prefA);
8478                 }
8479
8480                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8481                     || CHECK_FLAG(p->af_cap[afi][safi],
8482                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8483                     || CHECK_FLAG(p->af_cap[afi][safi],
8484                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8485                     || CHECK_FLAG(p->af_cap[afi][safi],
8486                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
8487                         json_object_int_add(json_af, "orfOldType",
8488                                             ORF_TYPE_PREFIX_OLD);
8489                         json_prefB = json_object_new_object();
8490                         bgp_show_peer_afi_orf_cap(
8491                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8492                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8493                                 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
8494                                 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json,
8495                                 json_prefB);
8496                         json_object_object_add(json_af, "orfOldPrefixList",
8497                                                json_prefB);
8498                 }
8499
8500                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8501                     || CHECK_FLAG(p->af_cap[afi][safi],
8502                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8503                     || CHECK_FLAG(p->af_cap[afi][safi],
8504                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8505                     || CHECK_FLAG(p->af_cap[afi][safi],
8506                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8507                     || CHECK_FLAG(p->af_cap[afi][safi],
8508                                   PEER_CAP_ORF_PREFIX_RM_RCV)
8509                     || CHECK_FLAG(p->af_cap[afi][safi],
8510                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
8511                         json_object_object_add(json_addr, "afDependentCap",
8512                                                json_af);
8513                 else
8514                         json_object_free(json_af);
8515
8516                 sprintf(orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
8517                 orf_pfx_count = prefix_bgp_show_prefix_list(
8518                         NULL, afi, orf_pfx_name, use_json);
8519
8520                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8521                                PEER_STATUS_ORF_PREFIX_SEND)
8522                     || orf_pfx_count) {
8523                         if (CHECK_FLAG(p->af_sflags[afi][safi],
8524                                        PEER_STATUS_ORF_PREFIX_SEND))
8525                                 json_object_boolean_true_add(json_neigh,
8526                                                              "orfSent");
8527                         if (orf_pfx_count)
8528                                 json_object_int_add(json_addr, "orfRecvCounter",
8529                                                     orf_pfx_count);
8530                 }
8531                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8532                                PEER_STATUS_ORF_WAIT_REFRESH))
8533                         json_object_string_add(
8534                                 json_addr, "orfFirstUpdate",
8535                                 "deferredUntilORFOrRouteRefreshRecvd");
8536
8537                 if (CHECK_FLAG(p->af_flags[afi][safi],
8538                                PEER_FLAG_REFLECTOR_CLIENT))
8539                         json_object_boolean_true_add(json_addr,
8540                                                      "routeReflectorClient");
8541                 if (CHECK_FLAG(p->af_flags[afi][safi],
8542                                PEER_FLAG_RSERVER_CLIENT))
8543                         json_object_boolean_true_add(json_addr,
8544                                                      "routeServerClient");
8545                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
8546                         json_object_boolean_true_add(json_addr,
8547                                                      "inboundSoftConfigPermit");
8548
8549                 if (CHECK_FLAG(p->af_flags[afi][safi],
8550                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
8551                         json_object_boolean_true_add(
8552                                 json_addr,
8553                                 "privateAsNumsAllReplacedInUpdatesToNbr");
8554                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8555                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
8556                         json_object_boolean_true_add(
8557                                 json_addr,
8558                                 "privateAsNumsReplacedInUpdatesToNbr");
8559                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8560                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
8561                         json_object_boolean_true_add(
8562                                 json_addr,
8563                                 "privateAsNumsAllRemovedInUpdatesToNbr");
8564                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8565                                     PEER_FLAG_REMOVE_PRIVATE_AS))
8566                         json_object_boolean_true_add(
8567                                 json_addr,
8568                                 "privateAsNumsRemovedInUpdatesToNbr");
8569
8570                 if (CHECK_FLAG(p->af_flags[afi][safi],
8571                                PEER_FLAG_ADDPATH_TX_ALL_PATHS))
8572                         json_object_boolean_true_add(json_addr,
8573                                                      "addpathTxAllPaths");
8574
8575                 if (CHECK_FLAG(p->af_flags[afi][safi],
8576                                PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS))
8577                         json_object_boolean_true_add(json_addr,
8578                                                      "addpathTxBestpathPerAS");
8579
8580                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
8581                         json_object_string_add(json_addr,
8582                                                "overrideASNsInOutboundUpdates",
8583                                                "ifAspathEqualRemoteAs");
8584
8585                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
8586                     || CHECK_FLAG(p->af_flags[afi][safi],
8587                                   PEER_FLAG_FORCE_NEXTHOP_SELF))
8588                         json_object_boolean_true_add(json_addr,
8589                                                      "routerAlwaysNextHop");
8590                 if (CHECK_FLAG(p->af_flags[afi][safi],
8591                                PEER_FLAG_AS_PATH_UNCHANGED))
8592                         json_object_boolean_true_add(
8593                                 json_addr, "unchangedAsPathPropogatedToNbr");
8594                 if (CHECK_FLAG(p->af_flags[afi][safi],
8595                                PEER_FLAG_NEXTHOP_UNCHANGED))
8596                         json_object_boolean_true_add(
8597                                 json_addr, "unchangedNextHopPropogatedToNbr");
8598                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
8599                         json_object_boolean_true_add(
8600                                 json_addr, "unchangedMedPropogatedToNbr");
8601                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
8602                     || CHECK_FLAG(p->af_flags[afi][safi],
8603                                   PEER_FLAG_SEND_EXT_COMMUNITY)) {
8604                         if (CHECK_FLAG(p->af_flags[afi][safi],
8605                                        PEER_FLAG_SEND_COMMUNITY)
8606                             && CHECK_FLAG(p->af_flags[afi][safi],
8607                                           PEER_FLAG_SEND_EXT_COMMUNITY))
8608                                 json_object_string_add(json_addr,
8609                                                        "commAttriSentToNbr",
8610                                                        "extendedAndStandard");
8611                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8612                                             PEER_FLAG_SEND_EXT_COMMUNITY))
8613                                 json_object_string_add(json_addr,
8614                                                        "commAttriSentToNbr",
8615                                                        "extended");
8616                         else
8617                                 json_object_string_add(json_addr,
8618                                                        "commAttriSentToNbr",
8619                                                        "standard");
8620                 }
8621                 if (CHECK_FLAG(p->af_flags[afi][safi],
8622                                PEER_FLAG_DEFAULT_ORIGINATE)) {
8623                         if (p->default_rmap[afi][safi].name)
8624                                 json_object_string_add(
8625                                         json_addr, "defaultRouteMap",
8626                                         p->default_rmap[afi][safi].name);
8627
8628                         if (paf && PAF_SUBGRP(paf)
8629                             && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
8630                                           SUBGRP_STATUS_DEFAULT_ORIGINATE))
8631                                 json_object_boolean_true_add(json_addr,
8632                                                              "defaultSent");
8633                         else
8634                                 json_object_boolean_true_add(json_addr,
8635                                                              "defaultNotSent");
8636                 }
8637
8638                 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
8639                         if (is_evpn_enabled())
8640                                 json_object_boolean_true_add(
8641                                         json_addr, "advertiseAllVnis");
8642                 }
8643
8644                 if (filter->plist[FILTER_IN].name
8645                     || filter->dlist[FILTER_IN].name
8646                     || filter->aslist[FILTER_IN].name
8647                     || filter->map[RMAP_IN].name)
8648                         json_object_boolean_true_add(json_addr,
8649                                                      "inboundPathPolicyConfig");
8650                 if (filter->plist[FILTER_OUT].name
8651                     || filter->dlist[FILTER_OUT].name
8652                     || filter->aslist[FILTER_OUT].name
8653                     || filter->map[RMAP_OUT].name || filter->usmap.name)
8654                         json_object_boolean_true_add(
8655                                 json_addr, "outboundPathPolicyConfig");
8656
8657                 /* prefix-list */
8658                 if (filter->plist[FILTER_IN].name)
8659                         json_object_string_add(json_addr,
8660                                                "incomingUpdatePrefixFilterList",
8661                                                filter->plist[FILTER_IN].name);
8662                 if (filter->plist[FILTER_OUT].name)
8663                         json_object_string_add(json_addr,
8664                                                "outgoingUpdatePrefixFilterList",
8665                                                filter->plist[FILTER_OUT].name);
8666
8667                 /* distribute-list */
8668                 if (filter->dlist[FILTER_IN].name)
8669                         json_object_string_add(
8670                                 json_addr, "incomingUpdateNetworkFilterList",
8671                                 filter->dlist[FILTER_IN].name);
8672                 if (filter->dlist[FILTER_OUT].name)
8673                         json_object_string_add(
8674                                 json_addr, "outgoingUpdateNetworkFilterList",
8675                                 filter->dlist[FILTER_OUT].name);
8676
8677                 /* filter-list. */
8678                 if (filter->aslist[FILTER_IN].name)
8679                         json_object_string_add(json_addr,
8680                                                "incomingUpdateAsPathFilterList",
8681                                                filter->aslist[FILTER_IN].name);
8682                 if (filter->aslist[FILTER_OUT].name)
8683                         json_object_string_add(json_addr,
8684                                                "outgoingUpdateAsPathFilterList",
8685                                                filter->aslist[FILTER_OUT].name);
8686
8687                 /* route-map. */
8688                 if (filter->map[RMAP_IN].name)
8689                         json_object_string_add(
8690                                 json_addr, "routeMapForIncomingAdvertisements",
8691                                 filter->map[RMAP_IN].name);
8692                 if (filter->map[RMAP_OUT].name)
8693                         json_object_string_add(
8694                                 json_addr, "routeMapForOutgoingAdvertisements",
8695                                 filter->map[RMAP_OUT].name);
8696
8697                 /* unsuppress-map */
8698                 if (filter->usmap.name)
8699                         json_object_string_add(json_addr,
8700                                                "selectiveUnsuppressRouteMap",
8701                                                filter->usmap.name);
8702
8703                 /* Receive prefix count */
8704                 json_object_int_add(json_addr, "acceptedPrefixCounter",
8705                                     p->pcount[afi][safi]);
8706                 if (paf && PAF_SUBGRP(paf))
8707                         json_object_int_add(json_addr, "sentPrefixCounter",
8708                                                 (PAF_SUBGRP(paf))->scount);
8709
8710                 /* Maximum prefix */
8711                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
8712                         json_object_int_add(json_addr, "prefixAllowedMax",
8713                                             p->pmax[afi][safi]);
8714                         if (CHECK_FLAG(p->af_flags[afi][safi],
8715                                        PEER_FLAG_MAX_PREFIX_WARNING))
8716                                 json_object_boolean_true_add(
8717                                         json_addr, "prefixAllowedMaxWarning");
8718                         json_object_int_add(json_addr,
8719                                             "prefixAllowedWarningThresh",
8720                                             p->pmax_threshold[afi][safi]);
8721                         if (p->pmax_restart[afi][safi])
8722                                 json_object_int_add(
8723                                         json_addr,
8724                                         "prefixAllowedRestartIntervalMsecs",
8725                                         p->pmax_restart[afi][safi] * 60000);
8726                 }
8727                 json_object_object_add(json_neigh, afi_safi_print(afi, safi),
8728                                        json_addr);
8729
8730         } else {
8731                 filter = &p->filter[afi][safi];
8732
8733                 vty_out(vty, " For address family: %s\n",
8734                         afi_safi_print(afi, safi));
8735
8736                 if (peer_group_active(p))
8737                         vty_out(vty, "  %s peer-group member\n",
8738                                 p->group->name);
8739
8740                 paf = peer_af_find(p, afi, safi);
8741                 if (paf && PAF_SUBGRP(paf)) {
8742                         vty_out(vty, "  Update group %" PRIu64
8743                                      ", subgroup %" PRIu64 "\n",
8744                                 PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id);
8745                         vty_out(vty, "  Packet Queue length %d\n",
8746                                 bpacket_queue_virtual_length(paf));
8747                 } else {
8748                         vty_out(vty, "  Not part of any update group\n");
8749                 }
8750                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8751                     || CHECK_FLAG(p->af_cap[afi][safi],
8752                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8753                     || CHECK_FLAG(p->af_cap[afi][safi],
8754                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8755                     || CHECK_FLAG(p->af_cap[afi][safi],
8756                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8757                     || CHECK_FLAG(p->af_cap[afi][safi],
8758                                   PEER_CAP_ORF_PREFIX_RM_RCV)
8759                     || CHECK_FLAG(p->af_cap[afi][safi],
8760                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
8761                         vty_out(vty, "  AF-dependant capabilities:\n");
8762
8763                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8764                     || CHECK_FLAG(p->af_cap[afi][safi],
8765                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8766                     || CHECK_FLAG(p->af_cap[afi][safi],
8767                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8768                     || CHECK_FLAG(p->af_cap[afi][safi],
8769                                   PEER_CAP_ORF_PREFIX_RM_RCV)) {
8770                         vty_out(vty,
8771                                 "    Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
8772                                 ORF_TYPE_PREFIX);
8773                         bgp_show_peer_afi_orf_cap(
8774                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8775                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8776                                 PEER_CAP_ORF_PREFIX_SM_RCV,
8777                                 PEER_CAP_ORF_PREFIX_RM_RCV, use_json, NULL);
8778                 }
8779                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8780                     || CHECK_FLAG(p->af_cap[afi][safi],
8781                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8782                     || CHECK_FLAG(p->af_cap[afi][safi],
8783                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8784                     || CHECK_FLAG(p->af_cap[afi][safi],
8785                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
8786                         vty_out(vty,
8787                                 "    Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
8788                                 ORF_TYPE_PREFIX_OLD);
8789                         bgp_show_peer_afi_orf_cap(
8790                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8791                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8792                                 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
8793                                 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, NULL);
8794                 }
8795
8796                 sprintf(orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
8797                 orf_pfx_count = prefix_bgp_show_prefix_list(
8798                         NULL, afi, orf_pfx_name, use_json);
8799
8800                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8801                                PEER_STATUS_ORF_PREFIX_SEND)
8802                     || orf_pfx_count) {
8803                         vty_out(vty, "  Outbound Route Filter (ORF):");
8804                         if (CHECK_FLAG(p->af_sflags[afi][safi],
8805                                        PEER_STATUS_ORF_PREFIX_SEND))
8806                                 vty_out(vty, " sent;");
8807                         if (orf_pfx_count)
8808                                 vty_out(vty, " received (%d entries)",
8809                                         orf_pfx_count);
8810                         vty_out(vty, "\n");
8811                 }
8812                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8813                                PEER_STATUS_ORF_WAIT_REFRESH))
8814                         vty_out(vty,
8815                                 "  First update is deferred until ORF or ROUTE-REFRESH is received\n");
8816
8817                 if (CHECK_FLAG(p->af_flags[afi][safi],
8818                                PEER_FLAG_REFLECTOR_CLIENT))
8819                         vty_out(vty, "  Route-Reflector Client\n");
8820                 if (CHECK_FLAG(p->af_flags[afi][safi],
8821                                PEER_FLAG_RSERVER_CLIENT))
8822                         vty_out(vty, "  Route-Server Client\n");
8823                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
8824                         vty_out(vty,
8825                                 "  Inbound soft reconfiguration allowed\n");
8826
8827                 if (CHECK_FLAG(p->af_flags[afi][safi],
8828                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
8829                         vty_out(vty,
8830                                 "  Private AS numbers (all) replaced in updates to this neighbor\n");
8831                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8832                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
8833                         vty_out(vty,
8834                                 "  Private AS numbers replaced in updates to this neighbor\n");
8835                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8836                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
8837                         vty_out(vty,
8838                                 "  Private AS numbers (all) removed in updates to this neighbor\n");
8839                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8840                                     PEER_FLAG_REMOVE_PRIVATE_AS))
8841                         vty_out(vty,
8842                                 "  Private AS numbers removed in updates to this neighbor\n");
8843
8844                 if (CHECK_FLAG(p->af_flags[afi][safi],
8845                                PEER_FLAG_ADDPATH_TX_ALL_PATHS))
8846                         vty_out(vty, "  Advertise all paths via addpath\n");
8847
8848                 if (CHECK_FLAG(p->af_flags[afi][safi],
8849                                PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS))
8850                         vty_out(vty,
8851                                 "  Advertise bestpath per AS via addpath\n");
8852
8853                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
8854                         vty_out(vty,
8855                                 "  Override ASNs in outbound updates if aspath equals remote-as\n");
8856
8857                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
8858                     || CHECK_FLAG(p->af_flags[afi][safi],
8859                                   PEER_FLAG_FORCE_NEXTHOP_SELF))
8860                         vty_out(vty, "  NEXT_HOP is always this router\n");
8861                 if (CHECK_FLAG(p->af_flags[afi][safi],
8862                                PEER_FLAG_AS_PATH_UNCHANGED))
8863                         vty_out(vty,
8864                                 "  AS_PATH is propagated unchanged to this neighbor\n");
8865                 if (CHECK_FLAG(p->af_flags[afi][safi],
8866                                PEER_FLAG_NEXTHOP_UNCHANGED))
8867                         vty_out(vty,
8868                                 "  NEXT_HOP is propagated unchanged to this neighbor\n");
8869                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
8870                         vty_out(vty,
8871                                 "  MED is propagated unchanged to this neighbor\n");
8872                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
8873                     || CHECK_FLAG(p->af_flags[afi][safi],
8874                                   PEER_FLAG_SEND_EXT_COMMUNITY)
8875                     || CHECK_FLAG(p->af_flags[afi][safi],
8876                                   PEER_FLAG_SEND_LARGE_COMMUNITY)) {
8877                         vty_out(vty,
8878                                 "  Community attribute sent to this neighbor");
8879                         if (CHECK_FLAG(p->af_flags[afi][safi],
8880                                        PEER_FLAG_SEND_COMMUNITY)
8881                             && CHECK_FLAG(p->af_flags[afi][safi],
8882                                           PEER_FLAG_SEND_EXT_COMMUNITY)
8883                             && CHECK_FLAG(p->af_flags[afi][safi],
8884                                           PEER_FLAG_SEND_LARGE_COMMUNITY))
8885                                 vty_out(vty, "(all)\n");
8886                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8887                                             PEER_FLAG_SEND_LARGE_COMMUNITY))
8888                                 vty_out(vty, "(large)\n");
8889                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8890                                             PEER_FLAG_SEND_EXT_COMMUNITY))
8891                                 vty_out(vty, "(extended)\n");
8892                         else
8893                                 vty_out(vty, "(standard)\n");
8894                 }
8895                 if (CHECK_FLAG(p->af_flags[afi][safi],
8896                                PEER_FLAG_DEFAULT_ORIGINATE)) {
8897                         vty_out(vty, "  Default information originate,");
8898
8899                         if (p->default_rmap[afi][safi].name)
8900                                 vty_out(vty, " default route-map %s%s,",
8901                                         p->default_rmap[afi][safi].map ? "*"
8902                                                                        : "",
8903                                         p->default_rmap[afi][safi].name);
8904                         if (paf && PAF_SUBGRP(paf)
8905                             && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
8906                                           SUBGRP_STATUS_DEFAULT_ORIGINATE))
8907                                 vty_out(vty, " default sent\n");
8908                         else
8909                                 vty_out(vty, " default not sent\n");
8910                 }
8911
8912                 /* advertise-vni-all */
8913                 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
8914                         if (is_evpn_enabled())
8915                                 vty_out(vty, "  advertise-all-vni\n");
8916                 }
8917
8918                 if (filter->plist[FILTER_IN].name
8919                     || filter->dlist[FILTER_IN].name
8920                     || filter->aslist[FILTER_IN].name
8921                     || filter->map[RMAP_IN].name)
8922                         vty_out(vty, "  Inbound path policy configured\n");
8923                 if (filter->plist[FILTER_OUT].name
8924                     || filter->dlist[FILTER_OUT].name
8925                     || filter->aslist[FILTER_OUT].name
8926                     || filter->map[RMAP_OUT].name || filter->usmap.name)
8927                         vty_out(vty, "  Outbound path policy configured\n");
8928
8929                 /* prefix-list */
8930                 if (filter->plist[FILTER_IN].name)
8931                         vty_out(vty,
8932                                 "  Incoming update prefix filter list is %s%s\n",
8933                                 filter->plist[FILTER_IN].plist ? "*" : "",
8934                                 filter->plist[FILTER_IN].name);
8935                 if (filter->plist[FILTER_OUT].name)
8936                         vty_out(vty,
8937                                 "  Outgoing update prefix filter list is %s%s\n",
8938                                 filter->plist[FILTER_OUT].plist ? "*" : "",
8939                                 filter->plist[FILTER_OUT].name);
8940
8941                 /* distribute-list */
8942                 if (filter->dlist[FILTER_IN].name)
8943                         vty_out(vty,
8944                                 "  Incoming update network filter list is %s%s\n",
8945                                 filter->dlist[FILTER_IN].alist ? "*" : "",
8946                                 filter->dlist[FILTER_IN].name);
8947                 if (filter->dlist[FILTER_OUT].name)
8948                         vty_out(vty,
8949                                 "  Outgoing update network filter list is %s%s\n",
8950                                 filter->dlist[FILTER_OUT].alist ? "*" : "",
8951                                 filter->dlist[FILTER_OUT].name);
8952
8953                 /* filter-list. */
8954                 if (filter->aslist[FILTER_IN].name)
8955                         vty_out(vty,
8956                                 "  Incoming update AS path filter list is %s%s\n",
8957                                 filter->aslist[FILTER_IN].aslist ? "*" : "",
8958                                 filter->aslist[FILTER_IN].name);
8959                 if (filter->aslist[FILTER_OUT].name)
8960                         vty_out(vty,
8961                                 "  Outgoing update AS path filter list is %s%s\n",
8962                                 filter->aslist[FILTER_OUT].aslist ? "*" : "",
8963                                 filter->aslist[FILTER_OUT].name);
8964
8965                 /* route-map. */
8966                 if (filter->map[RMAP_IN].name)
8967                         vty_out(vty,
8968                                 "  Route map for incoming advertisements is %s%s\n",
8969                                 filter->map[RMAP_IN].map ? "*" : "",
8970                                 filter->map[RMAP_IN].name);
8971                 if (filter->map[RMAP_OUT].name)
8972                         vty_out(vty,
8973                                 "  Route map for outgoing advertisements is %s%s\n",
8974                                 filter->map[RMAP_OUT].map ? "*" : "",
8975                                 filter->map[RMAP_OUT].name);
8976
8977                 /* unsuppress-map */
8978                 if (filter->usmap.name)
8979                         vty_out(vty,
8980                                 "  Route map for selective unsuppress is %s%s\n",
8981                                 filter->usmap.map ? "*" : "",
8982                                 filter->usmap.name);
8983
8984                 /* Receive prefix count */
8985                 vty_out(vty, "  %ld accepted prefixes\n", p->pcount[afi][safi]);
8986
8987                 /* Maximum prefix */
8988                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
8989                         vty_out(vty, "  Maximum prefixes allowed %ld%s\n",
8990                                 p->pmax[afi][safi],
8991                                 CHECK_FLAG(p->af_flags[afi][safi],
8992                                            PEER_FLAG_MAX_PREFIX_WARNING)
8993                                         ? " (warning-only)"
8994                                         : "");
8995                         vty_out(vty, "  Threshold for warning message %d%%",
8996                                 p->pmax_threshold[afi][safi]);
8997                         if (p->pmax_restart[afi][safi])
8998                                 vty_out(vty, ", restart interval %d min",
8999                                         p->pmax_restart[afi][safi]);
9000                         vty_out(vty, "\n");
9001                 }
9002
9003                 vty_out(vty, "\n");
9004         }
9005 }
9006
9007 static void bgp_show_peer(struct vty *vty, struct peer *p, bool use_json,
9008                           json_object *json)
9009 {
9010         struct bgp *bgp;
9011         char buf1[PREFIX2STR_BUFFER], buf[SU_ADDRSTRLEN];
9012         char timebuf[BGP_UPTIME_LEN];
9013         char dn_flag[2];
9014         const char *subcode_str;
9015         const char *code_str;
9016         afi_t afi;
9017         safi_t safi;
9018         uint16_t i;
9019         uint8_t *msg;
9020         json_object *json_neigh = NULL;
9021         time_t epoch_tbuf;
9022
9023         bgp = p->bgp;
9024
9025         if (use_json)
9026                 json_neigh = json_object_new_object();
9027
9028         memset(dn_flag, '\0', sizeof(dn_flag));
9029         if (!p->conf_if && peer_dynamic_neighbor(p))
9030                 dn_flag[0] = '*';
9031
9032         if (!use_json) {
9033                 if (p->conf_if) /* Configured interface name. */
9034                         vty_out(vty, "BGP neighbor on %s: %s, ", p->conf_if,
9035                                 BGP_PEER_SU_UNSPEC(p)
9036                                         ? "None"
9037                                         : sockunion2str(&p->su, buf,
9038                                                         SU_ADDRSTRLEN));
9039                 else /* Configured IP address. */
9040                         vty_out(vty, "BGP neighbor is %s%s, ", dn_flag,
9041                                 p->host);
9042         }
9043
9044         if (use_json) {
9045                 if (p->conf_if && BGP_PEER_SU_UNSPEC(p))
9046                         json_object_string_add(json_neigh, "bgpNeighborAddr",
9047                                                "none");
9048                 else if (p->conf_if && !BGP_PEER_SU_UNSPEC(p))
9049                         json_object_string_add(
9050                                 json_neigh, "bgpNeighborAddr",
9051                                 sockunion2str(&p->su, buf, SU_ADDRSTRLEN));
9052
9053                 json_object_int_add(json_neigh, "remoteAs", p->as);
9054
9055                 if (p->change_local_as)
9056                         json_object_int_add(json_neigh, "localAs",
9057                                             p->change_local_as);
9058                 else
9059                         json_object_int_add(json_neigh, "localAs", p->local_as);
9060
9061                 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
9062                         json_object_boolean_true_add(json_neigh,
9063                                                      "localAsNoPrepend");
9064
9065                 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS))
9066                         json_object_boolean_true_add(json_neigh,
9067                                                      "localAsReplaceAs");
9068         } else {
9069                 if ((p->as_type == AS_SPECIFIED) || (p->as_type == AS_EXTERNAL)
9070                     || (p->as_type == AS_INTERNAL))
9071                         vty_out(vty, "remote AS %u, ", p->as);
9072                 else
9073                         vty_out(vty, "remote AS Unspecified, ");
9074                 vty_out(vty, "local AS %u%s%s, ",
9075                         p->change_local_as ? p->change_local_as : p->local_as,
9076                         CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND)
9077                                 ? " no-prepend"
9078                                 : "",
9079                         CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS)
9080                                 ? " replace-as"
9081                                 : "");
9082         }
9083         /* peer type internal, external, confed-internal or confed-external */
9084         if (p->as == p->local_as) {
9085                 if (use_json) {
9086                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9087                                 json_object_boolean_true_add(
9088                                         json_neigh, "nbrConfedInternalLink");
9089                         else
9090                                 json_object_boolean_true_add(json_neigh,
9091                                                              "nbrInternalLink");
9092                 } else {
9093                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9094                                 vty_out(vty, "confed-internal link\n");
9095                         else
9096                                 vty_out(vty, "internal link\n");
9097                 }
9098         } else {
9099                 if (use_json) {
9100                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9101                                 json_object_boolean_true_add(
9102                                         json_neigh, "nbrConfedExternalLink");
9103                         else
9104                                 json_object_boolean_true_add(json_neigh,
9105                                                              "nbrExternalLink");
9106                 } else {
9107                         if (bgp_confederation_peers_check(bgp, p->as))
9108                                 vty_out(vty, "confed-external link\n");
9109                         else
9110                                 vty_out(vty, "external link\n");
9111                 }
9112         }
9113
9114         /* Description. */
9115         if (p->desc) {
9116                 if (use_json)
9117                         json_object_string_add(json_neigh, "nbrDesc", p->desc);
9118                 else
9119                         vty_out(vty, " Description: %s\n", p->desc);
9120         }
9121
9122         if (p->hostname) {
9123                 if (use_json) {
9124                         if (p->hostname)
9125                                 json_object_string_add(json_neigh, "hostname",
9126                                                        p->hostname);
9127
9128                         if (p->domainname)
9129                                 json_object_string_add(json_neigh, "domainname",
9130                                                        p->domainname);
9131                 } else {
9132                         if (p->domainname && (p->domainname[0] != '\0'))
9133                                 vty_out(vty, "Hostname: %s.%s\n", p->hostname,
9134                                         p->domainname);
9135                         else
9136                                 vty_out(vty, "Hostname: %s\n", p->hostname);
9137                 }
9138         }
9139
9140         /* Peer-group */
9141         if (p->group) {
9142                 if (use_json) {
9143                         json_object_string_add(json_neigh, "peerGroup",
9144                                                p->group->name);
9145
9146                         if (dn_flag[0]) {
9147                                 struct prefix prefix, *range = NULL;
9148
9149                                 sockunion2hostprefix(&(p->su), &prefix);
9150                                 range = peer_group_lookup_dynamic_neighbor_range(
9151                                         p->group, &prefix);
9152
9153                                 if (range) {
9154                                         prefix2str(range, buf1, sizeof(buf1));
9155                                         json_object_string_add(
9156                                                 json_neigh,
9157                                                 "peerSubnetRangeGroup", buf1);
9158                                 }
9159                         }
9160                 } else {
9161                         vty_out(vty,
9162                                 " Member of peer-group %s for session parameters\n",
9163                                 p->group->name);
9164
9165                         if (dn_flag[0]) {
9166                                 struct prefix prefix, *range = NULL;
9167
9168                                 sockunion2hostprefix(&(p->su), &prefix);
9169                                 range = peer_group_lookup_dynamic_neighbor_range(
9170                                         p->group, &prefix);
9171
9172                                 if (range) {
9173                                         prefix2str(range, buf1, sizeof(buf1));
9174                                         vty_out(vty,
9175                                                 " Belongs to the subnet range group: %s\n",
9176                                                 buf1);
9177                                 }
9178                         }
9179                 }
9180         }
9181
9182         if (use_json) {
9183                 /* Administrative shutdown. */
9184                 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN))
9185                         json_object_boolean_true_add(json_neigh,
9186                                                      "adminShutDown");
9187
9188                 /* BGP Version. */
9189                 json_object_int_add(json_neigh, "bgpVersion", 4);
9190                 json_object_string_add(
9191                         json_neigh, "remoteRouterId",
9192                         inet_ntop(AF_INET, &p->remote_id, buf1, sizeof(buf1)));
9193                 json_object_string_add(
9194                         json_neigh, "localRouterId",
9195                         inet_ntop(AF_INET, &bgp->router_id, buf1,
9196                                         sizeof(buf1)));
9197
9198                 /* Confederation */
9199                 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
9200                     && bgp_confederation_peers_check(bgp, p->as))
9201                         json_object_boolean_true_add(json_neigh,
9202                                                      "nbrCommonAdmin");
9203
9204                 /* Status. */
9205                 json_object_string_add(
9206                         json_neigh, "bgpState",
9207                         lookup_msg(bgp_status_msg, p->status, NULL));
9208
9209                 if (p->status == Established) {
9210                         time_t uptime;
9211
9212                         uptime = bgp_clock();
9213                         uptime -= p->uptime;
9214                         epoch_tbuf = time(NULL) - uptime;
9215
9216 #if CONFDATE > 20200101
9217                         CPP_NOTICE(
9218                                 "bgpTimerUp should be deprecated and can be removed now");
9219 #endif
9220                         /*
9221                          * bgpTimerUp was miliseconds that was accurate
9222                          * up to 1 day, then the value returned
9223                          * became garbage.  So in order to provide
9224                          * some level of backwards compatability,
9225                          * we still provde the data, but now
9226                          * we are returning the correct value
9227                          * and also adding a new bgpTimerUpMsec
9228                          * which will allow us to deprecate
9229                          * this eventually
9230                          */
9231                         json_object_int_add(json_neigh, "bgpTimerUp",
9232                                             uptime * 1000);
9233                         json_object_int_add(json_neigh, "bgpTimerUpMsec",
9234                                             uptime * 1000);
9235                         json_object_string_add(json_neigh, "bgpTimerUpString",
9236                                                peer_uptime(p->uptime, timebuf,
9237                                                            BGP_UPTIME_LEN, 0,
9238                                                            NULL));
9239                         json_object_int_add(json_neigh,
9240                                             "bgpTimerUpEstablishedEpoch",
9241                                             epoch_tbuf);
9242                 }
9243
9244                 else if (p->status == Active) {
9245                         if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
9246                                 json_object_string_add(json_neigh, "bgpStateIs",
9247                                                        "passive");
9248                         else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
9249                                 json_object_string_add(json_neigh, "bgpStateIs",
9250                                                        "passiveNSF");
9251                 }
9252
9253                 /* read timer */
9254                 time_t uptime;
9255                 struct tm *tm;
9256
9257                 uptime = bgp_clock();
9258                 uptime -= p->readtime;
9259                 tm = gmtime(&uptime);
9260                 json_object_int_add(json_neigh, "bgpTimerLastRead",
9261                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9262                                             + (tm->tm_hour * 3600000));
9263
9264                 uptime = bgp_clock();
9265                 uptime -= p->last_write;
9266                 tm = gmtime(&uptime);
9267                 json_object_int_add(json_neigh, "bgpTimerLastWrite",
9268                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9269                                             + (tm->tm_hour * 3600000));
9270
9271                 uptime = bgp_clock();
9272                 uptime -= p->update_time;
9273                 tm = gmtime(&uptime);
9274                 json_object_int_add(json_neigh, "bgpInUpdateElapsedTimeMsecs",
9275                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9276                                             + (tm->tm_hour * 3600000));
9277
9278                 /* Configured timer values. */
9279                 json_object_int_add(json_neigh, "bgpTimerHoldTimeMsecs",
9280                                     p->v_holdtime * 1000);
9281                 json_object_int_add(json_neigh,
9282                                     "bgpTimerKeepAliveIntervalMsecs",
9283                                     p->v_keepalive * 1000);
9284                 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER)) {
9285                         json_object_int_add(json_neigh,
9286                                             "bgpTimerConfiguredHoldTimeMsecs",
9287                                             p->holdtime * 1000);
9288                         json_object_int_add(
9289                                 json_neigh,
9290                                 "bgpTimerConfiguredKeepAliveIntervalMsecs",
9291                                 p->keepalive * 1000);
9292                 } else if ((bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
9293                            || (bgp->default_keepalive
9294                                != BGP_DEFAULT_KEEPALIVE)) {
9295                         json_object_int_add(json_neigh,
9296                                             "bgpTimerConfiguredHoldTimeMsecs",
9297                                             bgp->default_holdtime);
9298                         json_object_int_add(
9299                                 json_neigh,
9300                                 "bgpTimerConfiguredKeepAliveIntervalMsecs",
9301                                 bgp->default_keepalive);
9302                 }
9303         } else {
9304                 /* Administrative shutdown. */
9305                 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN))
9306                         vty_out(vty, " Administratively shut down\n");
9307
9308                 /* BGP Version. */
9309                 vty_out(vty, "  BGP version 4");
9310                 vty_out(vty, ", remote router ID %s",
9311                         inet_ntop(AF_INET, &p->remote_id, buf1, sizeof(buf1)));
9312                 vty_out(vty, ", local router ID %s\n",
9313                         inet_ntop(AF_INET, &bgp->router_id, buf1,
9314                                         sizeof(buf1)));
9315
9316                 /* Confederation */
9317                 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
9318                     && bgp_confederation_peers_check(bgp, p->as))
9319                         vty_out(vty,
9320                                 "  Neighbor under common administration\n");
9321
9322                 /* Status. */
9323                 vty_out(vty, "  BGP state = %s",
9324                         lookup_msg(bgp_status_msg, p->status, NULL));
9325
9326                 if (p->status == Established)
9327                         vty_out(vty, ", up for %8s",
9328                                 peer_uptime(p->uptime, timebuf, BGP_UPTIME_LEN,
9329                                             0, NULL));
9330
9331                 else if (p->status == Active) {
9332                         if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
9333                                 vty_out(vty, " (passive)");
9334                         else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
9335                                 vty_out(vty, " (NSF passive)");
9336                 }
9337                 vty_out(vty, "\n");
9338
9339                 /* read timer */
9340                 vty_out(vty, "  Last read %s",
9341                         peer_uptime(p->readtime, timebuf, BGP_UPTIME_LEN, 0,
9342                                     NULL));
9343                 vty_out(vty, ", Last write %s\n",
9344                         peer_uptime(p->last_write, timebuf, BGP_UPTIME_LEN, 0,
9345                                     NULL));
9346
9347                 /* Configured timer values. */
9348                 vty_out(vty,
9349                         "  Hold time is %d, keepalive interval is %d seconds\n",
9350                         p->v_holdtime, p->v_keepalive);
9351                 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER)) {
9352                         vty_out(vty, "  Configured hold time is %d",
9353                                 p->holdtime);
9354                         vty_out(vty, ", keepalive interval is %d seconds\n",
9355                                 p->keepalive);
9356                 } else if ((bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
9357                            || (bgp->default_keepalive
9358                                != BGP_DEFAULT_KEEPALIVE)) {
9359                         vty_out(vty, "  Configured hold time is %d",
9360                                 bgp->default_holdtime);
9361                         vty_out(vty, ", keepalive interval is %d seconds\n",
9362                                 bgp->default_keepalive);
9363                 }
9364         }
9365         /* Capability. */
9366         if (p->status == Established) {
9367                 if (p->cap || p->afc_adv[AFI_IP][SAFI_UNICAST]
9368                     || p->afc_recv[AFI_IP][SAFI_UNICAST]
9369                     || p->afc_adv[AFI_IP][SAFI_MULTICAST]
9370                     || p->afc_recv[AFI_IP][SAFI_MULTICAST]
9371                     || p->afc_adv[AFI_IP6][SAFI_UNICAST]
9372                     || p->afc_recv[AFI_IP6][SAFI_UNICAST]
9373                     || p->afc_adv[AFI_IP6][SAFI_MULTICAST]
9374                     || p->afc_recv[AFI_IP6][SAFI_MULTICAST]
9375                     || p->afc_adv[AFI_IP6][SAFI_MPLS_VPN]
9376                     || p->afc_recv[AFI_IP6][SAFI_MPLS_VPN]
9377                     || p->afc_adv[AFI_IP6][SAFI_ENCAP]
9378                     || p->afc_recv[AFI_IP6][SAFI_ENCAP]
9379                     || p->afc_adv[AFI_IP6][SAFI_FLOWSPEC]
9380                     || p->afc_recv[AFI_IP6][SAFI_FLOWSPEC]
9381                     || p->afc_adv[AFI_IP][SAFI_ENCAP]
9382                     || p->afc_recv[AFI_IP][SAFI_ENCAP]
9383                     || p->afc_adv[AFI_IP][SAFI_FLOWSPEC]
9384                     || p->afc_recv[AFI_IP][SAFI_FLOWSPEC]
9385                     || p->afc_adv[AFI_IP][SAFI_MPLS_VPN]
9386                     || p->afc_recv[AFI_IP][SAFI_MPLS_VPN]) {
9387                         if (use_json) {
9388                                 json_object *json_cap = NULL;
9389
9390                                 json_cap = json_object_new_object();
9391
9392                                 /* AS4 */
9393                                 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV)
9394                                     || CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
9395                                         if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)
9396                                             && CHECK_FLAG(p->cap,
9397                                                           PEER_CAP_AS4_RCV))
9398                                                 json_object_string_add(
9399                                                         json_cap, "4byteAs",
9400                                                         "advertisedAndReceived");
9401                                         else if (CHECK_FLAG(p->cap,
9402                                                             PEER_CAP_AS4_ADV))
9403                                                 json_object_string_add(
9404                                                         json_cap, "4byteAs",
9405                                                         "advertised");
9406                                         else if (CHECK_FLAG(p->cap,
9407                                                             PEER_CAP_AS4_RCV))
9408                                                 json_object_string_add(
9409                                                         json_cap, "4byteAs",
9410                                                         "received");
9411                                 }
9412
9413                                 /* AddPath */
9414                                 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV)
9415                                     || CHECK_FLAG(p->cap,
9416                                                   PEER_CAP_ADDPATH_ADV)) {
9417                                         json_object *json_add = NULL;
9418                                         const char *print_store;
9419
9420                                         json_add = json_object_new_object();
9421
9422                                         FOREACH_AFI_SAFI (afi, safi) {
9423                                                 json_object *json_sub = NULL;
9424                                                 json_sub =
9425                                                         json_object_new_object();
9426                                                 print_store = afi_safi_print(
9427                                                         afi, safi);
9428
9429                                                 if (CHECK_FLAG(
9430                                                             p->af_cap[afi]
9431                                                                      [safi],
9432                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9433                                                     || CHECK_FLAG(
9434                                                                p->af_cap[afi]
9435                                                                         [safi],
9436                                                                PEER_CAP_ADDPATH_AF_TX_RCV)) {
9437                                                         if (CHECK_FLAG(
9438                                                                     p->af_cap
9439                                                                             [afi]
9440                                                                             [safi],
9441                                                                     PEER_CAP_ADDPATH_AF_TX_ADV)
9442                                                             && CHECK_FLAG(
9443                                                                        p->af_cap
9444                                                                                [afi]
9445                                                                                [safi],
9446                                                                        PEER_CAP_ADDPATH_AF_TX_RCV))
9447                                                                 json_object_boolean_true_add(
9448                                                                         json_sub,
9449                                                                         "txAdvertisedAndReceived");
9450                                                         else if (
9451                                                                 CHECK_FLAG(
9452                                                                         p->af_cap
9453                                                                                 [afi]
9454                                                                                 [safi],
9455                                                                         PEER_CAP_ADDPATH_AF_TX_ADV))
9456                                                                 json_object_boolean_true_add(
9457                                                                         json_sub,
9458                                                                         "txAdvertised");
9459                                                         else if (
9460                                                                 CHECK_FLAG(
9461                                                                         p->af_cap
9462                                                                                 [afi]
9463                                                                                 [safi],
9464                                                                         PEER_CAP_ADDPATH_AF_TX_RCV))
9465                                                                 json_object_boolean_true_add(
9466                                                                         json_sub,
9467                                                                         "txReceived");
9468                                                 }
9469
9470                                                 if (CHECK_FLAG(
9471                                                             p->af_cap[afi]
9472                                                                      [safi],
9473                                                             PEER_CAP_ADDPATH_AF_RX_ADV)
9474                                                     || CHECK_FLAG(
9475                                                                p->af_cap[afi]
9476                                                                         [safi],
9477                                                                PEER_CAP_ADDPATH_AF_RX_RCV)) {
9478                                                         if (CHECK_FLAG(
9479                                                                     p->af_cap
9480                                                                             [afi]
9481                                                                             [safi],
9482                                                                     PEER_CAP_ADDPATH_AF_RX_ADV)
9483                                                             && CHECK_FLAG(
9484                                                                        p->af_cap
9485                                                                                [afi]
9486                                                                                [safi],
9487                                                                        PEER_CAP_ADDPATH_AF_RX_RCV))
9488                                                                 json_object_boolean_true_add(
9489                                                                         json_sub,
9490                                                                         "rxAdvertisedAndReceived");
9491                                                         else if (
9492                                                                 CHECK_FLAG(
9493                                                                         p->af_cap
9494                                                                                 [afi]
9495                                                                                 [safi],
9496                                                                         PEER_CAP_ADDPATH_AF_RX_ADV))
9497                                                                 json_object_boolean_true_add(
9498                                                                         json_sub,
9499                                                                         "rxAdvertised");
9500                                                         else if (
9501                                                                 CHECK_FLAG(
9502                                                                         p->af_cap
9503                                                                                 [afi]
9504                                                                                 [safi],
9505                                                                         PEER_CAP_ADDPATH_AF_RX_RCV))
9506                                                                 json_object_boolean_true_add(
9507                                                                         json_sub,
9508                                                                         "rxReceived");
9509                                                 }
9510
9511                                                 if (CHECK_FLAG(
9512                                                             p->af_cap[afi]
9513                                                                      [safi],
9514                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9515                                                     || CHECK_FLAG(
9516                                                                p->af_cap[afi]
9517                                                                         [safi],
9518                                                                PEER_CAP_ADDPATH_AF_TX_RCV)
9519                                                     || CHECK_FLAG(
9520                                                                p->af_cap[afi]
9521                                                                         [safi],
9522                                                                PEER_CAP_ADDPATH_AF_RX_ADV)
9523                                                     || CHECK_FLAG(
9524                                                                p->af_cap[afi]
9525                                                                         [safi],
9526                                                                PEER_CAP_ADDPATH_AF_RX_RCV))
9527                                                         json_object_object_add(
9528                                                                 json_add,
9529                                                                 print_store,
9530                                                                 json_sub);
9531                                                 else
9532                                                         json_object_free(
9533                                                                 json_sub);
9534                                         }
9535
9536                                         json_object_object_add(
9537                                                 json_cap, "addPath", json_add);
9538                                 }
9539
9540                                 /* Dynamic */
9541                                 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV)
9542                                     || CHECK_FLAG(p->cap,
9543                                                   PEER_CAP_DYNAMIC_ADV)) {
9544                                         if (CHECK_FLAG(p->cap,
9545                                                        PEER_CAP_DYNAMIC_ADV)
9546                                             && CHECK_FLAG(p->cap,
9547                                                           PEER_CAP_DYNAMIC_RCV))
9548                                                 json_object_string_add(
9549                                                         json_cap, "dynamic",
9550                                                         "advertisedAndReceived");
9551                                         else if (CHECK_FLAG(
9552                                                          p->cap,
9553                                                          PEER_CAP_DYNAMIC_ADV))
9554                                                 json_object_string_add(
9555                                                         json_cap, "dynamic",
9556                                                         "advertised");
9557                                         else if (CHECK_FLAG(
9558                                                          p->cap,
9559                                                          PEER_CAP_DYNAMIC_RCV))
9560                                                 json_object_string_add(
9561                                                         json_cap, "dynamic",
9562                                                         "received");
9563                                 }
9564
9565                                 /* Extended nexthop */
9566                                 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)
9567                                     || CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
9568                                         json_object *json_nxt = NULL;
9569                                         const char *print_store;
9570
9571
9572                                         if (CHECK_FLAG(p->cap,
9573                                                        PEER_CAP_ENHE_ADV)
9574                                             && CHECK_FLAG(p->cap,
9575                                                           PEER_CAP_ENHE_RCV))
9576                                                 json_object_string_add(
9577                                                         json_cap,
9578                                                         "extendedNexthop",
9579                                                         "advertisedAndReceived");
9580                                         else if (CHECK_FLAG(p->cap,
9581                                                             PEER_CAP_ENHE_ADV))
9582                                                 json_object_string_add(
9583                                                         json_cap,
9584                                                         "extendedNexthop",
9585                                                         "advertised");
9586                                         else if (CHECK_FLAG(p->cap,
9587                                                             PEER_CAP_ENHE_RCV))
9588                                                 json_object_string_add(
9589                                                         json_cap,
9590                                                         "extendedNexthop",
9591                                                         "received");
9592
9593                                         if (CHECK_FLAG(p->cap,
9594                                                        PEER_CAP_ENHE_RCV)) {
9595                                                 json_nxt =
9596                                                         json_object_new_object();
9597
9598                                                 for (safi = SAFI_UNICAST;
9599                                                      safi < SAFI_MAX; safi++) {
9600                                                         if (CHECK_FLAG(
9601                                                                     p->af_cap
9602                                                                             [AFI_IP]
9603                                                                             [safi],
9604                                                                     PEER_CAP_ENHE_AF_RCV)) {
9605                                                                 print_store = afi_safi_print(
9606                                                                         AFI_IP,
9607                                                                         safi);
9608                                                                 json_object_string_add(
9609                                                                         json_nxt,
9610                                                                         print_store,
9611                                                                         "recieved");
9612                                                         }
9613                                                 }
9614                                                 json_object_object_add(
9615                                                         json_cap,
9616                                                         "extendedNexthopFamililesByPeer",
9617                                                         json_nxt);
9618                                         }
9619                                 }
9620
9621                                 /* Route Refresh */
9622                                 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV)
9623                                     || CHECK_FLAG(p->cap,
9624                                                   PEER_CAP_REFRESH_NEW_RCV)
9625                                     || CHECK_FLAG(p->cap,
9626                                                   PEER_CAP_REFRESH_OLD_RCV)) {
9627                                         if (CHECK_FLAG(p->cap,
9628                                                        PEER_CAP_REFRESH_ADV)
9629                                             && (CHECK_FLAG(
9630                                                         p->cap,
9631                                                         PEER_CAP_REFRESH_NEW_RCV)
9632                                                 || CHECK_FLAG(
9633                                                            p->cap,
9634                                                            PEER_CAP_REFRESH_OLD_RCV))) {
9635                                                 if (CHECK_FLAG(
9636                                                             p->cap,
9637                                                             PEER_CAP_REFRESH_OLD_RCV)
9638                                                     && CHECK_FLAG(
9639                                                                p->cap,
9640                                                                PEER_CAP_REFRESH_NEW_RCV))
9641                                                         json_object_string_add(
9642                                                                 json_cap,
9643                                                                 "routeRefresh",
9644                                                                 "advertisedAndReceivedOldNew");
9645                                                 else {
9646                                                         if (CHECK_FLAG(
9647                                                                     p->cap,
9648                                                                     PEER_CAP_REFRESH_OLD_RCV))
9649                                                                 json_object_string_add(
9650                                                                         json_cap,
9651                                                                         "routeRefresh",
9652                                                                         "advertisedAndReceivedOld");
9653                                                         else
9654                                                                 json_object_string_add(
9655                                                                         json_cap,
9656                                                                         "routeRefresh",
9657                                                                         "advertisedAndReceivedNew");
9658                                                 }
9659                                         } else if (
9660                                                 CHECK_FLAG(
9661                                                         p->cap,
9662                                                         PEER_CAP_REFRESH_ADV))
9663                                                 json_object_string_add(
9664                                                         json_cap,
9665                                                         "routeRefresh",
9666                                                         "advertised");
9667                                         else if (
9668                                                 CHECK_FLAG(
9669                                                         p->cap,
9670                                                         PEER_CAP_REFRESH_NEW_RCV)
9671                                                 || CHECK_FLAG(
9672                                                            p->cap,
9673                                                            PEER_CAP_REFRESH_OLD_RCV))
9674                                                 json_object_string_add(
9675                                                         json_cap,
9676                                                         "routeRefresh",
9677                                                         "received");
9678                                 }
9679
9680                                 /* Multiprotocol Extensions */
9681                                 json_object *json_multi = NULL;
9682                                 json_multi = json_object_new_object();
9683
9684                                 FOREACH_AFI_SAFI (afi, safi) {
9685                                         if (p->afc_adv[afi][safi]
9686                                             || p->afc_recv[afi][safi]) {
9687                                                 json_object *json_exten = NULL;
9688                                                 json_exten =
9689                                                         json_object_new_object();
9690
9691                                                 if (p->afc_adv[afi][safi]
9692                                                     && p->afc_recv[afi][safi])
9693                                                         json_object_boolean_true_add(
9694                                                                 json_exten,
9695                                                                 "advertisedAndReceived");
9696                                                 else if (p->afc_adv[afi][safi])
9697                                                         json_object_boolean_true_add(
9698                                                                 json_exten,
9699                                                                 "advertised");
9700                                                 else if (p->afc_recv[afi][safi])
9701                                                         json_object_boolean_true_add(
9702                                                                 json_exten,
9703                                                                 "received");
9704
9705                                                 json_object_object_add(
9706                                                         json_multi,
9707                                                         afi_safi_print(afi,
9708                                                                        safi),
9709                                                         json_exten);
9710                                         }
9711                                 }
9712                                 json_object_object_add(
9713                                         json_cap, "multiprotocolExtensions",
9714                                         json_multi);
9715
9716                                 /* Hostname capabilities */
9717                                 json_object *json_hname = NULL;
9718
9719                                 json_hname = json_object_new_object();
9720
9721                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
9722                                         json_object_string_add(
9723                                                 json_hname, "advHostName",
9724                                                 bgp->peer_self->hostname
9725                                                         ? bgp->peer_self
9726                                                                   ->hostname
9727                                                         : "n/a");
9728                                         json_object_string_add(
9729                                                 json_hname, "advDomainName",
9730                                                 bgp->peer_self->domainname
9731                                                         ? bgp->peer_self
9732                                                                   ->domainname
9733                                                         : "n/a");
9734                                 }
9735
9736
9737                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
9738                                         json_object_string_add(
9739                                                 json_hname, "rcvHostName",
9740                                                 p->hostname ? p->hostname
9741                                                             : "n/a");
9742                                         json_object_string_add(
9743                                                 json_hname, "rcvDomainName",
9744                                                 p->domainname ? p->domainname
9745                                                               : "n/a");
9746                                 }
9747
9748                                 json_object_object_add(json_cap, "hostName",
9749                                                        json_hname);
9750
9751                                 /* Gracefull Restart */
9752                                 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)
9753                                     || CHECK_FLAG(p->cap,
9754                                                   PEER_CAP_RESTART_ADV)) {
9755                                         if (CHECK_FLAG(p->cap,
9756                                                        PEER_CAP_RESTART_ADV)
9757                                             && CHECK_FLAG(p->cap,
9758                                                           PEER_CAP_RESTART_RCV))
9759                                                 json_object_string_add(
9760                                                         json_cap,
9761                                                         "gracefulRestart",
9762                                                         "advertisedAndReceived");
9763                                         else if (CHECK_FLAG(
9764                                                          p->cap,
9765                                                          PEER_CAP_RESTART_ADV))
9766                                                 json_object_string_add(
9767                                                         json_cap,
9768                                                         "gracefulRestartCapability",
9769                                                         "advertised");
9770                                         else if (CHECK_FLAG(
9771                                                          p->cap,
9772                                                          PEER_CAP_RESTART_RCV))
9773                                                 json_object_string_add(
9774                                                         json_cap,
9775                                                         "gracefulRestartCapability",
9776                                                         "received");
9777
9778                                         if (CHECK_FLAG(p->cap,
9779                                                        PEER_CAP_RESTART_RCV)) {
9780                                                 int restart_af_count = 0;
9781                                                 json_object *json_restart =
9782                                                         NULL;
9783                                                 json_restart =
9784                                                         json_object_new_object();
9785
9786                                                 json_object_int_add(
9787                                                         json_cap,
9788                                                         "gracefulRestartRemoteTimerMsecs",
9789                                                         p->v_gr_restart * 1000);
9790
9791                                                 FOREACH_AFI_SAFI (afi, safi) {
9792                                                         if (CHECK_FLAG(
9793                                                                     p->af_cap
9794                                                                             [afi]
9795                                                                             [safi],
9796                                                                     PEER_CAP_RESTART_AF_RCV)) {
9797                                                                 json_object *
9798                                                                         json_sub =
9799                                                                                 NULL;
9800                                                                 json_sub =
9801                                                                         json_object_new_object();
9802
9803                                                                 if (CHECK_FLAG(
9804                                                                             p->af_cap
9805                                                                                     [afi]
9806                                                                                     [safi],
9807                                                                             PEER_CAP_RESTART_AF_PRESERVE_RCV))
9808                                                                         json_object_boolean_true_add(
9809                                                                                 json_sub,
9810                                                                                 "preserved");
9811                                                                 restart_af_count++;
9812                                                                 json_object_object_add(
9813                                                                         json_restart,
9814                                                                         afi_safi_print(
9815                                                                                 afi,
9816                                                                                 safi),
9817                                                                         json_sub);
9818                                                         }
9819                                                 }
9820                                                 if (!restart_af_count) {
9821                                                         json_object_string_add(
9822                                                                 json_cap,
9823                                                                 "addressFamiliesByPeer",
9824                                                                 "none");
9825                                                         json_object_free(
9826                                                                 json_restart);
9827                                                 } else
9828                                                         json_object_object_add(
9829                                                                 json_cap,
9830                                                                 "addressFamiliesByPeer",
9831                                                                 json_restart);
9832                                         }
9833                                 }
9834                                 json_object_object_add(json_neigh,
9835                                                        "neighborCapabilities",
9836                                                        json_cap);
9837                         } else {
9838                                 vty_out(vty, "  Neighbor capabilities:\n");
9839
9840                                 /* AS4 */
9841                                 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV)
9842                                     || CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
9843                                         vty_out(vty, "    4 Byte AS:");
9844                                         if (CHECK_FLAG(p->cap,
9845                                                        PEER_CAP_AS4_ADV))
9846                                                 vty_out(vty, " advertised");
9847                                         if (CHECK_FLAG(p->cap,
9848                                                        PEER_CAP_AS4_RCV))
9849                                                 vty_out(vty, " %sreceived",
9850                                                         CHECK_FLAG(
9851                                                                 p->cap,
9852                                                                 PEER_CAP_AS4_ADV)
9853                                                                 ? "and "
9854                                                                 : "");
9855                                         vty_out(vty, "\n");
9856                                 }
9857
9858                                 /* AddPath */
9859                                 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV)
9860                                     || CHECK_FLAG(p->cap,
9861                                                   PEER_CAP_ADDPATH_ADV)) {
9862                                         vty_out(vty, "    AddPath:\n");
9863
9864                                         FOREACH_AFI_SAFI (afi, safi) {
9865                                                 if (CHECK_FLAG(
9866                                                             p->af_cap[afi]
9867                                                                      [safi],
9868                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9869                                                     || CHECK_FLAG(
9870                                                                p->af_cap[afi]
9871                                                                         [safi],
9872                                                                PEER_CAP_ADDPATH_AF_TX_RCV)) {
9873                                                         vty_out(vty,
9874                                                                 "      %s: TX ",
9875                                                                 afi_safi_print(
9876                                                                         afi,
9877                                                                         safi));
9878
9879                                                         if (CHECK_FLAG(
9880                                                                     p->af_cap
9881                                                                             [afi]
9882                                                                             [safi],
9883                                                                     PEER_CAP_ADDPATH_AF_TX_ADV))
9884                                                                 vty_out(vty,
9885                                                                         "advertised %s",
9886                                                                         afi_safi_print(
9887                                                                                 afi,
9888                                                                                 safi));
9889
9890                                                         if (CHECK_FLAG(
9891                                                                     p->af_cap
9892                                                                             [afi]
9893                                                                             [safi],
9894                                                                     PEER_CAP_ADDPATH_AF_TX_RCV))
9895                                                                 vty_out(vty,
9896                                                                         "%sreceived",
9897                                                                         CHECK_FLAG(
9898                                                                                 p->af_cap
9899                                                                                         [afi]
9900                                                                                         [safi],
9901                                                                                 PEER_CAP_ADDPATH_AF_TX_ADV)
9902                                                                                 ? " and "
9903                                                                                 : "");
9904
9905                                                         vty_out(vty, "\n");
9906                                                 }
9907
9908                                                 if (CHECK_FLAG(
9909                                                             p->af_cap[afi]
9910                                                                      [safi],
9911                                                             PEER_CAP_ADDPATH_AF_RX_ADV)
9912                                                     || CHECK_FLAG(
9913                                                                p->af_cap[afi]
9914                                                                         [safi],
9915                                                                PEER_CAP_ADDPATH_AF_RX_RCV)) {
9916                                                         vty_out(vty,
9917                                                                 "      %s: RX ",
9918                                                                 afi_safi_print(
9919                                                                         afi,
9920                                                                         safi));
9921
9922                                                         if (CHECK_FLAG(
9923                                                                     p->af_cap
9924                                                                             [afi]
9925                                                                             [safi],
9926                                                                     PEER_CAP_ADDPATH_AF_RX_ADV))
9927                                                                 vty_out(vty,
9928                                                                         "advertised %s",
9929                                                                         afi_safi_print(
9930                                                                                 afi,
9931                                                                                 safi));
9932
9933                                                         if (CHECK_FLAG(
9934                                                                     p->af_cap
9935                                                                             [afi]
9936                                                                             [safi],
9937                                                                     PEER_CAP_ADDPATH_AF_RX_RCV))
9938                                                                 vty_out(vty,
9939                                                                         "%sreceived",
9940                                                                         CHECK_FLAG(
9941                                                                                 p->af_cap
9942                                                                                         [afi]
9943                                                                                         [safi],
9944                                                                                 PEER_CAP_ADDPATH_AF_RX_ADV)
9945                                                                                 ? " and "
9946                                                                                 : "");
9947
9948                                                         vty_out(vty, "\n");
9949                                                 }
9950                                         }
9951                                 }
9952
9953                                 /* Dynamic */
9954                                 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV)
9955                                     || CHECK_FLAG(p->cap,
9956                                                   PEER_CAP_DYNAMIC_ADV)) {
9957                                         vty_out(vty, "    Dynamic:");
9958                                         if (CHECK_FLAG(p->cap,
9959                                                        PEER_CAP_DYNAMIC_ADV))
9960                                                 vty_out(vty, " advertised");
9961                                         if (CHECK_FLAG(p->cap,
9962                                                        PEER_CAP_DYNAMIC_RCV))
9963                                                 vty_out(vty, " %sreceived",
9964                                                         CHECK_FLAG(
9965                                                                 p->cap,
9966                                                                 PEER_CAP_DYNAMIC_ADV)
9967                                                                 ? "and "
9968                                                                 : "");
9969                                         vty_out(vty, "\n");
9970                                 }
9971
9972                                 /* Extended nexthop */
9973                                 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)
9974                                     || CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
9975                                         vty_out(vty, "    Extended nexthop:");
9976                                         if (CHECK_FLAG(p->cap,
9977                                                        PEER_CAP_ENHE_ADV))
9978                                                 vty_out(vty, " advertised");
9979                                         if (CHECK_FLAG(p->cap,
9980                                                        PEER_CAP_ENHE_RCV))
9981                                                 vty_out(vty, " %sreceived",
9982                                                         CHECK_FLAG(
9983                                                                 p->cap,
9984                                                                 PEER_CAP_ENHE_ADV)
9985                                                                 ? "and "
9986                                                                 : "");
9987                                         vty_out(vty, "\n");
9988
9989                                         if (CHECK_FLAG(p->cap,
9990                                                        PEER_CAP_ENHE_RCV)) {
9991                                                 vty_out(vty,
9992                                                         "      Address families by peer:\n        ");
9993                                                 for (safi = SAFI_UNICAST;
9994                                                      safi < SAFI_MAX; safi++)
9995                                                         if (CHECK_FLAG(
9996                                                                     p->af_cap
9997                                                                             [AFI_IP]
9998                                                                             [safi],
9999                                                                     PEER_CAP_ENHE_AF_RCV))
10000                                                                 vty_out(vty,
10001                                                                         "           %s\n",
10002                                                                         afi_safi_print(
10003                                                                                 AFI_IP,
10004                                                                                 safi));
10005                                         }
10006                                 }
10007
10008                                 /* Route Refresh */
10009                                 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV)
10010                                     || CHECK_FLAG(p->cap,
10011                                                   PEER_CAP_REFRESH_NEW_RCV)
10012                                     || CHECK_FLAG(p->cap,
10013                                                   PEER_CAP_REFRESH_OLD_RCV)) {
10014                                         vty_out(vty, "    Route refresh:");
10015                                         if (CHECK_FLAG(p->cap,
10016                                                        PEER_CAP_REFRESH_ADV))
10017                                                 vty_out(vty, " advertised");
10018                                         if (CHECK_FLAG(p->cap,
10019                                                        PEER_CAP_REFRESH_NEW_RCV)
10020                                             || CHECK_FLAG(
10021                                                        p->cap,
10022                                                        PEER_CAP_REFRESH_OLD_RCV))
10023                                                 vty_out(vty, " %sreceived(%s)",
10024                                                         CHECK_FLAG(
10025                                                                 p->cap,
10026                                                                 PEER_CAP_REFRESH_ADV)
10027                                                                 ? "and "
10028                                                                 : "",
10029                                                         (CHECK_FLAG(
10030                                                                  p->cap,
10031                                                                  PEER_CAP_REFRESH_OLD_RCV)
10032                                                          && CHECK_FLAG(
10033                                                                     p->cap,
10034                                                                     PEER_CAP_REFRESH_NEW_RCV))
10035                                                                 ? "old & new"
10036                                                                 : CHECK_FLAG(
10037                                                                           p->cap,
10038                                                                           PEER_CAP_REFRESH_OLD_RCV)
10039                                                                           ? "old"
10040                                                                           : "new");
10041
10042                                         vty_out(vty, "\n");
10043                                 }
10044
10045                                 /* Multiprotocol Extensions */
10046                                 FOREACH_AFI_SAFI (afi, safi)
10047                                         if (p->afc_adv[afi][safi]
10048                                             || p->afc_recv[afi][safi]) {
10049                                                 vty_out(vty,
10050                                                         "    Address Family %s:",
10051                                                         afi_safi_print(afi,
10052                                                                        safi));
10053                                                 if (p->afc_adv[afi][safi])
10054                                                         vty_out(vty,
10055                                                                 " advertised");
10056                                                 if (p->afc_recv[afi][safi])
10057                                                         vty_out(vty,
10058                                                                 " %sreceived",
10059                                                                 p->afc_adv[afi]
10060                                                                           [safi]
10061                                                                         ? "and "
10062                                                                         : "");
10063                                                 vty_out(vty, "\n");
10064                                         }
10065
10066                                 /* Hostname capability */
10067                                 vty_out(vty, "    Hostname Capability:");
10068
10069                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
10070                                         vty_out(vty,
10071                                                 " advertised (name: %s,domain name: %s)",
10072                                                 bgp->peer_self->hostname
10073                                                         ? bgp->peer_self
10074                                                                   ->hostname
10075                                                         : "n/a",
10076                                                 bgp->peer_self->domainname
10077                                                         ? bgp->peer_self
10078                                                                   ->domainname
10079                                                         : "n/a");
10080                                 } else {
10081                                         vty_out(vty, " not advertised");
10082                                 }
10083
10084                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
10085                                         vty_out(vty,
10086                                                 " received (name: %s,domain name: %s)",
10087                                                 p->hostname ? p->hostname
10088                                                             : "n/a",
10089                                                 p->domainname ? p->domainname
10090                                                               : "n/a");
10091                                 } else {
10092                                         vty_out(vty, " not received");
10093                                 }
10094
10095                                 vty_out(vty, "\n");
10096
10097                                 /* Gracefull Restart */
10098                                 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)
10099                                     || CHECK_FLAG(p->cap,
10100                                                   PEER_CAP_RESTART_ADV)) {
10101                                         vty_out(vty,
10102                                                 "    Graceful Restart Capabilty:");
10103                                         if (CHECK_FLAG(p->cap,
10104                                                        PEER_CAP_RESTART_ADV))
10105                                                 vty_out(vty, " advertised");
10106                                         if (CHECK_FLAG(p->cap,
10107                                                        PEER_CAP_RESTART_RCV))
10108                                                 vty_out(vty, " %sreceived",
10109                                                         CHECK_FLAG(
10110                                                                 p->cap,
10111                                                                 PEER_CAP_RESTART_ADV)
10112                                                                 ? "and "
10113                                                                 : "");
10114                                         vty_out(vty, "\n");
10115
10116                                         if (CHECK_FLAG(p->cap,
10117                                                        PEER_CAP_RESTART_RCV)) {
10118                                                 int restart_af_count = 0;
10119
10120                                                 vty_out(vty,
10121                                                         "      Remote Restart timer is %d seconds\n",
10122                                                         p->v_gr_restart);
10123                                                 vty_out(vty,
10124                                                         "      Address families by peer:\n        ");
10125
10126                                                 FOREACH_AFI_SAFI (afi, safi)
10127                                                         if (CHECK_FLAG(
10128                                                                     p->af_cap
10129                                                                             [afi]
10130                                                                             [safi],
10131                                                                     PEER_CAP_RESTART_AF_RCV)) {
10132                                                                 vty_out(vty,
10133                                                                         "%s%s(%s)",
10134                                                                         restart_af_count
10135                                                                                 ? ", "
10136                                                                                 : "",
10137                                                                         afi_safi_print(
10138                                                                                 afi,
10139                                                                                 safi),
10140                                                                         CHECK_FLAG(
10141                                                                                 p->af_cap
10142                                                                                         [afi]
10143                                                                                         [safi],
10144                                                                                 PEER_CAP_RESTART_AF_PRESERVE_RCV)
10145                                                                                 ? "preserved"
10146                                                                                 : "not preserved");
10147                                                                 restart_af_count++;
10148                                                         }
10149                                                 if (!restart_af_count)
10150                                                         vty_out(vty, "none");
10151                                                 vty_out(vty, "\n");
10152                                         }
10153                                 }
10154                         }
10155                 }
10156         }
10157
10158         /* graceful restart information */
10159         if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) || p->t_gr_restart
10160             || p->t_gr_stale) {
10161                 json_object *json_grace = NULL;
10162                 json_object *json_grace_send = NULL;
10163                 json_object *json_grace_recv = NULL;
10164                 int eor_send_af_count = 0;
10165                 int eor_receive_af_count = 0;
10166
10167                 if (use_json) {
10168                         json_grace = json_object_new_object();
10169                         json_grace_send = json_object_new_object();
10170                         json_grace_recv = json_object_new_object();
10171
10172                         if (p->status == Established) {
10173                                 FOREACH_AFI_SAFI (afi, safi) {
10174                                         if (CHECK_FLAG(p->af_sflags[afi][safi],
10175                                                        PEER_STATUS_EOR_SEND)) {
10176                                                 json_object_boolean_true_add(
10177                                                         json_grace_send,
10178                                                         afi_safi_print(afi,
10179                                                                        safi));
10180                                                 eor_send_af_count++;
10181                                         }
10182                                 }
10183                                 FOREACH_AFI_SAFI (afi, safi) {
10184                                         if (CHECK_FLAG(
10185                                                     p->af_sflags[afi][safi],
10186                                                     PEER_STATUS_EOR_RECEIVED)) {
10187                                                 json_object_boolean_true_add(
10188                                                         json_grace_recv,
10189                                                         afi_safi_print(afi,
10190                                                                        safi));
10191                                                 eor_receive_af_count++;
10192                                         }
10193                                 }
10194                         }
10195
10196                         json_object_object_add(json_grace, "endOfRibSend",
10197                                                json_grace_send);
10198                         json_object_object_add(json_grace, "endOfRibRecv",
10199                                                json_grace_recv);
10200
10201                         if (p->t_gr_restart)
10202                                 json_object_int_add(json_grace,
10203                                                     "gracefulRestartTimerMsecs",
10204                                                     thread_timer_remain_second(
10205                                                             p->t_gr_restart)
10206                                                             * 1000);
10207
10208                         if (p->t_gr_stale)
10209                                 json_object_int_add(
10210                                         json_grace,
10211                                         "gracefulStalepathTimerMsecs",
10212                                         thread_timer_remain_second(
10213                                                 p->t_gr_stale)
10214                                                 * 1000);
10215
10216                         json_object_object_add(
10217                                 json_neigh, "gracefulRestartInfo", json_grace);
10218                 } else {
10219                         vty_out(vty, "  Graceful restart informations:\n");
10220                         if (p->status == Established) {
10221                                 vty_out(vty, "    End-of-RIB send: ");
10222                                 FOREACH_AFI_SAFI (afi, safi) {
10223                                         if (CHECK_FLAG(p->af_sflags[afi][safi],
10224                                                        PEER_STATUS_EOR_SEND)) {
10225                                                 vty_out(vty, "%s%s",
10226                                                         eor_send_af_count ? ", "
10227                                                                           : "",
10228                                                         afi_safi_print(afi,
10229                                                                        safi));
10230                                                 eor_send_af_count++;
10231                                         }
10232                                 }
10233                                 vty_out(vty, "\n");
10234                                 vty_out(vty, "    End-of-RIB received: ");
10235                                 FOREACH_AFI_SAFI (afi, safi) {
10236                                         if (CHECK_FLAG(
10237                                                     p->af_sflags[afi][safi],
10238                                                     PEER_STATUS_EOR_RECEIVED)) {
10239                                                 vty_out(vty, "%s%s",
10240                                                         eor_receive_af_count
10241                                                                 ? ", "
10242                                                                 : "",
10243                                                         afi_safi_print(afi,
10244                                                                        safi));
10245                                                 eor_receive_af_count++;
10246                                         }
10247                                 }
10248                                 vty_out(vty, "\n");
10249                         }
10250
10251                         if (p->t_gr_restart)
10252                                 vty_out(vty,
10253                                         "    The remaining time of restart timer is %ld\n",
10254                                         thread_timer_remain_second(
10255                                                 p->t_gr_restart));
10256
10257                         if (p->t_gr_stale)
10258                                 vty_out(vty,
10259                                         "    The remaining time of stalepath timer is %ld\n",
10260                                         thread_timer_remain_second(
10261                                                 p->t_gr_stale));
10262                 }
10263         }
10264         if (use_json) {
10265                 json_object *json_stat = NULL;
10266                 json_stat = json_object_new_object();
10267                 /* Packet counts. */
10268                 json_object_int_add(json_stat, "depthInq", 0);
10269                 json_object_int_add(json_stat, "depthOutq",
10270                                     (unsigned long)p->obuf->count);
10271                 json_object_int_add(json_stat, "opensSent",
10272                                     atomic_load_explicit(&p->open_out,
10273                                                          memory_order_relaxed));
10274                 json_object_int_add(json_stat, "opensRecv",
10275                                     atomic_load_explicit(&p->open_in,
10276                                                          memory_order_relaxed));
10277                 json_object_int_add(json_stat, "notificationsSent",
10278                                     atomic_load_explicit(&p->notify_out,
10279                                                          memory_order_relaxed));
10280                 json_object_int_add(json_stat, "notificationsRecv",
10281                                     atomic_load_explicit(&p->notify_in,
10282                                                          memory_order_relaxed));
10283                 json_object_int_add(json_stat, "updatesSent",
10284                                     atomic_load_explicit(&p->update_out,
10285                                                          memory_order_relaxed));
10286                 json_object_int_add(json_stat, "updatesRecv",
10287                                     atomic_load_explicit(&p->update_in,
10288                                                          memory_order_relaxed));
10289                 json_object_int_add(json_stat, "keepalivesSent",
10290                                     atomic_load_explicit(&p->keepalive_out,
10291                                                          memory_order_relaxed));
10292                 json_object_int_add(json_stat, "keepalivesRecv",
10293                                     atomic_load_explicit(&p->keepalive_in,
10294                                                          memory_order_relaxed));
10295                 json_object_int_add(json_stat, "routeRefreshSent",
10296                                     atomic_load_explicit(&p->refresh_out,
10297                                                          memory_order_relaxed));
10298                 json_object_int_add(json_stat, "routeRefreshRecv",
10299                                     atomic_load_explicit(&p->refresh_in,
10300                                                          memory_order_relaxed));
10301                 json_object_int_add(json_stat, "capabilitySent",
10302                                     atomic_load_explicit(&p->dynamic_cap_out,
10303                                                          memory_order_relaxed));
10304                 json_object_int_add(json_stat, "capabilityRecv",
10305                                     atomic_load_explicit(&p->dynamic_cap_in,
10306                                                          memory_order_relaxed));
10307                 json_object_int_add(json_stat, "totalSent", PEER_TOTAL_TX(p));
10308                 json_object_int_add(json_stat, "totalRecv", PEER_TOTAL_RX(p));
10309                 json_object_object_add(json_neigh, "messageStats", json_stat);
10310         } else {
10311                 /* Packet counts. */
10312                 vty_out(vty, "  Message statistics:\n");
10313                 vty_out(vty, "    Inq depth is 0\n");
10314                 vty_out(vty, "    Outq depth is %lu\n",
10315                         (unsigned long)p->obuf->count);
10316                 vty_out(vty, "                         Sent       Rcvd\n");
10317                 vty_out(vty, "    Opens:         %10d %10d\n",
10318                         atomic_load_explicit(&p->open_out,
10319                                              memory_order_relaxed),
10320                         atomic_load_explicit(&p->open_in,
10321                                              memory_order_relaxed));
10322                 vty_out(vty, "    Notifications: %10d %10d\n",
10323                         atomic_load_explicit(&p->notify_out,
10324                                              memory_order_relaxed),
10325                         atomic_load_explicit(&p->notify_in,
10326                                              memory_order_relaxed));
10327                 vty_out(vty, "    Updates:       %10d %10d\n",
10328                         atomic_load_explicit(&p->update_out,
10329                                              memory_order_relaxed),
10330                         atomic_load_explicit(&p->update_in,
10331                                              memory_order_relaxed));
10332                 vty_out(vty, "    Keepalives:    %10d %10d\n",
10333                         atomic_load_explicit(&p->keepalive_out,
10334                                              memory_order_relaxed),
10335                         atomic_load_explicit(&p->keepalive_in,
10336                                              memory_order_relaxed));
10337                 vty_out(vty, "    Route Refresh: %10d %10d\n",
10338                         atomic_load_explicit(&p->refresh_out,
10339                                              memory_order_relaxed),
10340                         atomic_load_explicit(&p->refresh_in,
10341                                              memory_order_relaxed));
10342                 vty_out(vty, "    Capability:    %10d %10d\n",
10343                         atomic_load_explicit(&p->dynamic_cap_out,
10344                                              memory_order_relaxed),
10345                         atomic_load_explicit(&p->dynamic_cap_in,
10346                                              memory_order_relaxed));
10347                 vty_out(vty, "    Total:         %10d %10d\n", PEER_TOTAL_TX(p),
10348                         PEER_TOTAL_RX(p));
10349         }
10350
10351         if (use_json) {
10352                 /* advertisement-interval */
10353                 json_object_int_add(json_neigh,
10354                                     "minBtwnAdvertisementRunsTimerMsecs",
10355                                     p->v_routeadv * 1000);
10356
10357                 /* Update-source. */
10358                 if (p->update_if || p->update_source) {
10359                         if (p->update_if)
10360                                 json_object_string_add(json_neigh,
10361                                                        "updateSource",
10362                                                        p->update_if);
10363                         else if (p->update_source)
10364                                 json_object_string_add(
10365                                         json_neigh, "updateSource",
10366                                         sockunion2str(p->update_source, buf1,
10367                                                       SU_ADDRSTRLEN));
10368                 }
10369         } else {
10370                 /* advertisement-interval */
10371                 vty_out(vty,
10372                         "  Minimum time between advertisement runs is %d seconds\n",
10373                         p->v_routeadv);
10374
10375                 /* Update-source. */
10376                 if (p->update_if || p->update_source) {
10377                         vty_out(vty, "  Update source is ");
10378                         if (p->update_if)
10379                                 vty_out(vty, "%s", p->update_if);
10380                         else if (p->update_source)
10381                                 vty_out(vty, "%s",
10382                                         sockunion2str(p->update_source, buf1,
10383                                                       SU_ADDRSTRLEN));
10384                         vty_out(vty, "\n");
10385                 }
10386
10387                 vty_out(vty, "\n");
10388         }
10389
10390         /* Address Family Information */
10391         json_object *json_hold = NULL;
10392
10393         if (use_json)
10394                 json_hold = json_object_new_object();
10395
10396         FOREACH_AFI_SAFI (afi, safi)
10397                 if (p->afc[afi][safi])
10398                         bgp_show_peer_afi(vty, p, afi, safi, use_json,
10399                                           json_hold);
10400
10401         if (use_json) {
10402                 json_object_object_add(json_neigh, "addressFamilyInfo",
10403                                        json_hold);
10404                 json_object_int_add(json_neigh, "connectionsEstablished",
10405                                     p->established);
10406                 json_object_int_add(json_neigh, "connectionsDropped",
10407                                     p->dropped);
10408         } else
10409                 vty_out(vty, "  Connections established %d; dropped %d\n",
10410                         p->established, p->dropped);
10411
10412         if (!p->last_reset) {
10413                 if (use_json)
10414                         json_object_string_add(json_neigh, "lastReset",
10415                                                "never");
10416                 else
10417                         vty_out(vty, "  Last reset never\n");
10418         } else {
10419                 if (use_json) {
10420                         time_t uptime;
10421                         struct tm *tm;
10422
10423                         uptime = bgp_clock();
10424                         uptime -= p->resettime;
10425                         tm = gmtime(&uptime);
10426                         json_object_int_add(json_neigh, "lastResetTimerMsecs",
10427                                             (tm->tm_sec * 1000)
10428                                                     + (tm->tm_min * 60000)
10429                                                     + (tm->tm_hour * 3600000));
10430                         json_object_string_add(
10431                                 json_neigh, "lastResetDueTo",
10432                                 peer_down_str[(int)p->last_reset]);
10433                         if (p->last_reset == PEER_DOWN_NOTIFY_SEND
10434                             || p->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10435                                 char errorcodesubcode_hexstr[5];
10436                                 char errorcodesubcode_str[256];
10437
10438                                 code_str = bgp_notify_code_str(p->notify.code);
10439                                 subcode_str = bgp_notify_subcode_str(
10440                                         p->notify.code, p->notify.subcode);
10441
10442                                 sprintf(errorcodesubcode_hexstr, "%02X%02X",
10443                                         p->notify.code, p->notify.subcode);
10444                                 json_object_string_add(json_neigh,
10445                                                        "lastErrorCodeSubcode",
10446                                                        errorcodesubcode_hexstr);
10447                                 snprintf(errorcodesubcode_str, 255, "%s%s",
10448                                          code_str, subcode_str);
10449                                 json_object_string_add(json_neigh,
10450                                                        "lastNotificationReason",
10451                                                        errorcodesubcode_str);
10452                                 if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10453                                     && p->notify.code == BGP_NOTIFY_CEASE
10454                                     && (p->notify.subcode
10455                                                 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10456                                         || p->notify.subcode
10457                                                    == BGP_NOTIFY_CEASE_ADMIN_RESET)
10458                                     && p->notify.length) {
10459                                         char msgbuf[1024];
10460                                         const char *msg_str;
10461
10462                                         msg_str = bgp_notify_admin_message(
10463                                                 msgbuf, sizeof(msgbuf),
10464                                                 (uint8_t *)p->notify.data,
10465                                                 p->notify.length);
10466                                         if (msg_str)
10467                                                 json_object_string_add(
10468                                                         json_neigh,
10469                                                         "lastShutdownDescription",
10470                                                         msg_str);
10471                                 }
10472                         }
10473                 } else {
10474                         vty_out(vty, "  Last reset %s, ",
10475                                 peer_uptime(p->resettime, timebuf,
10476                                             BGP_UPTIME_LEN, 0, NULL));
10477
10478                         if (p->last_reset == PEER_DOWN_NOTIFY_SEND
10479                             || p->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10480                                 code_str = bgp_notify_code_str(p->notify.code);
10481                                 subcode_str = bgp_notify_subcode_str(
10482                                         p->notify.code, p->notify.subcode);
10483                                 vty_out(vty, "due to NOTIFICATION %s (%s%s)\n",
10484                                         p->last_reset == PEER_DOWN_NOTIFY_SEND
10485                                                 ? "sent"
10486                                                 : "received",
10487                                         code_str, subcode_str);
10488                                 if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10489                                     && p->notify.code == BGP_NOTIFY_CEASE
10490                                     && (p->notify.subcode
10491                                                 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10492                                         || p->notify.subcode
10493                                                    == BGP_NOTIFY_CEASE_ADMIN_RESET)
10494                                     && p->notify.length) {
10495                                         char msgbuf[1024];
10496                                         const char *msg_str;
10497
10498                                         msg_str = bgp_notify_admin_message(
10499                                                 msgbuf, sizeof(msgbuf),
10500                                                 (uint8_t *)p->notify.data,
10501                                                 p->notify.length);
10502                                         if (msg_str)
10503                                                 vty_out(vty,
10504                                                         "    Message: \"%s\"\n",
10505                                                         msg_str);
10506                                 }
10507                         } else {
10508                                 vty_out(vty, "due to %s\n",
10509                                         peer_down_str[(int)p->last_reset]);
10510                         }
10511
10512                         if (p->last_reset_cause_size) {
10513                                 msg = p->last_reset_cause;
10514                                 vty_out(vty,
10515                                         "  Message received that caused BGP to send a NOTIFICATION:\n    ");
10516                                 for (i = 1; i <= p->last_reset_cause_size;
10517                                      i++) {
10518                                         vty_out(vty, "%02X", *msg++);
10519
10520                                         if (i != p->last_reset_cause_size) {
10521                                                 if (i % 16 == 0) {
10522                                                         vty_out(vty, "\n    ");
10523                                                 } else if (i % 4 == 0) {
10524                                                         vty_out(vty, " ");
10525                                                 }
10526                                         }
10527                                 }
10528                                 vty_out(vty, "\n");
10529                         }
10530                 }
10531         }
10532
10533         if (CHECK_FLAG(p->sflags, PEER_STATUS_PREFIX_OVERFLOW)) {
10534                 if (use_json)
10535                         json_object_boolean_true_add(json_neigh,
10536                                                      "prefixesConfigExceedMax");
10537                 else
10538                         vty_out(vty,
10539                                 "  Peer had exceeded the max. no. of prefixes configured.\n");
10540
10541                 if (p->t_pmax_restart) {
10542                         if (use_json) {
10543                                 json_object_boolean_true_add(
10544                                         json_neigh, "reducePrefixNumFrom");
10545                                 json_object_int_add(json_neigh,
10546                                                     "restartInTimerMsec",
10547                                                     thread_timer_remain_second(
10548                                                             p->t_pmax_restart)
10549                                                             * 1000);
10550                         } else
10551                                 vty_out(vty,
10552                                         "  Reduce the no. of prefix from %s, will restart in %ld seconds\n",
10553                                         p->host, thread_timer_remain_second(
10554                                                          p->t_pmax_restart));
10555                 } else {
10556                         if (use_json)
10557                                 json_object_boolean_true_add(
10558                                         json_neigh,
10559                                         "reducePrefixNumAndClearIpBgp");
10560                         else
10561                                 vty_out(vty,
10562                                         "  Reduce the no. of prefix and clear ip bgp %s to restore peering\n",
10563                                         p->host);
10564                 }
10565         }
10566
10567         /* EBGP Multihop and GTSM */
10568         if (p->sort != BGP_PEER_IBGP) {
10569                 if (use_json) {
10570                         if (p->gtsm_hops > 0)
10571                                 json_object_int_add(json_neigh,
10572                                                     "externalBgpNbrMaxHopsAway",
10573                                                     p->gtsm_hops);
10574                         else if (p->ttl > 1)
10575                                 json_object_int_add(json_neigh,
10576                                                     "externalBgpNbrMaxHopsAway",
10577                                                     p->ttl);
10578                 } else {
10579                         if (p->gtsm_hops > 0)
10580                                 vty_out(vty,
10581                                         "  External BGP neighbor may be up to %d hops away.\n",
10582                                         p->gtsm_hops);
10583                         else if (p->ttl > 1)
10584                                 vty_out(vty,
10585                                         "  External BGP neighbor may be up to %d hops away.\n",
10586                                         p->ttl);
10587                 }
10588         } else {
10589                 if (p->gtsm_hops > 0) {
10590                         if (use_json)
10591                                 json_object_int_add(json_neigh,
10592                                                     "internalBgpNbrMaxHopsAway",
10593                                                     p->gtsm_hops);
10594                         else
10595                                 vty_out(vty,
10596                                         "  Internal BGP neighbor may be up to %d hops away.\n",
10597                                         p->gtsm_hops);
10598                 }
10599         }
10600
10601         /* Local address. */
10602         if (p->su_local) {
10603                 if (use_json) {
10604                         json_object_string_add(json_neigh, "hostLocal",
10605                                                sockunion2str(p->su_local, buf1,
10606                                                              SU_ADDRSTRLEN));
10607                         json_object_int_add(json_neigh, "portLocal",
10608                                             ntohs(p->su_local->sin.sin_port));
10609                 } else
10610                         vty_out(vty, "Local host: %s, Local port: %d\n",
10611                                 sockunion2str(p->su_local, buf1, SU_ADDRSTRLEN),
10612                                 ntohs(p->su_local->sin.sin_port));
10613         }
10614
10615         /* Remote address. */
10616         if (p->su_remote) {
10617                 if (use_json) {
10618                         json_object_string_add(json_neigh, "hostForeign",
10619                                                sockunion2str(p->su_remote, buf1,
10620                                                              SU_ADDRSTRLEN));
10621                         json_object_int_add(json_neigh, "portForeign",
10622                                             ntohs(p->su_remote->sin.sin_port));
10623                 } else
10624                         vty_out(vty, "Foreign host: %s, Foreign port: %d\n",
10625                                 sockunion2str(p->su_remote, buf1,
10626                                               SU_ADDRSTRLEN),
10627                                 ntohs(p->su_remote->sin.sin_port));
10628         }
10629
10630         /* Nexthop display. */
10631         if (p->su_local) {
10632                 if (use_json) {
10633                         json_object_string_add(json_neigh, "nexthop",
10634                                                inet_ntop(AF_INET,
10635                                                          &p->nexthop.v4, buf1,
10636                                                          sizeof(buf1)));
10637                         json_object_string_add(json_neigh, "nexthopGlobal",
10638                                                inet_ntop(AF_INET6,
10639                                                          &p->nexthop.v6_global,
10640                                                          buf1, sizeof(buf1)));
10641                         json_object_string_add(json_neigh, "nexthopLocal",
10642                                                inet_ntop(AF_INET6,
10643                                                          &p->nexthop.v6_local,
10644                                                          buf1, sizeof(buf1)));
10645                         if (p->shared_network)
10646                                 json_object_string_add(json_neigh,
10647                                                        "bgpConnection",
10648                                                        "sharedNetwork");
10649                         else
10650                                 json_object_string_add(json_neigh,
10651                                                        "bgpConnection",
10652                                                        "nonSharedNetwork");
10653                 } else {
10654                         vty_out(vty, "Nexthop: %s\n",
10655                                 inet_ntop(AF_INET, &p->nexthop.v4, buf1,
10656                                           sizeof(buf1)));
10657                         vty_out(vty, "Nexthop global: %s\n",
10658                                 inet_ntop(AF_INET6, &p->nexthop.v6_global, buf1,
10659                                           sizeof(buf1)));
10660                         vty_out(vty, "Nexthop local: %s\n",
10661                                 inet_ntop(AF_INET6, &p->nexthop.v6_local, buf1,
10662                                           sizeof(buf1)));
10663                         vty_out(vty, "BGP connection: %s\n",
10664                                 p->shared_network ? "shared network"
10665                                                   : "non shared network");
10666                 }
10667         }
10668
10669         /* Timer information. */
10670         if (use_json) {
10671                 json_object_int_add(json_neigh, "connectRetryTimer",
10672                                     p->v_connect);
10673                 if (p->status == Established && p->rtt)
10674                         json_object_int_add(json_neigh, "estimatedRttInMsecs",
10675                                             p->rtt);
10676                 if (p->t_start)
10677                         json_object_int_add(
10678                                 json_neigh, "nextStartTimerDueInMsecs",
10679                                 thread_timer_remain_second(p->t_start) * 1000);
10680                 if (p->t_connect)
10681                         json_object_int_add(
10682                                 json_neigh, "nextConnectTimerDueInMsecs",
10683                                 thread_timer_remain_second(p->t_connect)
10684                                         * 1000);
10685                 if (p->t_routeadv) {
10686                         json_object_int_add(json_neigh, "mraiInterval",
10687                                             p->v_routeadv);
10688                         json_object_int_add(
10689                                 json_neigh, "mraiTimerExpireInMsecs",
10690                                 thread_timer_remain_second(p->t_routeadv)
10691                                         * 1000);
10692                 }
10693                 if (p->password)
10694                         json_object_int_add(json_neigh, "authenticationEnabled",
10695                                             1);
10696
10697                 if (p->t_read)
10698                         json_object_string_add(json_neigh, "readThread", "on");
10699                 else
10700                         json_object_string_add(json_neigh, "readThread", "off");
10701
10702                 if (CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON))
10703                         json_object_string_add(json_neigh, "writeThread", "on");
10704                 else
10705                         json_object_string_add(json_neigh, "writeThread",
10706                                                "off");
10707         } else {
10708                 vty_out(vty, "BGP Connect Retry Timer in Seconds: %d\n",
10709                         p->v_connect);
10710                 if (p->status == Established && p->rtt)
10711                         vty_out(vty, "Estimated round trip time: %d ms\n",
10712                                 p->rtt);
10713                 if (p->t_start)
10714                         vty_out(vty, "Next start timer due in %ld seconds\n",
10715                                 thread_timer_remain_second(p->t_start));
10716                 if (p->t_connect)
10717                         vty_out(vty, "Next connect timer due in %ld seconds\n",
10718                                 thread_timer_remain_second(p->t_connect));
10719                 if (p->t_routeadv)
10720                         vty_out(vty,
10721                                 "MRAI (interval %u) timer expires in %ld seconds\n",
10722                                 p->v_routeadv,
10723                                 thread_timer_remain_second(p->t_routeadv));
10724                 if (p->password)
10725                         vty_out(vty, "Peer Authentication Enabled\n");
10726
10727                 vty_out(vty, "Read thread: %s  Write thread: %s\n",
10728                         p->t_read ? "on" : "off",
10729                         CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON)
10730                                 ? "on"
10731                                 : "off");
10732         }
10733
10734         if (p->notify.code == BGP_NOTIFY_OPEN_ERR
10735             && p->notify.subcode == BGP_NOTIFY_OPEN_UNSUP_CAPBL)
10736                 bgp_capability_vty_out(vty, p, use_json, json_neigh);
10737
10738         if (!use_json)
10739                 vty_out(vty, "\n");
10740
10741         /* BFD information. */
10742         bgp_bfd_show_info(vty, p, use_json, json_neigh);
10743
10744         if (use_json) {
10745                 if (p->conf_if) /* Configured interface name. */
10746                         json_object_object_add(json, p->conf_if, json_neigh);
10747                 else /* Configured IP address. */
10748                         json_object_object_add(json, p->host, json_neigh);
10749         }
10750 }
10751
10752 static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
10753                              enum show_type type, union sockunion *su,
10754                              const char *conf_if, bool use_json,
10755                              json_object *json)
10756 {
10757         struct listnode *node, *nnode;
10758         struct peer *peer;
10759         int find = 0;
10760         bool nbr_output = false;
10761
10762         for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
10763                 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10764                         continue;
10765
10766                 switch (type) {
10767                 case show_all:
10768                         bgp_show_peer(vty, peer, use_json, json);
10769                         nbr_output = true;
10770                         break;
10771                 case show_peer:
10772                         if (conf_if) {
10773                                 if ((peer->conf_if
10774                                      && !strcmp(peer->conf_if, conf_if))
10775                                     || (peer->hostname
10776                                         && !strcmp(peer->hostname, conf_if))) {
10777                                         find = 1;
10778                                         bgp_show_peer(vty, peer, use_json,
10779                                                       json);
10780                                 }
10781                         } else {
10782                                 if (sockunion_same(&peer->su, su)) {
10783                                         find = 1;
10784                                         bgp_show_peer(vty, peer, use_json,
10785                                                       json);
10786                                 }
10787                         }
10788                         break;
10789                 }
10790         }
10791
10792         if (type == show_peer && !find) {
10793                 if (use_json)
10794                         json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
10795                 else
10796                         vty_out(vty, "%% No such neighbor in this view/vrf\n");
10797         }
10798
10799         if (type != show_peer && !nbr_output && !use_json)
10800                 vty_out(vty, "%% No BGP neighbors found\n");
10801
10802         if (use_json) {
10803                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
10804                                              json, JSON_C_TO_STRING_PRETTY));
10805                 json_object_free(json);
10806         } else {
10807                 vty_out(vty, "\n");
10808         }
10809
10810         return CMD_SUCCESS;
10811 }
10812
10813 static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
10814                                                  enum show_type type,
10815                                                  const char *ip_str,
10816                                                  bool use_json)
10817 {
10818         struct listnode *node, *nnode;
10819         struct bgp *bgp;
10820         union sockunion su;
10821         json_object *json = NULL;
10822         int ret, is_first = 1;
10823         bool nbr_output = false;
10824
10825         if (use_json)
10826                 vty_out(vty, "{\n");
10827
10828         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
10829                 nbr_output = true;
10830                 if (use_json) {
10831                         if (!(json = json_object_new_object())) {
10832                                 flog_err(
10833                                         EC_BGP_JSON_MEM_ERROR,
10834                                         "Unable to allocate memory for JSON object");
10835                                 vty_out(vty,
10836                                         "{\"error\": {\"message:\": \"Unable to allocate memory for JSON object\"}}}\n");
10837                                 return;
10838                         }
10839
10840                         json_object_int_add(json, "vrfId",
10841                                             (bgp->vrf_id == VRF_UNKNOWN)
10842                                                     ? -1
10843                                                     : (int64_t)bgp->vrf_id);
10844                         json_object_string_add(
10845                                 json, "vrfName",
10846                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
10847                                         ? "Default"
10848                                         : bgp->name);
10849
10850                         if (!is_first)
10851                                 vty_out(vty, ",\n");
10852                         else
10853                                 is_first = 0;
10854
10855                         vty_out(vty, "\"%s\":",
10856                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
10857                                         ? "Default"
10858                                         : bgp->name);
10859                 } else {
10860                         vty_out(vty, "\nInstance %s:\n",
10861                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
10862                                         ? "Default"
10863                                         : bgp->name);
10864                 }
10865
10866                 if (type == show_peer) {
10867                         ret = str2sockunion(ip_str, &su);
10868                         if (ret < 0)
10869                                 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
10870                                                   use_json, json);
10871                         else
10872                                 bgp_show_neighbor(vty, bgp, type, &su, NULL,
10873                                                   use_json, json);
10874                 } else {
10875                         bgp_show_neighbor(vty, bgp, show_all, NULL, NULL,
10876                                           use_json, json);
10877                 }
10878         }
10879
10880         if (use_json)
10881                 vty_out(vty, "}\n");
10882         else if (!nbr_output)
10883                 vty_out(vty, "%% BGP instance not found\n");
10884 }
10885
10886 static int bgp_show_neighbor_vty(struct vty *vty, const char *name,
10887                                  enum show_type type, const char *ip_str,
10888                                  bool use_json)
10889 {
10890         int ret;
10891         struct bgp *bgp;
10892         union sockunion su;
10893         json_object *json = NULL;
10894
10895         if (name) {
10896                 if (strmatch(name, "all")) {
10897                         bgp_show_all_instances_neighbors_vty(vty, type, ip_str,
10898                                                              use_json);
10899                         return CMD_SUCCESS;
10900                 } else {
10901                         bgp = bgp_lookup_by_name(name);
10902                         if (!bgp) {
10903                                 if (use_json) {
10904                                         json = json_object_new_object();
10905                                         vty_out(vty, "%s\n",
10906                                                 json_object_to_json_string_ext(
10907                                                         json,
10908                                                         JSON_C_TO_STRING_PRETTY));
10909                                         json_object_free(json);
10910                                 } else
10911                                         vty_out(vty,
10912                                                 "%% BGP instance not found\n");
10913
10914                                 return CMD_WARNING;
10915                         }
10916                 }
10917         } else {
10918                 bgp = bgp_get_default();
10919         }
10920
10921         if (bgp) {
10922                 json = json_object_new_object();
10923                 if (ip_str) {
10924                         ret = str2sockunion(ip_str, &su);
10925                         if (ret < 0)
10926                                 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
10927                                                   use_json, json);
10928                         else
10929                                 bgp_show_neighbor(vty, bgp, type, &su, NULL,
10930                                                   use_json, json);
10931                 } else {
10932                         bgp_show_neighbor(vty, bgp, type, NULL, NULL, use_json,
10933                                           json);
10934                 }
10935                 json_object_free(json);
10936         } else {
10937                 if (use_json)
10938                         vty_out(vty, "{}\n");
10939                 else
10940                         vty_out(vty, "%% BGP instance not found\n");
10941         }
10942
10943         return CMD_SUCCESS;
10944 }
10945
10946 /* "show [ip] bgp neighbors" commands.  */
10947 DEFUN (show_ip_bgp_neighbors,
10948        show_ip_bgp_neighbors_cmd,
10949        "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] [json]",
10950        SHOW_STR
10951        IP_STR
10952        BGP_STR
10953        BGP_INSTANCE_HELP_STR
10954        "Address Family\n"
10955        "Address Family\n"
10956        "Detailed information on TCP and BGP neighbor connections\n"
10957        "Neighbor to display information about\n"
10958        "Neighbor to display information about\n"
10959        "Neighbor on BGP configured interface\n"
10960        JSON_STR)
10961 {
10962         char *vrf = NULL;
10963         char *sh_arg = NULL;
10964         enum show_type sh_type;
10965
10966         bool uj = use_json(argc, argv);
10967
10968         int idx = 0;
10969
10970         /* [<vrf> VIEWVRFNAME] */
10971         if (argv_find(argv, argc, "vrf", &idx)) {
10972                 vrf = argv[idx + 1]->arg;
10973                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
10974                         vrf = NULL;
10975         } else if (argv_find(argv, argc, "view", &idx))
10976                 /* [<view> VIEWVRFNAME] */
10977                 vrf = argv[idx + 1]->arg;
10978
10979         idx++;
10980         if (argv_find(argv, argc, "A.B.C.D", &idx)
10981             || argv_find(argv, argc, "X:X::X:X", &idx)
10982             || argv_find(argv, argc, "WORD", &idx)) {
10983                 sh_type = show_peer;
10984                 sh_arg = argv[idx]->arg;
10985         } else
10986                 sh_type = show_all;
10987
10988         return bgp_show_neighbor_vty(vty, vrf, sh_type, sh_arg, uj);
10989 }
10990
10991 /* Show BGP's AS paths internal data.  There are both `show [ip] bgp
10992    paths' and `show ip mbgp paths'.  Those functions results are the
10993    same.*/
10994 DEFUN (show_ip_bgp_paths,
10995        show_ip_bgp_paths_cmd,
10996        "show [ip] bgp ["BGP_SAFI_CMD_STR"] paths",
10997        SHOW_STR
10998        IP_STR
10999        BGP_STR
11000        BGP_SAFI_HELP_STR
11001        "Path information\n")
11002 {
11003         vty_out(vty, "Address Refcnt Path\n");
11004         aspath_print_all_vty(vty);
11005         return CMD_SUCCESS;
11006 }
11007
11008 #include "hash.h"
11009
11010 static void community_show_all_iterator(struct hash_backet *backet,
11011                                         struct vty *vty)
11012 {
11013         struct community *com;
11014
11015         com = (struct community *)backet->data;
11016         vty_out(vty, "[%p] (%ld) %s\n", (void *)com, com->refcnt,
11017                 community_str(com, false));
11018 }
11019
11020 /* Show BGP's community internal data. */
11021 DEFUN (show_ip_bgp_community_info,
11022        show_ip_bgp_community_info_cmd,
11023        "show [ip] bgp community-info",
11024        SHOW_STR
11025        IP_STR
11026        BGP_STR
11027        "List all bgp community information\n")
11028 {
11029         vty_out(vty, "Address Refcnt Community\n");
11030
11031         hash_iterate(community_hash(),
11032                      (void (*)(struct hash_backet *,
11033                                void *))community_show_all_iterator,
11034                      vty);
11035
11036         return CMD_SUCCESS;
11037 }
11038
11039 static void lcommunity_show_all_iterator(struct hash_backet *backet,
11040                                          struct vty *vty)
11041 {
11042         struct lcommunity *lcom;
11043
11044         lcom = (struct lcommunity *)backet->data;
11045         vty_out(vty, "[%p] (%ld) %s\n", (void *)lcom, lcom->refcnt,
11046                 lcommunity_str(lcom, false));
11047 }
11048
11049 /* Show BGP's community internal data. */
11050 DEFUN (show_ip_bgp_lcommunity_info,
11051        show_ip_bgp_lcommunity_info_cmd,
11052        "show ip bgp large-community-info",
11053        SHOW_STR
11054        IP_STR
11055        BGP_STR
11056        "List all bgp large-community information\n")
11057 {
11058         vty_out(vty, "Address Refcnt Large-community\n");
11059
11060         hash_iterate(lcommunity_hash(),
11061                      (void (*)(struct hash_backet *,
11062                                void *))lcommunity_show_all_iterator,
11063                      vty);
11064
11065         return CMD_SUCCESS;
11066 }
11067
11068
11069 DEFUN (show_ip_bgp_attr_info,
11070        show_ip_bgp_attr_info_cmd,
11071        "show [ip] bgp attribute-info",
11072        SHOW_STR
11073        IP_STR
11074        BGP_STR
11075        "List all bgp attribute information\n")
11076 {
11077         attr_show_all(vty);
11078         return CMD_SUCCESS;
11079 }
11080
11081 static int bgp_show_route_leak_vty(struct vty *vty, const char *name, afi_t afi,
11082                                    safi_t safi, bool use_json)
11083 {
11084         struct bgp *bgp;
11085         struct listnode *node;
11086         char *vname;
11087         char buf1[INET6_ADDRSTRLEN];
11088         char *ecom_str;
11089         vpn_policy_direction_t dir;
11090
11091         if (use_json) {
11092                 json_object *json = NULL;
11093                 json_object *json_import_vrfs = NULL;
11094                 json_object *json_export_vrfs = NULL;
11095
11096                 json = json_object_new_object();
11097
11098                 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11099
11100                 if (!bgp) {
11101                         vty_out(vty, "%s\n",
11102                                 json_object_to_json_string_ext(
11103                                         json,
11104                                         JSON_C_TO_STRING_PRETTY));
11105                         json_object_free(json);
11106
11107                         return CMD_WARNING;
11108                 }
11109
11110                 /* Provide context for the block */
11111                 json_object_string_add(json, "vrf", name ? name : "default");
11112                 json_object_string_add(json, "afiSafi",
11113                                        afi_safi_print(afi, safi));
11114
11115                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11116                                 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
11117                         json_object_string_add(json, "importFromVrfs", "none");
11118                         json_object_string_add(json, "importRts", "none");
11119                 } else {
11120                         json_import_vrfs = json_object_new_array();
11121
11122                         for (ALL_LIST_ELEMENTS_RO(
11123                                                 bgp->vpn_policy[afi].import_vrf,
11124                                                 node, vname))
11125                                 json_object_array_add(json_import_vrfs,
11126                                                 json_object_new_string(vname));
11127
11128                         dir = BGP_VPN_POLICY_DIR_FROMVPN;
11129                         ecom_str = ecommunity_ecom2str(
11130                                         bgp->vpn_policy[afi].rtlist[dir],
11131                                         ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11132                         json_object_object_add(json, "importFromVrfs",
11133                                                json_import_vrfs);
11134                         json_object_string_add(json, "importRts", ecom_str);
11135
11136                         XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11137                 }
11138
11139                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11140                                 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
11141                         json_object_string_add(json, "exportToVrfs", "none");
11142                         json_object_string_add(json, "routeDistinguisher",
11143                                                "none");
11144                         json_object_string_add(json, "exportRts", "none");
11145                 } else {
11146                         json_export_vrfs = json_object_new_array();
11147
11148                         for (ALL_LIST_ELEMENTS_RO(
11149                                                 bgp->vpn_policy[afi].export_vrf,
11150                                                 node, vname))
11151                                 json_object_array_add(json_export_vrfs,
11152                                                 json_object_new_string(vname));
11153                         json_object_object_add(json, "exportToVrfs",
11154                                                json_export_vrfs);
11155                         json_object_string_add(json, "routeDistinguisher",
11156                                    prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd,
11157                                                  buf1, RD_ADDRSTRLEN));
11158
11159                         dir = BGP_VPN_POLICY_DIR_TOVPN;
11160                         ecom_str = ecommunity_ecom2str(
11161                                                bgp->vpn_policy[afi].rtlist[dir],
11162                                                ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11163                         json_object_string_add(json, "exportRts", ecom_str);
11164
11165                         XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11166                 }
11167
11168                 vty_out(vty, "%s\n",
11169                         json_object_to_json_string_ext(json,
11170                                                       JSON_C_TO_STRING_PRETTY));
11171                 json_object_free(json);
11172
11173         } else {
11174                 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11175
11176                 if (!bgp) {
11177                         vty_out(vty, "%% No such BGP instance exist\n");
11178                         return CMD_WARNING;
11179                 }
11180
11181                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11182                                 BGP_CONFIG_VRF_TO_VRF_IMPORT))
11183                         vty_out(vty,
11184                      "This VRF is not importing %s routes from any other VRF\n",
11185                       afi_safi_print(afi, safi));
11186                 else {
11187                         vty_out(vty,
11188                    "This VRF is importing %s routes from the following VRFs:\n",
11189                     afi_safi_print(afi, safi));
11190
11191                         for (ALL_LIST_ELEMENTS_RO(
11192                                                 bgp->vpn_policy[afi].import_vrf,
11193                                                 node, vname))
11194                                 vty_out(vty, "  %s\n", vname);
11195
11196                         dir = BGP_VPN_POLICY_DIR_FROMVPN;
11197                         ecom_str = ecommunity_ecom2str(
11198                                                bgp->vpn_policy[afi].rtlist[dir],
11199                                                ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11200                         vty_out(vty, "Import RT(s): %s\n", ecom_str);
11201
11202                         XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11203                 }
11204
11205                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11206                                 BGP_CONFIG_VRF_TO_VRF_EXPORT))
11207                         vty_out(vty,
11208                        "This VRF is not exporting %s routes to any other VRF\n",
11209                         afi_safi_print(afi, safi));
11210                 else {
11211                         vty_out(vty,
11212                        "This VRF is exporting %s routes to the following VRFs:\n",
11213                         afi_safi_print(afi, safi));
11214
11215                         for (ALL_LIST_ELEMENTS_RO(
11216                                                 bgp->vpn_policy[afi].export_vrf,
11217                                                 node, vname))
11218                                 vty_out(vty, "  %s\n", vname);
11219
11220                         vty_out(vty, "RD: %s\n",
11221                                 prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd,
11222                                               buf1, RD_ADDRSTRLEN));
11223
11224                         dir = BGP_VPN_POLICY_DIR_TOVPN;
11225                         ecom_str = ecommunity_ecom2str(
11226                                         bgp->vpn_policy[afi].rtlist[dir],
11227                                         ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11228                         vty_out(vty, "Export RT: %s\n", ecom_str);
11229                         XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11230                 }
11231         }
11232
11233         return CMD_SUCCESS;
11234 }
11235
11236 /* "show [ip] bgp route-leak" command.  */
11237 DEFUN (show_ip_bgp_route_leak,
11238         show_ip_bgp_route_leak_cmd,
11239         "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] route-leak  [json]",
11240         SHOW_STR
11241         IP_STR
11242         BGP_STR
11243         BGP_INSTANCE_HELP_STR
11244         BGP_AFI_HELP_STR
11245         BGP_SAFI_HELP_STR
11246         "Route leaking information\n"
11247         JSON_STR)
11248 {
11249         char *vrf = NULL;
11250         afi_t afi = AFI_MAX;
11251         safi_t safi = SAFI_MAX;
11252
11253         bool uj = use_json(argc, argv);
11254         int idx = 0;
11255
11256         /* show [ip] bgp */
11257         if (argv_find(argv, argc, "ip", &idx)) {
11258                 afi = AFI_IP;
11259                 safi = SAFI_UNICAST;
11260         }
11261         /* [vrf VIEWVRFNAME] */
11262         if (argv_find(argv, argc, "view", &idx)) {
11263                 vty_out(vty,
11264                         "%% This command is not applicable to BGP views\n");
11265                 return CMD_WARNING;
11266         }
11267
11268         if (argv_find(argv, argc, "vrf", &idx)) {
11269                 vrf = argv[idx + 1]->arg;
11270                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11271                         vrf = NULL;
11272         }
11273         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
11274         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
11275                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
11276         }
11277
11278         if (!((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST)) {
11279                 vty_out(vty,
11280                         "%% This command is applicable only for unicast ipv4|ipv6\n");
11281                 return CMD_WARNING;
11282         }
11283
11284         return bgp_show_route_leak_vty(vty, vrf, afi, safi, uj);
11285 }
11286
11287 static void bgp_show_all_instances_updgrps_vty(struct vty *vty, afi_t afi,
11288                                                safi_t safi)
11289 {
11290         struct listnode *node, *nnode;
11291         struct bgp *bgp;
11292
11293         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
11294                 vty_out(vty, "\nInstance %s:\n",
11295                         (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11296                                 ? "Default"
11297                                 : bgp->name);
11298                 update_group_show(bgp, afi, safi, vty, 0);
11299         }
11300 }
11301
11302 static int bgp_show_update_groups(struct vty *vty, const char *name, int afi,
11303                                   int safi, uint64_t subgrp_id)
11304 {
11305         struct bgp *bgp;
11306
11307         if (name) {
11308                 if (strmatch(name, "all")) {
11309                         bgp_show_all_instances_updgrps_vty(vty, afi, safi);
11310                         return CMD_SUCCESS;
11311                 } else {
11312                         bgp = bgp_lookup_by_name(name);
11313                 }
11314         } else {
11315                 bgp = bgp_get_default();
11316         }
11317
11318         if (bgp)
11319                 update_group_show(bgp, afi, safi, vty, subgrp_id);
11320         return CMD_SUCCESS;
11321 }
11322
11323 DEFUN (show_ip_bgp_updgrps,
11324        show_ip_bgp_updgrps_cmd,
11325        "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] update-groups [SUBGROUP-ID]",
11326        SHOW_STR
11327        IP_STR
11328        BGP_STR
11329        BGP_INSTANCE_HELP_STR
11330        BGP_AFI_HELP_STR
11331        BGP_SAFI_WITH_LABEL_HELP_STR
11332        "Detailed info about dynamic update groups\n"
11333        "Specific subgroup to display detailed info for\n")
11334 {
11335         char *vrf = NULL;
11336         afi_t afi = AFI_IP6;
11337         safi_t safi = SAFI_UNICAST;
11338         uint64_t subgrp_id = 0;
11339
11340         int idx = 0;
11341
11342         /* show [ip] bgp */
11343         if (argv_find(argv, argc, "ip", &idx))
11344                 afi = AFI_IP;
11345         /* [<vrf> VIEWVRFNAME] */
11346         if (argv_find(argv, argc, "vrf", &idx)) {
11347                 vrf = argv[idx + 1]->arg;
11348                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11349                         vrf = NULL;
11350         } else if (argv_find(argv, argc, "view", &idx))
11351                 /* [<view> VIEWVRFNAME] */
11352                 vrf = argv[idx + 1]->arg;
11353         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
11354         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
11355                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
11356         }
11357
11358         /* get subgroup id, if provided */
11359         idx = argc - 1;
11360         if (argv[idx]->type == VARIABLE_TKN)
11361                 subgrp_id = strtoull(argv[idx]->arg, NULL, 10);
11362
11363         return (bgp_show_update_groups(vty, vrf, afi, safi, subgrp_id));
11364 }
11365
11366 DEFUN (show_bgp_instance_all_ipv6_updgrps,
11367        show_bgp_instance_all_ipv6_updgrps_cmd,
11368        "show [ip] bgp <view|vrf> all update-groups",
11369        SHOW_STR
11370        IP_STR
11371        BGP_STR
11372        BGP_INSTANCE_ALL_HELP_STR
11373        "Detailed info about dynamic update groups\n")
11374 {
11375         bgp_show_all_instances_updgrps_vty(vty, AFI_IP6, SAFI_UNICAST);
11376         return CMD_SUCCESS;
11377 }
11378
11379 DEFUN (show_bgp_updgrps_stats,
11380        show_bgp_updgrps_stats_cmd,
11381        "show [ip] bgp update-groups statistics",
11382        SHOW_STR
11383        IP_STR
11384        BGP_STR
11385        "Detailed info about dynamic update groups\n"
11386        "Statistics\n")
11387 {
11388         struct bgp *bgp;
11389
11390         bgp = bgp_get_default();
11391         if (bgp)
11392                 update_group_show_stats(bgp, vty);
11393
11394         return CMD_SUCCESS;
11395 }
11396
11397 DEFUN (show_bgp_instance_updgrps_stats,
11398        show_bgp_instance_updgrps_stats_cmd,
11399        "show [ip] bgp <view|vrf> VIEWVRFNAME update-groups statistics",
11400        SHOW_STR
11401        IP_STR
11402        BGP_STR
11403        BGP_INSTANCE_HELP_STR
11404        "Detailed info about dynamic update groups\n"
11405        "Statistics\n")
11406 {
11407         int idx_word = 3;
11408         struct bgp *bgp;
11409
11410         bgp = bgp_lookup_by_name(argv[idx_word]->arg);
11411         if (bgp)
11412                 update_group_show_stats(bgp, vty);
11413
11414         return CMD_SUCCESS;
11415 }
11416
11417 static void show_bgp_updgrps_adj_info_aux(struct vty *vty, const char *name,
11418                                           afi_t afi, safi_t safi,
11419                                           const char *what, uint64_t subgrp_id)
11420 {
11421         struct bgp *bgp;
11422
11423         if (name)
11424                 bgp = bgp_lookup_by_name(name);
11425         else
11426                 bgp = bgp_get_default();
11427
11428         if (bgp) {
11429                 if (!strcmp(what, "advertise-queue"))
11430                         update_group_show_adj_queue(bgp, afi, safi, vty,
11431                                                     subgrp_id);
11432                 else if (!strcmp(what, "advertised-routes"))
11433                         update_group_show_advertised(bgp, afi, safi, vty,
11434                                                      subgrp_id);
11435                 else if (!strcmp(what, "packet-queue"))
11436                         update_group_show_packet_queue(bgp, afi, safi, vty,
11437                                                        subgrp_id);
11438         }
11439 }
11440
11441 DEFPY(show_ip_bgp_instance_updgrps_adj_s,
11442       show_ip_bgp_instance_updgrps_adj_s_cmd,
11443       "show [ip]$ip bgp [<view|vrf> VIEWVRFNAME$vrf] [<ipv4|ipv6>$afi <unicast|multicast|vpn>$safi] update-groups [SUBGROUP-ID]$sgid <advertise-queue|advertised-routes|packet-queue>$rtq",
11444       SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
11445               BGP_SAFI_HELP_STR
11446       "Detailed info about dynamic update groups\n"
11447       "Specific subgroup to display info for\n"
11448       "Advertisement queue\n"
11449       "Announced routes\n"
11450       "Packet queue\n")
11451 {
11452         uint64_t subgrp_id = 0;
11453         afi_t afiz;
11454         safi_t safiz;
11455         if (sgid)
11456                 subgrp_id = strtoull(sgid, NULL, 10);
11457
11458         if (!ip && !afi)
11459                 afiz = AFI_IP6;
11460         if (!ip && afi)
11461                 afiz = bgp_vty_afi_from_str(afi);
11462         if (ip && !afi)
11463                 afiz = AFI_IP;
11464         if (ip && afi) {
11465                 afiz = bgp_vty_afi_from_str(afi);
11466                 if (afiz != AFI_IP)
11467                         vty_out(vty,
11468                                 "%% Cannot specify both 'ip' and 'ipv6'\n");
11469                 return CMD_WARNING;
11470         }
11471
11472         safiz = safi ? bgp_vty_safi_from_str(safi) : SAFI_UNICAST;
11473
11474         show_bgp_updgrps_adj_info_aux(vty, vrf, afiz, safiz, rtq, subgrp_id);
11475         return CMD_SUCCESS;
11476 }
11477
11478 static int bgp_show_one_peer_group(struct vty *vty, struct peer_group *group)
11479 {
11480         struct listnode *node, *nnode;
11481         struct prefix *range;
11482         struct peer *conf;
11483         struct peer *peer;
11484         char buf[PREFIX2STR_BUFFER];
11485         afi_t afi;
11486         safi_t safi;
11487         const char *peer_status;
11488         const char *af_str;
11489         int lr_count;
11490         int dynamic;
11491         int af_cfgd;
11492
11493         conf = group->conf;
11494
11495         if (conf->as_type == AS_SPECIFIED || conf->as_type == AS_EXTERNAL) {
11496                 vty_out(vty, "\nBGP peer-group %s, remote AS %d\n", group->name,
11497                         conf->as);
11498         } else if (conf->as_type == AS_INTERNAL) {
11499                 vty_out(vty, "\nBGP peer-group %s, remote AS %d\n", group->name,
11500                         group->bgp->as);
11501         } else {
11502                 vty_out(vty, "\nBGP peer-group %s\n", group->name);
11503         }
11504
11505         if ((group->bgp->as == conf->as) || (conf->as_type == AS_INTERNAL))
11506                 vty_out(vty, "  Peer-group type is internal\n");
11507         else
11508                 vty_out(vty, "  Peer-group type is external\n");
11509
11510         /* Display AFs configured. */
11511         vty_out(vty, "  Configured address-families:");
11512         FOREACH_AFI_SAFI (afi, safi) {
11513                 if (conf->afc[afi][safi]) {
11514                         af_cfgd = 1;
11515                         vty_out(vty, " %s;", afi_safi_print(afi, safi));
11516                 }
11517         }
11518         if (!af_cfgd)
11519                 vty_out(vty, " none\n");
11520         else
11521                 vty_out(vty, "\n");
11522
11523         /* Display listen ranges (for dynamic neighbors), if any */
11524         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
11525                 if (afi == AFI_IP)
11526                         af_str = "IPv4";
11527                 else if (afi == AFI_IP6)
11528                         af_str = "IPv6";
11529                 else
11530                         af_str = "???";
11531                 lr_count = listcount(group->listen_range[afi]);
11532                 if (lr_count) {
11533                         vty_out(vty, "  %d %s listen range(s)\n", lr_count,
11534                                 af_str);
11535
11536
11537                         for (ALL_LIST_ELEMENTS(group->listen_range[afi], node,
11538                                                nnode, range)) {
11539                                 prefix2str(range, buf, sizeof(buf));
11540                                 vty_out(vty, "    %s\n", buf);
11541                         }
11542                 }
11543         }
11544
11545         /* Display group members and their status */
11546         if (listcount(group->peer)) {
11547                 vty_out(vty, "  Peer-group members:\n");
11548                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
11549                         if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
11550                                 peer_status = "Idle (Admin)";
11551                         else if (CHECK_FLAG(peer->sflags,
11552                                             PEER_STATUS_PREFIX_OVERFLOW))
11553                                 peer_status = "Idle (PfxCt)";
11554                         else
11555                                 peer_status = lookup_msg(bgp_status_msg,
11556                                                          peer->status, NULL);
11557
11558                         dynamic = peer_dynamic_neighbor(peer);
11559                         vty_out(vty, "    %s %s %s \n", peer->host,
11560                                 dynamic ? "(dynamic)" : "", peer_status);
11561                 }
11562         }
11563
11564         return CMD_SUCCESS;
11565 }
11566
11567 static int bgp_show_peer_group_vty(struct vty *vty, const char *name,
11568                                    const char *group_name)
11569 {
11570         struct bgp *bgp;
11571         struct listnode *node, *nnode;
11572         struct peer_group *group;
11573         bool found = false;
11574
11575         bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11576
11577         if (!bgp) {
11578                 vty_out(vty, "%% BGP instance not found\n");
11579                 return CMD_WARNING;
11580         }
11581
11582         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
11583                 if (group_name) {
11584                         if (strmatch(group->name, group_name)) {
11585                                 bgp_show_one_peer_group(vty, group);
11586                                 found = true;
11587                                 break;
11588                         }
11589                 } else {
11590                         bgp_show_one_peer_group(vty, group);
11591                 }
11592         }
11593
11594         if (group_name && !found)
11595                 vty_out(vty, "%% No such peer-group\n");
11596
11597         return CMD_SUCCESS;
11598 }
11599
11600 DEFUN (show_ip_bgp_peer_groups,
11601        show_ip_bgp_peer_groups_cmd,
11602        "show [ip] bgp [<view|vrf> VIEWVRFNAME] peer-group [PGNAME]",
11603        SHOW_STR
11604        IP_STR
11605        BGP_STR
11606        BGP_INSTANCE_HELP_STR
11607        "Detailed information on BGP peer groups\n"
11608        "Peer group name\n")
11609 {
11610         char *vrf, *pg;
11611         int idx = 0;
11612
11613         vrf = argv_find(argv, argc, "VIEWVRFNAME", &idx) ? argv[idx]->arg
11614                                                          : NULL;
11615         pg = argv_find(argv, argc, "PGNAME", &idx) ? argv[idx]->arg : NULL;
11616
11617         return bgp_show_peer_group_vty(vty, vrf, pg);
11618 }
11619
11620
11621 /* Redistribute VTY commands.  */
11622
11623 DEFUN (bgp_redistribute_ipv4,
11624        bgp_redistribute_ipv4_cmd,
11625        "redistribute " FRR_IP_REDIST_STR_BGPD,
11626        "Redistribute information from another routing protocol\n"
11627        FRR_IP_REDIST_HELP_STR_BGPD)
11628 {
11629         VTY_DECLVAR_CONTEXT(bgp, bgp);
11630         int idx_protocol = 1;
11631         int type;
11632
11633         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11634         if (type < 0) {
11635                 vty_out(vty, "%% Invalid route type\n");
11636                 return CMD_WARNING_CONFIG_FAILED;
11637         }
11638
11639         bgp_redist_add(bgp, AFI_IP, type, 0);
11640         return bgp_redistribute_set(bgp, AFI_IP, type, 0, false);
11641 }
11642
11643 ALIAS_HIDDEN(
11644         bgp_redistribute_ipv4, bgp_redistribute_ipv4_hidden_cmd,
11645         "redistribute " FRR_IP_REDIST_STR_BGPD,
11646         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD)
11647
11648 DEFUN (bgp_redistribute_ipv4_rmap,
11649        bgp_redistribute_ipv4_rmap_cmd,
11650        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD",
11651        "Redistribute information from another routing protocol\n"
11652        FRR_IP_REDIST_HELP_STR_BGPD
11653        "Route map reference\n"
11654        "Pointer to route-map entries\n")
11655 {
11656         VTY_DECLVAR_CONTEXT(bgp, bgp);
11657         int idx_protocol = 1;
11658         int idx_word = 3;
11659         int type;
11660         struct bgp_redist *red;
11661         bool changed;
11662         struct route_map *route_map = route_map_lookup_warn_noexist(
11663                 vty, argv[idx_word]->arg);
11664
11665         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11666         if (type < 0) {
11667                 vty_out(vty, "%% Invalid route type\n");
11668                 return CMD_WARNING_CONFIG_FAILED;
11669         }
11670
11671         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11672         changed =
11673                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11674         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11675 }
11676
11677 ALIAS_HIDDEN(
11678         bgp_redistribute_ipv4_rmap, bgp_redistribute_ipv4_rmap_hidden_cmd,
11679         "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD",
11680         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11681         "Route map reference\n"
11682         "Pointer to route-map entries\n")
11683
11684 DEFUN (bgp_redistribute_ipv4_metric,
11685        bgp_redistribute_ipv4_metric_cmd,
11686        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
11687        "Redistribute information from another routing protocol\n"
11688        FRR_IP_REDIST_HELP_STR_BGPD
11689        "Metric for redistributed routes\n"
11690        "Default metric\n")
11691 {
11692         VTY_DECLVAR_CONTEXT(bgp, bgp);
11693         int idx_protocol = 1;
11694         int idx_number = 3;
11695         int type;
11696         uint32_t metric;
11697         struct bgp_redist *red;
11698         bool changed;
11699
11700         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11701         if (type < 0) {
11702                 vty_out(vty, "%% Invalid route type\n");
11703                 return CMD_WARNING_CONFIG_FAILED;
11704         }
11705         metric = strtoul(argv[idx_number]->arg, NULL, 10);
11706
11707         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11708         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
11709         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11710 }
11711
11712 ALIAS_HIDDEN(
11713         bgp_redistribute_ipv4_metric, bgp_redistribute_ipv4_metric_hidden_cmd,
11714         "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
11715         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11716         "Metric for redistributed routes\n"
11717         "Default metric\n")
11718
11719 DEFUN (bgp_redistribute_ipv4_rmap_metric,
11720        bgp_redistribute_ipv4_rmap_metric_cmd,
11721        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
11722        "Redistribute information from another routing protocol\n"
11723        FRR_IP_REDIST_HELP_STR_BGPD
11724        "Route map reference\n"
11725        "Pointer to route-map entries\n"
11726        "Metric for redistributed routes\n"
11727        "Default metric\n")
11728 {
11729         VTY_DECLVAR_CONTEXT(bgp, bgp);
11730         int idx_protocol = 1;
11731         int idx_word = 3;
11732         int idx_number = 5;
11733         int type;
11734         uint32_t metric;
11735         struct bgp_redist *red;
11736         bool changed;
11737         struct route_map *route_map =
11738                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
11739
11740         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11741         if (type < 0) {
11742                 vty_out(vty, "%% Invalid route type\n");
11743                 return CMD_WARNING_CONFIG_FAILED;
11744         }
11745         metric = strtoul(argv[idx_number]->arg, NULL, 10);
11746
11747         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11748         changed =
11749                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11750         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
11751         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11752 }
11753
11754 ALIAS_HIDDEN(
11755         bgp_redistribute_ipv4_rmap_metric,
11756         bgp_redistribute_ipv4_rmap_metric_hidden_cmd,
11757         "redistribute " FRR_IP_REDIST_STR_BGPD
11758         " route-map WORD metric (0-4294967295)",
11759         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11760         "Route map reference\n"
11761         "Pointer to route-map entries\n"
11762         "Metric for redistributed routes\n"
11763         "Default metric\n")
11764
11765 DEFUN (bgp_redistribute_ipv4_metric_rmap,
11766        bgp_redistribute_ipv4_metric_rmap_cmd,
11767        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
11768        "Redistribute information from another routing protocol\n"
11769        FRR_IP_REDIST_HELP_STR_BGPD
11770        "Metric for redistributed routes\n"
11771        "Default metric\n"
11772        "Route map reference\n"
11773        "Pointer to route-map entries\n")
11774 {
11775         VTY_DECLVAR_CONTEXT(bgp, bgp);
11776         int idx_protocol = 1;
11777         int idx_number = 3;
11778         int idx_word = 5;
11779         int type;
11780         uint32_t metric;
11781         struct bgp_redist *red;
11782         bool changed;
11783         struct route_map *route_map =
11784                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
11785
11786         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11787         if (type < 0) {
11788                 vty_out(vty, "%% Invalid route type\n");
11789                 return CMD_WARNING_CONFIG_FAILED;
11790         }
11791         metric = strtoul(argv[idx_number]->arg, NULL, 10);
11792
11793         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11794         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
11795         changed |=
11796                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11797         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11798 }
11799
11800 ALIAS_HIDDEN(
11801         bgp_redistribute_ipv4_metric_rmap,
11802         bgp_redistribute_ipv4_metric_rmap_hidden_cmd,
11803         "redistribute " FRR_IP_REDIST_STR_BGPD
11804         " metric (0-4294967295) route-map WORD",
11805         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11806         "Metric for redistributed routes\n"
11807         "Default metric\n"
11808         "Route map reference\n"
11809         "Pointer to route-map entries\n")
11810
11811 DEFUN (bgp_redistribute_ipv4_ospf,
11812        bgp_redistribute_ipv4_ospf_cmd,
11813        "redistribute <ospf|table> (1-65535)",
11814        "Redistribute information from another routing protocol\n"
11815        "Open Shortest Path First (OSPFv2)\n"
11816        "Non-main Kernel Routing Table\n"
11817        "Instance ID/Table ID\n")
11818 {
11819         VTY_DECLVAR_CONTEXT(bgp, bgp);
11820         int idx_ospf_table = 1;
11821         int idx_number = 2;
11822         unsigned short instance;
11823         unsigned short protocol;
11824
11825         instance = strtoul(argv[idx_number]->arg, NULL, 10);
11826
11827         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
11828                 protocol = ZEBRA_ROUTE_OSPF;
11829         else
11830                 protocol = ZEBRA_ROUTE_TABLE;
11831
11832         bgp_redist_add(bgp, AFI_IP, protocol, instance);
11833         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, false);
11834 }
11835
11836 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf, bgp_redistribute_ipv4_ospf_hidden_cmd,
11837              "redistribute <ospf|table> (1-65535)",
11838              "Redistribute information from another routing protocol\n"
11839              "Open Shortest Path First (OSPFv2)\n"
11840              "Non-main Kernel Routing Table\n"
11841              "Instance ID/Table ID\n")
11842
11843 DEFUN (bgp_redistribute_ipv4_ospf_rmap,
11844        bgp_redistribute_ipv4_ospf_rmap_cmd,
11845        "redistribute <ospf|table> (1-65535) route-map WORD",
11846        "Redistribute information from another routing protocol\n"
11847        "Open Shortest Path First (OSPFv2)\n"
11848        "Non-main Kernel Routing Table\n"
11849        "Instance ID/Table ID\n"
11850        "Route map reference\n"
11851        "Pointer to route-map entries\n")
11852 {
11853         VTY_DECLVAR_CONTEXT(bgp, bgp);
11854         int idx_ospf_table = 1;
11855         int idx_number = 2;
11856         int idx_word = 4;
11857         struct bgp_redist *red;
11858         unsigned short instance;
11859         int protocol;
11860         bool changed;
11861         struct route_map *route_map =
11862                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
11863
11864         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
11865                 protocol = ZEBRA_ROUTE_OSPF;
11866         else
11867                 protocol = ZEBRA_ROUTE_TABLE;
11868
11869         instance = strtoul(argv[idx_number]->arg, NULL, 10);
11870         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
11871         changed =
11872                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11873         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
11874 }
11875
11876 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_rmap,
11877              bgp_redistribute_ipv4_ospf_rmap_hidden_cmd,
11878              "redistribute <ospf|table> (1-65535) route-map WORD",
11879              "Redistribute information from another routing protocol\n"
11880              "Open Shortest Path First (OSPFv2)\n"
11881              "Non-main Kernel Routing Table\n"
11882              "Instance ID/Table ID\n"
11883              "Route map reference\n"
11884              "Pointer to route-map entries\n")
11885
11886 DEFUN (bgp_redistribute_ipv4_ospf_metric,
11887        bgp_redistribute_ipv4_ospf_metric_cmd,
11888        "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
11889        "Redistribute information from another routing protocol\n"
11890        "Open Shortest Path First (OSPFv2)\n"
11891        "Non-main Kernel Routing Table\n"
11892        "Instance ID/Table ID\n"
11893        "Metric for redistributed routes\n"
11894        "Default metric\n")
11895 {
11896         VTY_DECLVAR_CONTEXT(bgp, bgp);
11897         int idx_ospf_table = 1;
11898         int idx_number = 2;
11899         int idx_number_2 = 4;
11900         uint32_t metric;
11901         struct bgp_redist *red;
11902         unsigned short instance;
11903         int protocol;
11904         bool changed;
11905
11906         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
11907                 protocol = ZEBRA_ROUTE_OSPF;
11908         else
11909                 protocol = ZEBRA_ROUTE_TABLE;
11910
11911         instance = strtoul(argv[idx_number]->arg, NULL, 10);
11912         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
11913
11914         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
11915         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
11916                                                 metric);
11917         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
11918 }
11919
11920 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_metric,
11921              bgp_redistribute_ipv4_ospf_metric_hidden_cmd,
11922              "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
11923              "Redistribute information from another routing protocol\n"
11924              "Open Shortest Path First (OSPFv2)\n"
11925              "Non-main Kernel Routing Table\n"
11926              "Instance ID/Table ID\n"
11927              "Metric for redistributed routes\n"
11928              "Default metric\n")
11929
11930 DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
11931        bgp_redistribute_ipv4_ospf_rmap_metric_cmd,
11932        "redistribute <ospf|table> (1-65535) route-map WORD metric (0-4294967295)",
11933        "Redistribute information from another routing protocol\n"
11934        "Open Shortest Path First (OSPFv2)\n"
11935        "Non-main Kernel Routing Table\n"
11936        "Instance ID/Table ID\n"
11937        "Route map reference\n"
11938        "Pointer to route-map entries\n"
11939        "Metric for redistributed routes\n"
11940        "Default metric\n")
11941 {
11942         VTY_DECLVAR_CONTEXT(bgp, bgp);
11943         int idx_ospf_table = 1;
11944         int idx_number = 2;
11945         int idx_word = 4;
11946         int idx_number_2 = 6;
11947         uint32_t metric;
11948         struct bgp_redist *red;
11949         unsigned short instance;
11950         int protocol;
11951         bool changed;
11952         struct route_map *route_map =
11953                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
11954
11955         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
11956                 protocol = ZEBRA_ROUTE_OSPF;
11957         else
11958                 protocol = ZEBRA_ROUTE_TABLE;
11959
11960         instance = strtoul(argv[idx_number]->arg, NULL, 10);
11961         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
11962
11963         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
11964         changed =
11965                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11966         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
11967                                                 metric);
11968         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
11969 }
11970
11971 ALIAS_HIDDEN(
11972         bgp_redistribute_ipv4_ospf_rmap_metric,
11973         bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd,
11974         "redistribute <ospf|table> (1-65535) route-map WORD metric (0-4294967295)",
11975         "Redistribute information from another routing protocol\n"
11976         "Open Shortest Path First (OSPFv2)\n"
11977         "Non-main Kernel Routing Table\n"
11978         "Instance ID/Table ID\n"
11979         "Route map reference\n"
11980         "Pointer to route-map entries\n"
11981         "Metric for redistributed routes\n"
11982         "Default metric\n")
11983
11984 DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
11985        bgp_redistribute_ipv4_ospf_metric_rmap_cmd,
11986        "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map WORD",
11987        "Redistribute information from another routing protocol\n"
11988        "Open Shortest Path First (OSPFv2)\n"
11989        "Non-main Kernel Routing Table\n"
11990        "Instance ID/Table ID\n"
11991        "Metric for redistributed routes\n"
11992        "Default metric\n"
11993        "Route map reference\n"
11994        "Pointer to route-map entries\n")
11995 {
11996         VTY_DECLVAR_CONTEXT(bgp, bgp);
11997         int idx_ospf_table = 1;
11998         int idx_number = 2;
11999         int idx_number_2 = 4;
12000         int idx_word = 6;
12001         uint32_t metric;
12002         struct bgp_redist *red;
12003         unsigned short instance;
12004         int protocol;
12005         bool changed;
12006         struct route_map *route_map =
12007                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12008
12009         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12010                 protocol = ZEBRA_ROUTE_OSPF;
12011         else
12012                 protocol = ZEBRA_ROUTE_TABLE;
12013
12014         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12015         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
12016
12017         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
12018         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
12019                                                 metric);
12020         changed |=
12021                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12022         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
12023 }
12024
12025 ALIAS_HIDDEN(
12026         bgp_redistribute_ipv4_ospf_metric_rmap,
12027         bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd,
12028         "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map WORD",
12029         "Redistribute information from another routing protocol\n"
12030         "Open Shortest Path First (OSPFv2)\n"
12031         "Non-main Kernel Routing Table\n"
12032         "Instance ID/Table ID\n"
12033         "Metric for redistributed routes\n"
12034         "Default metric\n"
12035         "Route map reference\n"
12036         "Pointer to route-map entries\n")
12037
12038 DEFUN (no_bgp_redistribute_ipv4_ospf,
12039        no_bgp_redistribute_ipv4_ospf_cmd,
12040        "no redistribute <ospf|table> (1-65535) [metric (0-4294967295)] [route-map WORD]",
12041        NO_STR
12042        "Redistribute information from another routing protocol\n"
12043        "Open Shortest Path First (OSPFv2)\n"
12044        "Non-main Kernel Routing Table\n"
12045        "Instance ID/Table ID\n"
12046        "Metric for redistributed routes\n"
12047        "Default metric\n"
12048        "Route map reference\n"
12049        "Pointer to route-map entries\n")
12050 {
12051         VTY_DECLVAR_CONTEXT(bgp, bgp);
12052         int idx_ospf_table = 2;
12053         int idx_number = 3;
12054         unsigned short instance;
12055         int protocol;
12056
12057         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12058                 protocol = ZEBRA_ROUTE_OSPF;
12059         else
12060                 protocol = ZEBRA_ROUTE_TABLE;
12061
12062         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12063         return bgp_redistribute_unset(bgp, AFI_IP, protocol, instance);
12064 }
12065
12066 ALIAS_HIDDEN(
12067         no_bgp_redistribute_ipv4_ospf, no_bgp_redistribute_ipv4_ospf_hidden_cmd,
12068         "no redistribute <ospf|table> (1-65535) [metric (0-4294967295)] [route-map WORD]",
12069         NO_STR
12070         "Redistribute information from another routing protocol\n"
12071         "Open Shortest Path First (OSPFv2)\n"
12072         "Non-main Kernel Routing Table\n"
12073         "Instance ID/Table ID\n"
12074         "Metric for redistributed routes\n"
12075         "Default metric\n"
12076         "Route map reference\n"
12077         "Pointer to route-map entries\n")
12078
12079 DEFUN (no_bgp_redistribute_ipv4,
12080        no_bgp_redistribute_ipv4_cmd,
12081        "no redistribute " FRR_IP_REDIST_STR_BGPD " [metric (0-4294967295)] [route-map WORD]",
12082        NO_STR
12083        "Redistribute information from another routing protocol\n"
12084        FRR_IP_REDIST_HELP_STR_BGPD
12085        "Metric for redistributed routes\n"
12086        "Default metric\n"
12087        "Route map reference\n"
12088        "Pointer to route-map entries\n")
12089 {
12090         VTY_DECLVAR_CONTEXT(bgp, bgp);
12091         int idx_protocol = 2;
12092         int type;
12093
12094         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
12095         if (type < 0) {
12096                 vty_out(vty, "%% Invalid route type\n");
12097                 return CMD_WARNING_CONFIG_FAILED;
12098         }
12099         return bgp_redistribute_unset(bgp, AFI_IP, type, 0);
12100 }
12101
12102 ALIAS_HIDDEN(
12103         no_bgp_redistribute_ipv4, no_bgp_redistribute_ipv4_hidden_cmd,
12104         "no redistribute " FRR_IP_REDIST_STR_BGPD
12105         " [metric (0-4294967295)] [route-map WORD]",
12106         NO_STR
12107         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
12108         "Metric for redistributed routes\n"
12109         "Default metric\n"
12110         "Route map reference\n"
12111         "Pointer to route-map entries\n")
12112
12113 DEFUN (bgp_redistribute_ipv6,
12114        bgp_redistribute_ipv6_cmd,
12115        "redistribute " FRR_IP6_REDIST_STR_BGPD,
12116        "Redistribute information from another routing protocol\n"
12117        FRR_IP6_REDIST_HELP_STR_BGPD)
12118 {
12119         VTY_DECLVAR_CONTEXT(bgp, bgp);
12120         int idx_protocol = 1;
12121         int type;
12122
12123         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12124         if (type < 0) {
12125                 vty_out(vty, "%% Invalid route type\n");
12126                 return CMD_WARNING_CONFIG_FAILED;
12127         }
12128
12129         bgp_redist_add(bgp, AFI_IP6, type, 0);
12130         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, false);
12131 }
12132
12133 DEFUN (bgp_redistribute_ipv6_rmap,
12134        bgp_redistribute_ipv6_rmap_cmd,
12135        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD",
12136        "Redistribute information from another routing protocol\n"
12137        FRR_IP6_REDIST_HELP_STR_BGPD
12138        "Route map reference\n"
12139        "Pointer to route-map entries\n")
12140 {
12141         VTY_DECLVAR_CONTEXT(bgp, bgp);
12142         int idx_protocol = 1;
12143         int idx_word = 3;
12144         int type;
12145         struct bgp_redist *red;
12146         bool changed;
12147         struct route_map *route_map =
12148                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12149
12150         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12151         if (type < 0) {
12152                 vty_out(vty, "%% Invalid route type\n");
12153                 return CMD_WARNING_CONFIG_FAILED;
12154         }
12155
12156         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12157         changed =
12158                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12159         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12160 }
12161
12162 DEFUN (bgp_redistribute_ipv6_metric,
12163        bgp_redistribute_ipv6_metric_cmd,
12164        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295)",
12165        "Redistribute information from another routing protocol\n"
12166        FRR_IP6_REDIST_HELP_STR_BGPD
12167        "Metric for redistributed routes\n"
12168        "Default metric\n")
12169 {
12170         VTY_DECLVAR_CONTEXT(bgp, bgp);
12171         int idx_protocol = 1;
12172         int idx_number = 3;
12173         int type;
12174         uint32_t metric;
12175         struct bgp_redist *red;
12176         bool changed;
12177
12178         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12179         if (type < 0) {
12180                 vty_out(vty, "%% Invalid route type\n");
12181                 return CMD_WARNING_CONFIG_FAILED;
12182         }
12183         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12184
12185         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12186         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
12187         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12188 }
12189
12190 DEFUN (bgp_redistribute_ipv6_rmap_metric,
12191        bgp_redistribute_ipv6_rmap_metric_cmd,
12192        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
12193        "Redistribute information from another routing protocol\n"
12194        FRR_IP6_REDIST_HELP_STR_BGPD
12195        "Route map reference\n"
12196        "Pointer to route-map entries\n"
12197        "Metric for redistributed routes\n"
12198        "Default metric\n")
12199 {
12200         VTY_DECLVAR_CONTEXT(bgp, bgp);
12201         int idx_protocol = 1;
12202         int idx_word = 3;
12203         int idx_number = 5;
12204         int type;
12205         uint32_t metric;
12206         struct bgp_redist *red;
12207         bool changed;
12208         struct route_map *route_map =
12209                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12210
12211         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12212         if (type < 0) {
12213                 vty_out(vty, "%% Invalid route type\n");
12214                 return CMD_WARNING_CONFIG_FAILED;
12215         }
12216         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12217
12218         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12219         changed =
12220                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12221         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP6, type,
12222                                                 metric);
12223         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12224 }
12225
12226 DEFUN (bgp_redistribute_ipv6_metric_rmap,
12227        bgp_redistribute_ipv6_metric_rmap_cmd,
12228        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
12229        "Redistribute information from another routing protocol\n"
12230        FRR_IP6_REDIST_HELP_STR_BGPD
12231        "Metric for redistributed routes\n"
12232        "Default metric\n"
12233        "Route map reference\n"
12234        "Pointer to route-map entries\n")
12235 {
12236         VTY_DECLVAR_CONTEXT(bgp, bgp);
12237         int idx_protocol = 1;
12238         int idx_number = 3;
12239         int idx_word = 5;
12240         int type;
12241         uint32_t metric;
12242         struct bgp_redist *red;
12243         bool changed;
12244         struct route_map *route_map =
12245                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12246
12247         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12248         if (type < 0) {
12249                 vty_out(vty, "%% Invalid route type\n");
12250                 return CMD_WARNING_CONFIG_FAILED;
12251         }
12252         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12253
12254         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12255         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, SAFI_UNICAST,
12256                                                 metric);
12257         changed |=
12258                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12259         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12260 }
12261
12262 DEFUN (no_bgp_redistribute_ipv6,
12263        no_bgp_redistribute_ipv6_cmd,
12264        "no redistribute " FRR_IP6_REDIST_STR_BGPD " [metric (0-4294967295)] [route-map WORD]",
12265        NO_STR
12266        "Redistribute information from another routing protocol\n"
12267        FRR_IP6_REDIST_HELP_STR_BGPD
12268        "Metric for redistributed routes\n"
12269        "Default metric\n"
12270        "Route map reference\n"
12271        "Pointer to route-map entries\n")
12272 {
12273         VTY_DECLVAR_CONTEXT(bgp, bgp);
12274         int idx_protocol = 2;
12275         int type;
12276
12277         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12278         if (type < 0) {
12279                 vty_out(vty, "%% Invalid route type\n");
12280                 return CMD_WARNING_CONFIG_FAILED;
12281         }
12282
12283         return bgp_redistribute_unset(bgp, AFI_IP6, type, 0);
12284 }
12285
12286 void bgp_config_write_redistribute(struct vty *vty, struct bgp *bgp, afi_t afi,
12287                                    safi_t safi)
12288 {
12289         int i;
12290
12291         /* Unicast redistribution only.  */
12292         if (safi != SAFI_UNICAST)
12293                 return;
12294
12295         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
12296                 /* Redistribute BGP does not make sense.  */
12297                 if (i != ZEBRA_ROUTE_BGP) {
12298                         struct list *red_list;
12299                         struct listnode *node;
12300                         struct bgp_redist *red;
12301
12302                         red_list = bgp->redist[afi][i];
12303                         if (!red_list)
12304                                 continue;
12305
12306                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
12307                                 /* "redistribute" configuration.  */
12308                                 vty_out(vty, "  redistribute %s",
12309                                         zebra_route_string(i));
12310                                 if (red->instance)
12311                                         vty_out(vty, " %d", red->instance);
12312                                 if (red->redist_metric_flag)
12313                                         vty_out(vty, " metric %u",
12314                                                 red->redist_metric);
12315                                 if (red->rmap.name)
12316                                         vty_out(vty, " route-map %s",
12317                                                 red->rmap.name);
12318                                 vty_out(vty, "\n");
12319                         }
12320                 }
12321         }
12322 }
12323
12324 /* This is part of the address-family block (unicast only) */
12325 void bgp_vpn_policy_config_write_afi(struct vty *vty, struct bgp *bgp,
12326                                             afi_t afi)
12327 {
12328         int indent = 2;
12329
12330         if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_FROMVPN])
12331                 vty_out(vty, "%*simport vrf route-map %s\n", indent, "",
12332                         bgp->vpn_policy[afi]
12333                                 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
12334
12335         if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
12336                        BGP_CONFIG_VRF_TO_VRF_IMPORT)
12337             || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
12338                           BGP_CONFIG_VRF_TO_VRF_EXPORT))
12339                 return;
12340
12341         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12342                 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
12343
12344                 vty_out(vty, "%*slabel vpn export %s\n", indent, "", "auto");
12345
12346         } else {
12347                 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
12348                         vty_out(vty, "%*slabel vpn export %u\n", indent, "",
12349                                 bgp->vpn_policy[afi].tovpn_label);
12350                 }
12351         }
12352         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12353                        BGP_VPN_POLICY_TOVPN_RD_SET)) {
12354                 char buf[RD_ADDRSTRLEN];
12355                 vty_out(vty, "%*srd vpn export %s\n", indent, "",
12356                         prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd, buf,
12357                                       sizeof(buf)));
12358         }
12359         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12360                        BGP_VPN_POLICY_TOVPN_NEXTHOP_SET)) {
12361
12362                 char buf[PREFIX_STRLEN];
12363                 if (inet_ntop(bgp->vpn_policy[afi].tovpn_nexthop.family,
12364                               &bgp->vpn_policy[afi].tovpn_nexthop.u.prefix, buf,
12365                               sizeof(buf))) {
12366
12367                         vty_out(vty, "%*snexthop vpn export %s\n",
12368                                 indent, "", buf);
12369                 }
12370         }
12371         if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]
12372             && bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]
12373             && ecommunity_cmp(
12374                        bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
12375                        bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN])) {
12376
12377                 char *b = ecommunity_ecom2str(
12378                         bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN],
12379                         ECOMMUNITY_FORMAT_ROUTE_MAP, ECOMMUNITY_ROUTE_TARGET);
12380                 vty_out(vty, "%*srt vpn both %s\n", indent, "", b);
12381                 XFREE(MTYPE_ECOMMUNITY_STR, b);
12382         } else {
12383                 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]) {
12384                         char *b = ecommunity_ecom2str(
12385                                 bgp->vpn_policy[afi]
12386                                         .rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
12387                                 ECOMMUNITY_FORMAT_ROUTE_MAP,
12388                                 ECOMMUNITY_ROUTE_TARGET);
12389                         vty_out(vty, "%*srt vpn import %s\n", indent, "", b);
12390                         XFREE(MTYPE_ECOMMUNITY_STR, b);
12391                 }
12392                 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]) {
12393                         char *b = ecommunity_ecom2str(
12394                                 bgp->vpn_policy[afi]
12395                                         .rtlist[BGP_VPN_POLICY_DIR_TOVPN],
12396                                 ECOMMUNITY_FORMAT_ROUTE_MAP,
12397                                 ECOMMUNITY_ROUTE_TARGET);
12398                         vty_out(vty, "%*srt vpn export %s\n", indent, "", b);
12399                         XFREE(MTYPE_ECOMMUNITY_STR, b);
12400                 }
12401         }
12402
12403         if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_TOVPN])
12404                 vty_out(vty, "%*sroute-map vpn export %s\n", indent, "",
12405                         bgp->vpn_policy[afi]
12406                                 .rmap_name[BGP_VPN_POLICY_DIR_TOVPN]);
12407
12408         if (bgp->vpn_policy[afi].import_redirect_rtlist) {
12409                 char *b = ecommunity_ecom2str(
12410                                         bgp->vpn_policy[afi]
12411                                         .import_redirect_rtlist,
12412                                         ECOMMUNITY_FORMAT_ROUTE_MAP,
12413                                         ECOMMUNITY_ROUTE_TARGET);
12414
12415                 vty_out(vty, "%*srt redirect import %s\n", indent, "", b);
12416                 XFREE(MTYPE_ECOMMUNITY_STR, b);
12417         }
12418 }
12419
12420
12421 /* BGP node structure. */
12422 static struct cmd_node bgp_node = {
12423         BGP_NODE, "%s(config-router)# ", 1,
12424 };
12425
12426 static struct cmd_node bgp_ipv4_unicast_node = {
12427         BGP_IPV4_NODE, "%s(config-router-af)# ", 1,
12428 };
12429
12430 static struct cmd_node bgp_ipv4_multicast_node = {
12431         BGP_IPV4M_NODE, "%s(config-router-af)# ", 1,
12432 };
12433
12434 static struct cmd_node bgp_ipv4_labeled_unicast_node = {
12435         BGP_IPV4L_NODE, "%s(config-router-af)# ", 1,
12436 };
12437
12438 static struct cmd_node bgp_ipv6_unicast_node = {
12439         BGP_IPV6_NODE, "%s(config-router-af)# ", 1,
12440 };
12441
12442 static struct cmd_node bgp_ipv6_multicast_node = {
12443         BGP_IPV6M_NODE, "%s(config-router-af)# ", 1,
12444 };
12445
12446 static struct cmd_node bgp_ipv6_labeled_unicast_node = {
12447         BGP_IPV6L_NODE, "%s(config-router-af)# ", 1,
12448 };
12449
12450 static struct cmd_node bgp_vpnv4_node = {BGP_VPNV4_NODE,
12451                                          "%s(config-router-af)# ", 1};
12452
12453 static struct cmd_node bgp_vpnv6_node = {BGP_VPNV6_NODE,
12454                                          "%s(config-router-af-vpnv6)# ", 1};
12455
12456 static struct cmd_node bgp_evpn_node = {BGP_EVPN_NODE,
12457                                         "%s(config-router-evpn)# ", 1};
12458
12459 static struct cmd_node bgp_evpn_vni_node = {BGP_EVPN_VNI_NODE,
12460                                             "%s(config-router-af-vni)# ", 1};
12461
12462 static struct cmd_node bgp_flowspecv4_node = {BGP_FLOWSPECV4_NODE,
12463                                          "%s(config-router-af)# ", 1};
12464
12465 static struct cmd_node bgp_flowspecv6_node = {BGP_FLOWSPECV6_NODE,
12466                                          "%s(config-router-af-vpnv6)# ", 1};
12467
12468 static void community_list_vty(void);
12469
12470 static void bgp_ac_neighbor(vector comps, struct cmd_token *token)
12471 {
12472         struct bgp *bgp;
12473         struct peer *peer;
12474         struct listnode *lnbgp, *lnpeer;
12475
12476         for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
12477                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, lnpeer, peer)) {
12478                         /* only provide suggestions on the appropriate input
12479                          * token type,
12480                          * they'll otherwise show up multiple times */
12481                         enum cmd_token_type match_type;
12482                         char *name = peer->host;
12483
12484                         if (peer->conf_if) {
12485                                 match_type = VARIABLE_TKN;
12486                                 name = peer->conf_if;
12487                         } else if (strchr(peer->host, ':'))
12488                                 match_type = IPV6_TKN;
12489                         else
12490                                 match_type = IPV4_TKN;
12491
12492                         if (token->type != match_type)
12493                                 continue;
12494
12495                         vector_set(comps, XSTRDUP(MTYPE_COMPLETION, name));
12496                 }
12497         }
12498 }
12499
12500 static const struct cmd_variable_handler bgp_var_neighbor[] = {
12501         {.varname = "neighbor", .completions = bgp_ac_neighbor},
12502         {.varname = "neighbors", .completions = bgp_ac_neighbor},
12503         {.varname = "peer", .completions = bgp_ac_neighbor},
12504         {.completions = NULL}};
12505
12506 static void bgp_ac_peergroup(vector comps, struct cmd_token *token)
12507 {
12508         struct bgp *bgp;
12509         struct peer_group *group;
12510         struct listnode *lnbgp, *lnpeer;
12511
12512         for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
12513                 for (ALL_LIST_ELEMENTS_RO(bgp->group, lnpeer, group))
12514                         vector_set(comps, XSTRDUP(MTYPE_COMPLETION,
12515                                                   group->name));
12516         }
12517 }
12518
12519 static const struct cmd_variable_handler bgp_var_peergroup[] = {
12520         {.tokenname = "PGNAME", .completions = bgp_ac_peergroup},
12521         {.completions = NULL} };
12522
12523 void bgp_vty_init(void)
12524 {
12525         cmd_variable_handler_register(bgp_var_neighbor);
12526         cmd_variable_handler_register(bgp_var_peergroup);
12527
12528         /* Install bgp top node. */
12529         install_node(&bgp_node, bgp_config_write);
12530         install_node(&bgp_ipv4_unicast_node, NULL);
12531         install_node(&bgp_ipv4_multicast_node, NULL);
12532         install_node(&bgp_ipv4_labeled_unicast_node, NULL);
12533         install_node(&bgp_ipv6_unicast_node, NULL);
12534         install_node(&bgp_ipv6_multicast_node, NULL);
12535         install_node(&bgp_ipv6_labeled_unicast_node, NULL);
12536         install_node(&bgp_vpnv4_node, NULL);
12537         install_node(&bgp_vpnv6_node, NULL);
12538         install_node(&bgp_evpn_node, NULL);
12539         install_node(&bgp_evpn_vni_node, NULL);
12540         install_node(&bgp_flowspecv4_node, NULL);
12541         install_node(&bgp_flowspecv6_node, NULL);
12542
12543         /* Install default VTY commands to new nodes.  */
12544         install_default(BGP_NODE);
12545         install_default(BGP_IPV4_NODE);
12546         install_default(BGP_IPV4M_NODE);
12547         install_default(BGP_IPV4L_NODE);
12548         install_default(BGP_IPV6_NODE);
12549         install_default(BGP_IPV6M_NODE);
12550         install_default(BGP_IPV6L_NODE);
12551         install_default(BGP_VPNV4_NODE);
12552         install_default(BGP_VPNV6_NODE);
12553         install_default(BGP_FLOWSPECV4_NODE);
12554         install_default(BGP_FLOWSPECV6_NODE);
12555         install_default(BGP_EVPN_NODE);
12556         install_default(BGP_EVPN_VNI_NODE);
12557
12558         /* "bgp multiple-instance" commands. */
12559         install_element(CONFIG_NODE, &bgp_multiple_instance_cmd);
12560         install_element(CONFIG_NODE, &no_bgp_multiple_instance_cmd);
12561
12562         /* "bgp config-type" commands. */
12563         install_element(CONFIG_NODE, &bgp_config_type_cmd);
12564         install_element(CONFIG_NODE, &no_bgp_config_type_cmd);
12565
12566         /* bgp route-map delay-timer commands. */
12567         install_element(CONFIG_NODE, &bgp_set_route_map_delay_timer_cmd);
12568         install_element(CONFIG_NODE, &no_bgp_set_route_map_delay_timer_cmd);
12569
12570         /* Dummy commands (Currently not supported) */
12571         install_element(BGP_NODE, &no_synchronization_cmd);
12572         install_element(BGP_NODE, &no_auto_summary_cmd);
12573
12574         /* "router bgp" commands. */
12575         install_element(CONFIG_NODE, &router_bgp_cmd);
12576
12577         /* "no router bgp" commands. */
12578         install_element(CONFIG_NODE, &no_router_bgp_cmd);
12579
12580         /* "bgp router-id" commands. */
12581         install_element(BGP_NODE, &bgp_router_id_cmd);
12582         install_element(BGP_NODE, &no_bgp_router_id_cmd);
12583
12584         /* "bgp cluster-id" commands. */
12585         install_element(BGP_NODE, &bgp_cluster_id_cmd);
12586         install_element(BGP_NODE, &no_bgp_cluster_id_cmd);
12587
12588         /* "bgp confederation" commands. */
12589         install_element(BGP_NODE, &bgp_confederation_identifier_cmd);
12590         install_element(BGP_NODE, &no_bgp_confederation_identifier_cmd);
12591
12592         /* "bgp confederation peers" commands. */
12593         install_element(BGP_NODE, &bgp_confederation_peers_cmd);
12594         install_element(BGP_NODE, &no_bgp_confederation_peers_cmd);
12595
12596         /* bgp max-med command */
12597         install_element(BGP_NODE, &bgp_maxmed_admin_cmd);
12598         install_element(BGP_NODE, &no_bgp_maxmed_admin_cmd);
12599         install_element(BGP_NODE, &bgp_maxmed_admin_medv_cmd);
12600         install_element(BGP_NODE, &bgp_maxmed_onstartup_cmd);
12601         install_element(BGP_NODE, &no_bgp_maxmed_onstartup_cmd);
12602
12603         /* bgp disable-ebgp-connected-nh-check */
12604         install_element(BGP_NODE, &bgp_disable_connected_route_check_cmd);
12605         install_element(BGP_NODE, &no_bgp_disable_connected_route_check_cmd);
12606
12607         /* bgp update-delay command */
12608         install_element(BGP_NODE, &bgp_update_delay_cmd);
12609         install_element(BGP_NODE, &no_bgp_update_delay_cmd);
12610         install_element(BGP_NODE, &bgp_update_delay_establish_wait_cmd);
12611
12612         install_element(BGP_NODE, &bgp_wpkt_quanta_cmd);
12613         install_element(BGP_NODE, &no_bgp_wpkt_quanta_cmd);
12614         install_element(BGP_NODE, &bgp_rpkt_quanta_cmd);
12615         install_element(BGP_NODE, &no_bgp_rpkt_quanta_cmd);
12616
12617         install_element(BGP_NODE, &bgp_coalesce_time_cmd);
12618         install_element(BGP_NODE, &no_bgp_coalesce_time_cmd);
12619
12620         /* "maximum-paths" commands. */
12621         install_element(BGP_NODE, &bgp_maxpaths_hidden_cmd);
12622         install_element(BGP_NODE, &no_bgp_maxpaths_hidden_cmd);
12623         install_element(BGP_IPV4_NODE, &bgp_maxpaths_cmd);
12624         install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_cmd);
12625         install_element(BGP_IPV6_NODE, &bgp_maxpaths_cmd);
12626         install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_cmd);
12627         install_element(BGP_NODE, &bgp_maxpaths_ibgp_hidden_cmd);
12628         install_element(BGP_NODE, &bgp_maxpaths_ibgp_cluster_hidden_cmd);
12629         install_element(BGP_NODE, &no_bgp_maxpaths_ibgp_hidden_cmd);
12630         install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cmd);
12631         install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12632         install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_ibgp_cmd);
12633         install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cmd);
12634         install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12635         install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_ibgp_cmd);
12636
12637         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_cmd);
12638         install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_cmd);
12639         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cmd);
12640         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12641         install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_ibgp_cmd);
12642
12643         /* "timers bgp" commands. */
12644         install_element(BGP_NODE, &bgp_timers_cmd);
12645         install_element(BGP_NODE, &no_bgp_timers_cmd);
12646
12647         /* route-map delay-timer commands - per instance for backwards compat.
12648          */
12649         install_element(BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
12650         install_element(BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
12651
12652         /* "bgp client-to-client reflection" commands */
12653         install_element(BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
12654         install_element(BGP_NODE, &bgp_client_to_client_reflection_cmd);
12655
12656         /* "bgp always-compare-med" commands */
12657         install_element(BGP_NODE, &bgp_always_compare_med_cmd);
12658         install_element(BGP_NODE, &no_bgp_always_compare_med_cmd);
12659
12660         /* "bgp deterministic-med" commands */
12661         install_element(BGP_NODE, &bgp_deterministic_med_cmd);
12662         install_element(BGP_NODE, &no_bgp_deterministic_med_cmd);
12663
12664         /* "bgp graceful-restart" commands */
12665         install_element(BGP_NODE, &bgp_graceful_restart_cmd);
12666         install_element(BGP_NODE, &no_bgp_graceful_restart_cmd);
12667         install_element(BGP_NODE, &bgp_graceful_restart_stalepath_time_cmd);
12668         install_element(BGP_NODE, &no_bgp_graceful_restart_stalepath_time_cmd);
12669         install_element(BGP_NODE, &bgp_graceful_restart_restart_time_cmd);
12670         install_element(BGP_NODE, &no_bgp_graceful_restart_restart_time_cmd);
12671
12672         install_element(BGP_NODE, &bgp_graceful_restart_preserve_fw_cmd);
12673         install_element(BGP_NODE, &no_bgp_graceful_restart_preserve_fw_cmd);
12674
12675         /* "bgp graceful-shutdown" commands */
12676         install_element(BGP_NODE, &bgp_graceful_shutdown_cmd);
12677         install_element(BGP_NODE, &no_bgp_graceful_shutdown_cmd);
12678
12679         /* "bgp fast-external-failover" commands */
12680         install_element(BGP_NODE, &bgp_fast_external_failover_cmd);
12681         install_element(BGP_NODE, &no_bgp_fast_external_failover_cmd);
12682
12683         /* "bgp enforce-first-as" commands */
12684         install_element(BGP_NODE, &bgp_enforce_first_as_cmd);
12685
12686         /* "bgp bestpath compare-routerid" commands */
12687         install_element(BGP_NODE, &bgp_bestpath_compare_router_id_cmd);
12688         install_element(BGP_NODE, &no_bgp_bestpath_compare_router_id_cmd);
12689
12690         /* "bgp bestpath as-path ignore" commands */
12691         install_element(BGP_NODE, &bgp_bestpath_aspath_ignore_cmd);
12692         install_element(BGP_NODE, &no_bgp_bestpath_aspath_ignore_cmd);
12693
12694         /* "bgp bestpath as-path confed" commands */
12695         install_element(BGP_NODE, &bgp_bestpath_aspath_confed_cmd);
12696         install_element(BGP_NODE, &no_bgp_bestpath_aspath_confed_cmd);
12697
12698         /* "bgp bestpath as-path multipath-relax" commands */
12699         install_element(BGP_NODE, &bgp_bestpath_aspath_multipath_relax_cmd);
12700         install_element(BGP_NODE, &no_bgp_bestpath_aspath_multipath_relax_cmd);
12701
12702         /* "bgp log-neighbor-changes" commands */
12703         install_element(BGP_NODE, &bgp_log_neighbor_changes_cmd);
12704         install_element(BGP_NODE, &no_bgp_log_neighbor_changes_cmd);
12705
12706         /* "bgp bestpath med" commands */
12707         install_element(BGP_NODE, &bgp_bestpath_med_cmd);
12708         install_element(BGP_NODE, &no_bgp_bestpath_med_cmd);
12709
12710         /* "no bgp default ipv4-unicast" commands. */
12711         install_element(BGP_NODE, &no_bgp_default_ipv4_unicast_cmd);
12712         install_element(BGP_NODE, &bgp_default_ipv4_unicast_cmd);
12713
12714         /* "bgp network import-check" commands. */
12715         install_element(BGP_NODE, &bgp_network_import_check_cmd);
12716         install_element(BGP_NODE, &bgp_network_import_check_exact_cmd);
12717         install_element(BGP_NODE, &no_bgp_network_import_check_cmd);
12718
12719         /* "bgp default local-preference" commands. */
12720         install_element(BGP_NODE, &bgp_default_local_preference_cmd);
12721         install_element(BGP_NODE, &no_bgp_default_local_preference_cmd);
12722
12723         /* bgp default show-hostname */
12724         install_element(BGP_NODE, &bgp_default_show_hostname_cmd);
12725         install_element(BGP_NODE, &no_bgp_default_show_hostname_cmd);
12726
12727         /* "bgp default subgroup-pkt-queue-max" commands. */
12728         install_element(BGP_NODE, &bgp_default_subgroup_pkt_queue_max_cmd);
12729         install_element(BGP_NODE, &no_bgp_default_subgroup_pkt_queue_max_cmd);
12730
12731         /* bgp ibgp-allow-policy-mods command */
12732         install_element(BGP_NODE, &bgp_rr_allow_outbound_policy_cmd);
12733         install_element(BGP_NODE, &no_bgp_rr_allow_outbound_policy_cmd);
12734
12735         /* "bgp listen limit" commands. */
12736         install_element(BGP_NODE, &bgp_listen_limit_cmd);
12737         install_element(BGP_NODE, &no_bgp_listen_limit_cmd);
12738
12739         /* "bgp listen range" commands. */
12740         install_element(BGP_NODE, &bgp_listen_range_cmd);
12741         install_element(BGP_NODE, &no_bgp_listen_range_cmd);
12742
12743         /* "bgp default shutdown" command */
12744         install_element(BGP_NODE, &bgp_default_shutdown_cmd);
12745
12746         /* "neighbor remote-as" commands. */
12747         install_element(BGP_NODE, &neighbor_remote_as_cmd);
12748         install_element(BGP_NODE, &neighbor_interface_config_cmd);
12749         install_element(BGP_NODE, &neighbor_interface_config_v6only_cmd);
12750         install_element(BGP_NODE, &neighbor_interface_config_remote_as_cmd);
12751         install_element(BGP_NODE,
12752                         &neighbor_interface_v6only_config_remote_as_cmd);
12753         install_element(BGP_NODE, &no_neighbor_cmd);
12754         install_element(BGP_NODE, &no_neighbor_interface_config_cmd);
12755
12756         /* "neighbor peer-group" commands. */
12757         install_element(BGP_NODE, &neighbor_peer_group_cmd);
12758         install_element(BGP_NODE, &no_neighbor_peer_group_cmd);
12759         install_element(BGP_NODE,
12760                         &no_neighbor_interface_peer_group_remote_as_cmd);
12761
12762         /* "neighbor local-as" commands. */
12763         install_element(BGP_NODE, &neighbor_local_as_cmd);
12764         install_element(BGP_NODE, &neighbor_local_as_no_prepend_cmd);
12765         install_element(BGP_NODE, &neighbor_local_as_no_prepend_replace_as_cmd);
12766         install_element(BGP_NODE, &no_neighbor_local_as_cmd);
12767
12768         /* "neighbor solo" commands. */
12769         install_element(BGP_NODE, &neighbor_solo_cmd);
12770         install_element(BGP_NODE, &no_neighbor_solo_cmd);
12771
12772         /* "neighbor password" commands. */
12773         install_element(BGP_NODE, &neighbor_password_cmd);
12774         install_element(BGP_NODE, &no_neighbor_password_cmd);
12775
12776         /* "neighbor activate" commands. */
12777         install_element(BGP_NODE, &neighbor_activate_hidden_cmd);
12778         install_element(BGP_IPV4_NODE, &neighbor_activate_cmd);
12779         install_element(BGP_IPV4M_NODE, &neighbor_activate_cmd);
12780         install_element(BGP_IPV4L_NODE, &neighbor_activate_cmd);
12781         install_element(BGP_IPV6_NODE, &neighbor_activate_cmd);
12782         install_element(BGP_IPV6M_NODE, &neighbor_activate_cmd);
12783         install_element(BGP_IPV6L_NODE, &neighbor_activate_cmd);
12784         install_element(BGP_VPNV4_NODE, &neighbor_activate_cmd);
12785         install_element(BGP_VPNV6_NODE, &neighbor_activate_cmd);
12786         install_element(BGP_FLOWSPECV4_NODE, &neighbor_activate_cmd);
12787         install_element(BGP_FLOWSPECV6_NODE, &neighbor_activate_cmd);
12788         install_element(BGP_EVPN_NODE, &neighbor_activate_cmd);
12789
12790         /* "no neighbor activate" commands. */
12791         install_element(BGP_NODE, &no_neighbor_activate_hidden_cmd);
12792         install_element(BGP_IPV4_NODE, &no_neighbor_activate_cmd);
12793         install_element(BGP_IPV4M_NODE, &no_neighbor_activate_cmd);
12794         install_element(BGP_IPV4L_NODE, &no_neighbor_activate_cmd);
12795         install_element(BGP_IPV6_NODE, &no_neighbor_activate_cmd);
12796         install_element(BGP_IPV6M_NODE, &no_neighbor_activate_cmd);
12797         install_element(BGP_IPV6L_NODE, &no_neighbor_activate_cmd);
12798         install_element(BGP_VPNV4_NODE, &no_neighbor_activate_cmd);
12799         install_element(BGP_VPNV6_NODE, &no_neighbor_activate_cmd);
12800         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_activate_cmd);
12801         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_activate_cmd);
12802         install_element(BGP_EVPN_NODE, &no_neighbor_activate_cmd);
12803
12804         /* "neighbor peer-group" set commands. */
12805         install_element(BGP_NODE, &neighbor_set_peer_group_cmd);
12806         install_element(BGP_IPV4_NODE, &neighbor_set_peer_group_hidden_cmd);
12807         install_element(BGP_IPV4M_NODE, &neighbor_set_peer_group_hidden_cmd);
12808         install_element(BGP_IPV6_NODE, &neighbor_set_peer_group_hidden_cmd);
12809         install_element(BGP_IPV6M_NODE, &neighbor_set_peer_group_hidden_cmd);
12810         install_element(BGP_IPV6L_NODE, &neighbor_set_peer_group_hidden_cmd);
12811         install_element(BGP_VPNV4_NODE, &neighbor_set_peer_group_hidden_cmd);
12812         install_element(BGP_VPNV6_NODE, &neighbor_set_peer_group_hidden_cmd);
12813         install_element(BGP_FLOWSPECV4_NODE,
12814                         &neighbor_set_peer_group_hidden_cmd);
12815         install_element(BGP_FLOWSPECV6_NODE,
12816                         &neighbor_set_peer_group_hidden_cmd);
12817
12818         /* "no neighbor peer-group unset" commands. */
12819         install_element(BGP_NODE, &no_neighbor_set_peer_group_cmd);
12820         install_element(BGP_IPV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12821         install_element(BGP_IPV4M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12822         install_element(BGP_IPV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12823         install_element(BGP_IPV6M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12824         install_element(BGP_IPV6L_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12825         install_element(BGP_VPNV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12826         install_element(BGP_VPNV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
12827         install_element(BGP_FLOWSPECV4_NODE,
12828                         &no_neighbor_set_peer_group_hidden_cmd);
12829         install_element(BGP_FLOWSPECV6_NODE,
12830                         &no_neighbor_set_peer_group_hidden_cmd);
12831
12832         /* "neighbor softreconfiguration inbound" commands.*/
12833         install_element(BGP_NODE, &neighbor_soft_reconfiguration_hidden_cmd);
12834         install_element(BGP_NODE, &no_neighbor_soft_reconfiguration_hidden_cmd);
12835         install_element(BGP_IPV4_NODE, &neighbor_soft_reconfiguration_cmd);
12836         install_element(BGP_IPV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
12837         install_element(BGP_IPV4L_NODE, &neighbor_soft_reconfiguration_cmd);
12838         install_element(BGP_IPV4L_NODE, &no_neighbor_soft_reconfiguration_cmd);
12839         install_element(BGP_IPV4M_NODE, &neighbor_soft_reconfiguration_cmd);
12840         install_element(BGP_IPV4M_NODE, &no_neighbor_soft_reconfiguration_cmd);
12841         install_element(BGP_IPV6_NODE, &neighbor_soft_reconfiguration_cmd);
12842         install_element(BGP_IPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
12843         install_element(BGP_IPV6M_NODE, &neighbor_soft_reconfiguration_cmd);
12844         install_element(BGP_IPV6M_NODE, &no_neighbor_soft_reconfiguration_cmd);
12845         install_element(BGP_IPV6L_NODE, &neighbor_soft_reconfiguration_cmd);
12846         install_element(BGP_IPV6L_NODE, &no_neighbor_soft_reconfiguration_cmd);
12847         install_element(BGP_VPNV4_NODE, &neighbor_soft_reconfiguration_cmd);
12848         install_element(BGP_VPNV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
12849         install_element(BGP_VPNV6_NODE, &neighbor_soft_reconfiguration_cmd);
12850         install_element(BGP_VPNV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
12851         install_element(BGP_FLOWSPECV4_NODE,
12852                         &neighbor_soft_reconfiguration_cmd);
12853         install_element(BGP_FLOWSPECV4_NODE,
12854                         &no_neighbor_soft_reconfiguration_cmd);
12855         install_element(BGP_FLOWSPECV6_NODE,
12856                         &neighbor_soft_reconfiguration_cmd);
12857         install_element(BGP_FLOWSPECV6_NODE,
12858                         &no_neighbor_soft_reconfiguration_cmd);
12859
12860         /* "neighbor attribute-unchanged" commands.  */
12861         install_element(BGP_NODE, &neighbor_attr_unchanged_hidden_cmd);
12862         install_element(BGP_NODE, &no_neighbor_attr_unchanged_hidden_cmd);
12863         install_element(BGP_IPV4_NODE, &neighbor_attr_unchanged_cmd);
12864         install_element(BGP_IPV4_NODE, &no_neighbor_attr_unchanged_cmd);
12865         install_element(BGP_IPV4M_NODE, &neighbor_attr_unchanged_cmd);
12866         install_element(BGP_IPV4M_NODE, &no_neighbor_attr_unchanged_cmd);
12867         install_element(BGP_IPV4L_NODE, &neighbor_attr_unchanged_cmd);
12868         install_element(BGP_IPV4L_NODE, &no_neighbor_attr_unchanged_cmd);
12869         install_element(BGP_IPV6_NODE, &neighbor_attr_unchanged_cmd);
12870         install_element(BGP_IPV6_NODE, &no_neighbor_attr_unchanged_cmd);
12871         install_element(BGP_IPV6M_NODE, &neighbor_attr_unchanged_cmd);
12872         install_element(BGP_IPV6M_NODE, &no_neighbor_attr_unchanged_cmd);
12873         install_element(BGP_IPV6L_NODE, &neighbor_attr_unchanged_cmd);
12874         install_element(BGP_IPV6L_NODE, &no_neighbor_attr_unchanged_cmd);
12875         install_element(BGP_VPNV4_NODE, &neighbor_attr_unchanged_cmd);
12876         install_element(BGP_VPNV4_NODE, &no_neighbor_attr_unchanged_cmd);
12877         install_element(BGP_VPNV6_NODE, &neighbor_attr_unchanged_cmd);
12878         install_element(BGP_VPNV6_NODE, &no_neighbor_attr_unchanged_cmd);
12879
12880         install_element(BGP_EVPN_NODE, &neighbor_attr_unchanged_cmd);
12881         install_element(BGP_EVPN_NODE, &no_neighbor_attr_unchanged_cmd);
12882
12883         /* "nexthop-local unchanged" commands */
12884         install_element(BGP_IPV6_NODE, &neighbor_nexthop_local_unchanged_cmd);
12885         install_element(BGP_IPV6_NODE,
12886                         &no_neighbor_nexthop_local_unchanged_cmd);
12887
12888         /* "neighbor next-hop-self" commands. */
12889         install_element(BGP_NODE, &neighbor_nexthop_self_hidden_cmd);
12890         install_element(BGP_NODE, &no_neighbor_nexthop_self_hidden_cmd);
12891         install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_cmd);
12892         install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_cmd);
12893         install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_cmd);
12894         install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_cmd);
12895         install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_cmd);
12896         install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_cmd);
12897         install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_cmd);
12898         install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_cmd);
12899         install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_cmd);
12900         install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_cmd);
12901         install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_cmd);
12902         install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_cmd);
12903         install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_cmd);
12904         install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_cmd);
12905         install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_cmd);
12906         install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_cmd);
12907         install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_cmd);
12908         install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_cmd);
12909
12910         /* "neighbor next-hop-self force" commands. */
12911         install_element(BGP_NODE, &neighbor_nexthop_self_force_hidden_cmd);
12912         install_element(BGP_NODE, &no_neighbor_nexthop_self_force_hidden_cmd);
12913         install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_force_cmd);
12914         install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_force_cmd);
12915         install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_force_cmd);
12916         install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_force_cmd);
12917         install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_force_cmd);
12918         install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_force_cmd);
12919         install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_force_cmd);
12920         install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_force_cmd);
12921         install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_force_cmd);
12922         install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_force_cmd);
12923         install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_force_cmd);
12924         install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_force_cmd);
12925         install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_force_cmd);
12926         install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_force_cmd);
12927         install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_force_cmd);
12928         install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_force_cmd);
12929
12930         /* "neighbor as-override" commands. */
12931         install_element(BGP_NODE, &neighbor_as_override_hidden_cmd);
12932         install_element(BGP_NODE, &no_neighbor_as_override_hidden_cmd);
12933         install_element(BGP_IPV4_NODE, &neighbor_as_override_cmd);
12934         install_element(BGP_IPV4_NODE, &no_neighbor_as_override_cmd);
12935         install_element(BGP_IPV4M_NODE, &neighbor_as_override_cmd);
12936         install_element(BGP_IPV4M_NODE, &no_neighbor_as_override_cmd);
12937         install_element(BGP_IPV4L_NODE, &neighbor_as_override_cmd);
12938         install_element(BGP_IPV4L_NODE, &no_neighbor_as_override_cmd);
12939         install_element(BGP_IPV6_NODE, &neighbor_as_override_cmd);
12940         install_element(BGP_IPV6_NODE, &no_neighbor_as_override_cmd);
12941         install_element(BGP_IPV6M_NODE, &neighbor_as_override_cmd);
12942         install_element(BGP_IPV6M_NODE, &no_neighbor_as_override_cmd);
12943         install_element(BGP_IPV6L_NODE, &neighbor_as_override_cmd);
12944         install_element(BGP_IPV6L_NODE, &no_neighbor_as_override_cmd);
12945         install_element(BGP_VPNV4_NODE, &neighbor_as_override_cmd);
12946         install_element(BGP_VPNV4_NODE, &no_neighbor_as_override_cmd);
12947         install_element(BGP_VPNV6_NODE, &neighbor_as_override_cmd);
12948         install_element(BGP_VPNV6_NODE, &no_neighbor_as_override_cmd);
12949
12950         /* "neighbor remove-private-AS" commands. */
12951         install_element(BGP_NODE, &neighbor_remove_private_as_hidden_cmd);
12952         install_element(BGP_NODE, &no_neighbor_remove_private_as_hidden_cmd);
12953         install_element(BGP_NODE, &neighbor_remove_private_as_all_hidden_cmd);
12954         install_element(BGP_NODE,
12955                         &no_neighbor_remove_private_as_all_hidden_cmd);
12956         install_element(BGP_NODE,
12957                         &neighbor_remove_private_as_replace_as_hidden_cmd);
12958         install_element(BGP_NODE,
12959                         &no_neighbor_remove_private_as_replace_as_hidden_cmd);
12960         install_element(BGP_NODE,
12961                         &neighbor_remove_private_as_all_replace_as_hidden_cmd);
12962         install_element(
12963                 BGP_NODE,
12964                 &no_neighbor_remove_private_as_all_replace_as_hidden_cmd);
12965         install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_cmd);
12966         install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_cmd);
12967         install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_all_cmd);
12968         install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_cmd);
12969         install_element(BGP_IPV4_NODE,
12970                         &neighbor_remove_private_as_replace_as_cmd);
12971         install_element(BGP_IPV4_NODE,
12972                         &no_neighbor_remove_private_as_replace_as_cmd);
12973         install_element(BGP_IPV4_NODE,
12974                         &neighbor_remove_private_as_all_replace_as_cmd);
12975         install_element(BGP_IPV4_NODE,
12976                         &no_neighbor_remove_private_as_all_replace_as_cmd);
12977         install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_cmd);
12978         install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_cmd);
12979         install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_all_cmd);
12980         install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_cmd);
12981         install_element(BGP_IPV4M_NODE,
12982                         &neighbor_remove_private_as_replace_as_cmd);
12983         install_element(BGP_IPV4M_NODE,
12984                         &no_neighbor_remove_private_as_replace_as_cmd);
12985         install_element(BGP_IPV4M_NODE,
12986                         &neighbor_remove_private_as_all_replace_as_cmd);
12987         install_element(BGP_IPV4M_NODE,
12988                         &no_neighbor_remove_private_as_all_replace_as_cmd);
12989         install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_cmd);
12990         install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_cmd);
12991         install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_all_cmd);
12992         install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_all_cmd);
12993         install_element(BGP_IPV4L_NODE,
12994                         &neighbor_remove_private_as_replace_as_cmd);
12995         install_element(BGP_IPV4L_NODE,
12996                         &no_neighbor_remove_private_as_replace_as_cmd);
12997         install_element(BGP_IPV4L_NODE,
12998                         &neighbor_remove_private_as_all_replace_as_cmd);
12999         install_element(BGP_IPV4L_NODE,
13000                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13001         install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_cmd);
13002         install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_cmd);
13003         install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_all_cmd);
13004         install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_cmd);
13005         install_element(BGP_IPV6_NODE,
13006                         &neighbor_remove_private_as_replace_as_cmd);
13007         install_element(BGP_IPV6_NODE,
13008                         &no_neighbor_remove_private_as_replace_as_cmd);
13009         install_element(BGP_IPV6_NODE,
13010                         &neighbor_remove_private_as_all_replace_as_cmd);
13011         install_element(BGP_IPV6_NODE,
13012                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13013         install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_cmd);
13014         install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_cmd);
13015         install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_all_cmd);
13016         install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_cmd);
13017         install_element(BGP_IPV6M_NODE,
13018                         &neighbor_remove_private_as_replace_as_cmd);
13019         install_element(BGP_IPV6M_NODE,
13020                         &no_neighbor_remove_private_as_replace_as_cmd);
13021         install_element(BGP_IPV6M_NODE,
13022                         &neighbor_remove_private_as_all_replace_as_cmd);
13023         install_element(BGP_IPV6M_NODE,
13024                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13025         install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_cmd);
13026         install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_cmd);
13027         install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_all_cmd);
13028         install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_all_cmd);
13029         install_element(BGP_IPV6L_NODE,
13030                         &neighbor_remove_private_as_replace_as_cmd);
13031         install_element(BGP_IPV6L_NODE,
13032                         &no_neighbor_remove_private_as_replace_as_cmd);
13033         install_element(BGP_IPV6L_NODE,
13034                         &neighbor_remove_private_as_all_replace_as_cmd);
13035         install_element(BGP_IPV6L_NODE,
13036                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13037         install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_cmd);
13038         install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_cmd);
13039         install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_all_cmd);
13040         install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_cmd);
13041         install_element(BGP_VPNV4_NODE,
13042                         &neighbor_remove_private_as_replace_as_cmd);
13043         install_element(BGP_VPNV4_NODE,
13044                         &no_neighbor_remove_private_as_replace_as_cmd);
13045         install_element(BGP_VPNV4_NODE,
13046                         &neighbor_remove_private_as_all_replace_as_cmd);
13047         install_element(BGP_VPNV4_NODE,
13048                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13049         install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_cmd);
13050         install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_cmd);
13051         install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_all_cmd);
13052         install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_cmd);
13053         install_element(BGP_VPNV6_NODE,
13054                         &neighbor_remove_private_as_replace_as_cmd);
13055         install_element(BGP_VPNV6_NODE,
13056                         &no_neighbor_remove_private_as_replace_as_cmd);
13057         install_element(BGP_VPNV6_NODE,
13058                         &neighbor_remove_private_as_all_replace_as_cmd);
13059         install_element(BGP_VPNV6_NODE,
13060                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13061
13062         /* "neighbor send-community" commands.*/
13063         install_element(BGP_NODE, &neighbor_send_community_hidden_cmd);
13064         install_element(BGP_NODE, &neighbor_send_community_type_hidden_cmd);
13065         install_element(BGP_NODE, &no_neighbor_send_community_hidden_cmd);
13066         install_element(BGP_NODE, &no_neighbor_send_community_type_hidden_cmd);
13067         install_element(BGP_IPV4_NODE, &neighbor_send_community_cmd);
13068         install_element(BGP_IPV4_NODE, &neighbor_send_community_type_cmd);
13069         install_element(BGP_IPV4_NODE, &no_neighbor_send_community_cmd);
13070         install_element(BGP_IPV4_NODE, &no_neighbor_send_community_type_cmd);
13071         install_element(BGP_IPV4M_NODE, &neighbor_send_community_cmd);
13072         install_element(BGP_IPV4M_NODE, &neighbor_send_community_type_cmd);
13073         install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_cmd);
13074         install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_type_cmd);
13075         install_element(BGP_IPV4L_NODE, &neighbor_send_community_cmd);
13076         install_element(BGP_IPV4L_NODE, &neighbor_send_community_type_cmd);
13077         install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_cmd);
13078         install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_type_cmd);
13079         install_element(BGP_IPV6_NODE, &neighbor_send_community_cmd);
13080         install_element(BGP_IPV6_NODE, &neighbor_send_community_type_cmd);
13081         install_element(BGP_IPV6_NODE, &no_neighbor_send_community_cmd);
13082         install_element(BGP_IPV6_NODE, &no_neighbor_send_community_type_cmd);
13083         install_element(BGP_IPV6M_NODE, &neighbor_send_community_cmd);
13084         install_element(BGP_IPV6M_NODE, &neighbor_send_community_type_cmd);
13085         install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_cmd);
13086         install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_type_cmd);
13087         install_element(BGP_IPV6L_NODE, &neighbor_send_community_cmd);
13088         install_element(BGP_IPV6L_NODE, &neighbor_send_community_type_cmd);
13089         install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_cmd);
13090         install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_type_cmd);
13091         install_element(BGP_VPNV4_NODE, &neighbor_send_community_cmd);
13092         install_element(BGP_VPNV4_NODE, &neighbor_send_community_type_cmd);
13093         install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_cmd);
13094         install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_type_cmd);
13095         install_element(BGP_VPNV6_NODE, &neighbor_send_community_cmd);
13096         install_element(BGP_VPNV6_NODE, &neighbor_send_community_type_cmd);
13097         install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_cmd);
13098         install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_type_cmd);
13099
13100         /* "neighbor route-reflector" commands.*/
13101         install_element(BGP_NODE, &neighbor_route_reflector_client_hidden_cmd);
13102         install_element(BGP_NODE,
13103                         &no_neighbor_route_reflector_client_hidden_cmd);
13104         install_element(BGP_IPV4_NODE, &neighbor_route_reflector_client_cmd);
13105         install_element(BGP_IPV4_NODE, &no_neighbor_route_reflector_client_cmd);
13106         install_element(BGP_IPV4M_NODE, &neighbor_route_reflector_client_cmd);
13107         install_element(BGP_IPV4M_NODE,
13108                         &no_neighbor_route_reflector_client_cmd);
13109         install_element(BGP_IPV4L_NODE, &neighbor_route_reflector_client_cmd);
13110         install_element(BGP_IPV4L_NODE,
13111                         &no_neighbor_route_reflector_client_cmd);
13112         install_element(BGP_IPV6_NODE, &neighbor_route_reflector_client_cmd);
13113         install_element(BGP_IPV6_NODE, &no_neighbor_route_reflector_client_cmd);
13114         install_element(BGP_IPV6M_NODE, &neighbor_route_reflector_client_cmd);
13115         install_element(BGP_IPV6M_NODE,
13116                         &no_neighbor_route_reflector_client_cmd);
13117         install_element(BGP_IPV6L_NODE, &neighbor_route_reflector_client_cmd);
13118         install_element(BGP_IPV6L_NODE,
13119                         &no_neighbor_route_reflector_client_cmd);
13120         install_element(BGP_VPNV4_NODE, &neighbor_route_reflector_client_cmd);
13121         install_element(BGP_VPNV4_NODE,
13122                         &no_neighbor_route_reflector_client_cmd);
13123         install_element(BGP_VPNV6_NODE, &neighbor_route_reflector_client_cmd);
13124         install_element(BGP_VPNV6_NODE,
13125                         &no_neighbor_route_reflector_client_cmd);
13126         install_element(BGP_FLOWSPECV4_NODE,
13127                         &neighbor_route_reflector_client_cmd);
13128         install_element(BGP_FLOWSPECV4_NODE,
13129                         &no_neighbor_route_reflector_client_cmd);
13130         install_element(BGP_FLOWSPECV6_NODE,
13131                         &neighbor_route_reflector_client_cmd);
13132         install_element(BGP_FLOWSPECV6_NODE,
13133                         &no_neighbor_route_reflector_client_cmd);
13134         install_element(BGP_EVPN_NODE, &neighbor_route_reflector_client_cmd);
13135         install_element(BGP_EVPN_NODE, &no_neighbor_route_reflector_client_cmd);
13136
13137         /* "neighbor route-server" commands.*/
13138         install_element(BGP_NODE, &neighbor_route_server_client_hidden_cmd);
13139         install_element(BGP_NODE, &no_neighbor_route_server_client_hidden_cmd);
13140         install_element(BGP_IPV4_NODE, &neighbor_route_server_client_cmd);
13141         install_element(BGP_IPV4_NODE, &no_neighbor_route_server_client_cmd);
13142         install_element(BGP_IPV4M_NODE, &neighbor_route_server_client_cmd);
13143         install_element(BGP_IPV4M_NODE, &no_neighbor_route_server_client_cmd);
13144         install_element(BGP_IPV4L_NODE, &neighbor_route_server_client_cmd);
13145         install_element(BGP_IPV4L_NODE, &no_neighbor_route_server_client_cmd);
13146         install_element(BGP_IPV6_NODE, &neighbor_route_server_client_cmd);
13147         install_element(BGP_IPV6_NODE, &no_neighbor_route_server_client_cmd);
13148         install_element(BGP_IPV6M_NODE, &neighbor_route_server_client_cmd);
13149         install_element(BGP_IPV6M_NODE, &no_neighbor_route_server_client_cmd);
13150         install_element(BGP_IPV6L_NODE, &neighbor_route_server_client_cmd);
13151         install_element(BGP_IPV6L_NODE, &no_neighbor_route_server_client_cmd);
13152         install_element(BGP_VPNV4_NODE, &neighbor_route_server_client_cmd);
13153         install_element(BGP_VPNV4_NODE, &no_neighbor_route_server_client_cmd);
13154         install_element(BGP_VPNV6_NODE, &neighbor_route_server_client_cmd);
13155         install_element(BGP_VPNV6_NODE, &no_neighbor_route_server_client_cmd);
13156         install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_server_client_cmd);
13157         install_element(BGP_FLOWSPECV4_NODE,
13158                         &no_neighbor_route_server_client_cmd);
13159         install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_server_client_cmd);
13160         install_element(BGP_FLOWSPECV6_NODE,
13161                         &no_neighbor_route_server_client_cmd);
13162
13163         /* "neighbor addpath-tx-all-paths" commands.*/
13164         install_element(BGP_NODE, &neighbor_addpath_tx_all_paths_hidden_cmd);
13165         install_element(BGP_NODE, &no_neighbor_addpath_tx_all_paths_hidden_cmd);
13166         install_element(BGP_IPV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
13167         install_element(BGP_IPV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13168         install_element(BGP_IPV4M_NODE, &neighbor_addpath_tx_all_paths_cmd);
13169         install_element(BGP_IPV4M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13170         install_element(BGP_IPV4L_NODE, &neighbor_addpath_tx_all_paths_cmd);
13171         install_element(BGP_IPV4L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13172         install_element(BGP_IPV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
13173         install_element(BGP_IPV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13174         install_element(BGP_IPV6M_NODE, &neighbor_addpath_tx_all_paths_cmd);
13175         install_element(BGP_IPV6M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13176         install_element(BGP_IPV6L_NODE, &neighbor_addpath_tx_all_paths_cmd);
13177         install_element(BGP_IPV6L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13178         install_element(BGP_VPNV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
13179         install_element(BGP_VPNV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13180         install_element(BGP_VPNV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
13181         install_element(BGP_VPNV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13182
13183         /* "neighbor addpath-tx-bestpath-per-AS" commands.*/
13184         install_element(BGP_NODE,
13185                         &neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
13186         install_element(BGP_NODE,
13187                         &no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
13188         install_element(BGP_IPV4_NODE,
13189                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13190         install_element(BGP_IPV4_NODE,
13191                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13192         install_element(BGP_IPV4M_NODE,
13193                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13194         install_element(BGP_IPV4M_NODE,
13195                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13196         install_element(BGP_IPV4L_NODE,
13197                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13198         install_element(BGP_IPV4L_NODE,
13199                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13200         install_element(BGP_IPV6_NODE,
13201                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13202         install_element(BGP_IPV6_NODE,
13203                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13204         install_element(BGP_IPV6M_NODE,
13205                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13206         install_element(BGP_IPV6M_NODE,
13207                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13208         install_element(BGP_IPV6L_NODE,
13209                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13210         install_element(BGP_IPV6L_NODE,
13211                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13212         install_element(BGP_VPNV4_NODE,
13213                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13214         install_element(BGP_VPNV4_NODE,
13215                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13216         install_element(BGP_VPNV6_NODE,
13217                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13218         install_element(BGP_VPNV6_NODE,
13219                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13220
13221         /* "neighbor passive" commands. */
13222         install_element(BGP_NODE, &neighbor_passive_cmd);
13223         install_element(BGP_NODE, &no_neighbor_passive_cmd);
13224
13225
13226         /* "neighbor shutdown" commands. */
13227         install_element(BGP_NODE, &neighbor_shutdown_cmd);
13228         install_element(BGP_NODE, &no_neighbor_shutdown_cmd);
13229         install_element(BGP_NODE, &neighbor_shutdown_msg_cmd);
13230         install_element(BGP_NODE, &no_neighbor_shutdown_msg_cmd);
13231
13232         /* "neighbor capability extended-nexthop" commands.*/
13233         install_element(BGP_NODE, &neighbor_capability_enhe_cmd);
13234         install_element(BGP_NODE, &no_neighbor_capability_enhe_cmd);
13235
13236         /* "neighbor capability orf prefix-list" commands.*/
13237         install_element(BGP_NODE, &neighbor_capability_orf_prefix_hidden_cmd);
13238         install_element(BGP_NODE,
13239                         &no_neighbor_capability_orf_prefix_hidden_cmd);
13240         install_element(BGP_IPV4_NODE, &neighbor_capability_orf_prefix_cmd);
13241         install_element(BGP_IPV4_NODE, &no_neighbor_capability_orf_prefix_cmd);
13242         install_element(BGP_IPV4M_NODE, &neighbor_capability_orf_prefix_cmd);
13243         install_element(BGP_IPV4M_NODE, &no_neighbor_capability_orf_prefix_cmd);
13244         install_element(BGP_IPV4L_NODE, &neighbor_capability_orf_prefix_cmd);
13245         install_element(BGP_IPV4L_NODE, &no_neighbor_capability_orf_prefix_cmd);
13246         install_element(BGP_IPV6_NODE, &neighbor_capability_orf_prefix_cmd);
13247         install_element(BGP_IPV6_NODE, &no_neighbor_capability_orf_prefix_cmd);
13248         install_element(BGP_IPV6M_NODE, &neighbor_capability_orf_prefix_cmd);
13249         install_element(BGP_IPV6M_NODE, &no_neighbor_capability_orf_prefix_cmd);
13250         install_element(BGP_IPV6L_NODE, &neighbor_capability_orf_prefix_cmd);
13251         install_element(BGP_IPV6L_NODE, &no_neighbor_capability_orf_prefix_cmd);
13252
13253         /* "neighbor capability dynamic" commands.*/
13254         install_element(BGP_NODE, &neighbor_capability_dynamic_cmd);
13255         install_element(BGP_NODE, &no_neighbor_capability_dynamic_cmd);
13256
13257         /* "neighbor dont-capability-negotiate" commands. */
13258         install_element(BGP_NODE, &neighbor_dont_capability_negotiate_cmd);
13259         install_element(BGP_NODE, &no_neighbor_dont_capability_negotiate_cmd);
13260
13261         /* "neighbor ebgp-multihop" commands. */
13262         install_element(BGP_NODE, &neighbor_ebgp_multihop_cmd);
13263         install_element(BGP_NODE, &neighbor_ebgp_multihop_ttl_cmd);
13264         install_element(BGP_NODE, &no_neighbor_ebgp_multihop_cmd);
13265
13266         /* "neighbor disable-connected-check" commands.  */
13267         install_element(BGP_NODE, &neighbor_disable_connected_check_cmd);
13268         install_element(BGP_NODE, &no_neighbor_disable_connected_check_cmd);
13269
13270         /* "neighbor enforce-first-as" commands. */
13271         install_element(BGP_NODE, &neighbor_enforce_first_as_cmd);
13272         install_element(BGP_NODE, &no_neighbor_enforce_first_as_cmd);
13273
13274         /* "neighbor description" commands. */
13275         install_element(BGP_NODE, &neighbor_description_cmd);
13276         install_element(BGP_NODE, &no_neighbor_description_cmd);
13277         install_element(BGP_NODE, &no_neighbor_description_comment_cmd);
13278
13279         /* "neighbor update-source" commands. "*/
13280         install_element(BGP_NODE, &neighbor_update_source_cmd);
13281         install_element(BGP_NODE, &no_neighbor_update_source_cmd);
13282
13283         /* "neighbor default-originate" commands. */
13284         install_element(BGP_NODE, &neighbor_default_originate_hidden_cmd);
13285         install_element(BGP_NODE, &neighbor_default_originate_rmap_hidden_cmd);
13286         install_element(BGP_NODE, &no_neighbor_default_originate_hidden_cmd);
13287         install_element(BGP_IPV4_NODE, &neighbor_default_originate_cmd);
13288         install_element(BGP_IPV4_NODE, &neighbor_default_originate_rmap_cmd);
13289         install_element(BGP_IPV4_NODE, &no_neighbor_default_originate_cmd);
13290         install_element(BGP_IPV4M_NODE, &neighbor_default_originate_cmd);
13291         install_element(BGP_IPV4M_NODE, &neighbor_default_originate_rmap_cmd);
13292         install_element(BGP_IPV4M_NODE, &no_neighbor_default_originate_cmd);
13293         install_element(BGP_IPV4L_NODE, &neighbor_default_originate_cmd);
13294         install_element(BGP_IPV4L_NODE, &neighbor_default_originate_rmap_cmd);
13295         install_element(BGP_IPV4L_NODE, &no_neighbor_default_originate_cmd);
13296         install_element(BGP_IPV6_NODE, &neighbor_default_originate_cmd);
13297         install_element(BGP_IPV6_NODE, &neighbor_default_originate_rmap_cmd);
13298         install_element(BGP_IPV6_NODE, &no_neighbor_default_originate_cmd);
13299         install_element(BGP_IPV6M_NODE, &neighbor_default_originate_cmd);
13300         install_element(BGP_IPV6M_NODE, &neighbor_default_originate_rmap_cmd);
13301         install_element(BGP_IPV6M_NODE, &no_neighbor_default_originate_cmd);
13302         install_element(BGP_IPV6L_NODE, &neighbor_default_originate_cmd);
13303         install_element(BGP_IPV6L_NODE, &neighbor_default_originate_rmap_cmd);
13304         install_element(BGP_IPV6L_NODE, &no_neighbor_default_originate_cmd);
13305
13306         /* "neighbor port" commands. */
13307         install_element(BGP_NODE, &neighbor_port_cmd);
13308         install_element(BGP_NODE, &no_neighbor_port_cmd);
13309
13310         /* "neighbor weight" commands. */
13311         install_element(BGP_NODE, &neighbor_weight_hidden_cmd);
13312         install_element(BGP_NODE, &no_neighbor_weight_hidden_cmd);
13313
13314         install_element(BGP_IPV4_NODE, &neighbor_weight_cmd);
13315         install_element(BGP_IPV4_NODE, &no_neighbor_weight_cmd);
13316         install_element(BGP_IPV4M_NODE, &neighbor_weight_cmd);
13317         install_element(BGP_IPV4M_NODE, &no_neighbor_weight_cmd);
13318         install_element(BGP_IPV4L_NODE, &neighbor_weight_cmd);
13319         install_element(BGP_IPV4L_NODE, &no_neighbor_weight_cmd);
13320         install_element(BGP_IPV6_NODE, &neighbor_weight_cmd);
13321         install_element(BGP_IPV6_NODE, &no_neighbor_weight_cmd);
13322         install_element(BGP_IPV6M_NODE, &neighbor_weight_cmd);
13323         install_element(BGP_IPV6M_NODE, &no_neighbor_weight_cmd);
13324         install_element(BGP_IPV6L_NODE, &neighbor_weight_cmd);
13325         install_element(BGP_IPV6L_NODE, &no_neighbor_weight_cmd);
13326         install_element(BGP_VPNV4_NODE, &neighbor_weight_cmd);
13327         install_element(BGP_VPNV4_NODE, &no_neighbor_weight_cmd);
13328         install_element(BGP_VPNV6_NODE, &neighbor_weight_cmd);
13329         install_element(BGP_VPNV6_NODE, &no_neighbor_weight_cmd);
13330
13331         /* "neighbor override-capability" commands. */
13332         install_element(BGP_NODE, &neighbor_override_capability_cmd);
13333         install_element(BGP_NODE, &no_neighbor_override_capability_cmd);
13334
13335         /* "neighbor strict-capability-match" commands. */
13336         install_element(BGP_NODE, &neighbor_strict_capability_cmd);
13337         install_element(BGP_NODE, &no_neighbor_strict_capability_cmd);
13338
13339         /* "neighbor timers" commands. */
13340         install_element(BGP_NODE, &neighbor_timers_cmd);
13341         install_element(BGP_NODE, &no_neighbor_timers_cmd);
13342
13343         /* "neighbor timers connect" commands. */
13344         install_element(BGP_NODE, &neighbor_timers_connect_cmd);
13345         install_element(BGP_NODE, &no_neighbor_timers_connect_cmd);
13346
13347         /* "neighbor advertisement-interval" commands. */
13348         install_element(BGP_NODE, &neighbor_advertise_interval_cmd);
13349         install_element(BGP_NODE, &no_neighbor_advertise_interval_cmd);
13350
13351         /* "neighbor interface" commands. */
13352         install_element(BGP_NODE, &neighbor_interface_cmd);
13353         install_element(BGP_NODE, &no_neighbor_interface_cmd);
13354
13355         /* "neighbor distribute" commands. */
13356         install_element(BGP_NODE, &neighbor_distribute_list_hidden_cmd);
13357         install_element(BGP_NODE, &no_neighbor_distribute_list_hidden_cmd);
13358         install_element(BGP_IPV4_NODE, &neighbor_distribute_list_cmd);
13359         install_element(BGP_IPV4_NODE, &no_neighbor_distribute_list_cmd);
13360         install_element(BGP_IPV4M_NODE, &neighbor_distribute_list_cmd);
13361         install_element(BGP_IPV4M_NODE, &no_neighbor_distribute_list_cmd);
13362         install_element(BGP_IPV4L_NODE, &neighbor_distribute_list_cmd);
13363         install_element(BGP_IPV4L_NODE, &no_neighbor_distribute_list_cmd);
13364         install_element(BGP_IPV6_NODE, &neighbor_distribute_list_cmd);
13365         install_element(BGP_IPV6_NODE, &no_neighbor_distribute_list_cmd);
13366         install_element(BGP_IPV6M_NODE, &neighbor_distribute_list_cmd);
13367         install_element(BGP_IPV6M_NODE, &no_neighbor_distribute_list_cmd);
13368         install_element(BGP_IPV6L_NODE, &neighbor_distribute_list_cmd);
13369         install_element(BGP_IPV6L_NODE, &no_neighbor_distribute_list_cmd);
13370         install_element(BGP_VPNV4_NODE, &neighbor_distribute_list_cmd);
13371         install_element(BGP_VPNV4_NODE, &no_neighbor_distribute_list_cmd);
13372         install_element(BGP_VPNV6_NODE, &neighbor_distribute_list_cmd);
13373         install_element(BGP_VPNV6_NODE, &no_neighbor_distribute_list_cmd);
13374
13375         /* "neighbor prefix-list" commands. */
13376         install_element(BGP_NODE, &neighbor_prefix_list_hidden_cmd);
13377         install_element(BGP_NODE, &no_neighbor_prefix_list_hidden_cmd);
13378         install_element(BGP_IPV4_NODE, &neighbor_prefix_list_cmd);
13379         install_element(BGP_IPV4_NODE, &no_neighbor_prefix_list_cmd);
13380         install_element(BGP_IPV4M_NODE, &neighbor_prefix_list_cmd);
13381         install_element(BGP_IPV4M_NODE, &no_neighbor_prefix_list_cmd);
13382         install_element(BGP_IPV4L_NODE, &neighbor_prefix_list_cmd);
13383         install_element(BGP_IPV4L_NODE, &no_neighbor_prefix_list_cmd);
13384         install_element(BGP_IPV6_NODE, &neighbor_prefix_list_cmd);
13385         install_element(BGP_IPV6_NODE, &no_neighbor_prefix_list_cmd);
13386         install_element(BGP_IPV6M_NODE, &neighbor_prefix_list_cmd);
13387         install_element(BGP_IPV6M_NODE, &no_neighbor_prefix_list_cmd);
13388         install_element(BGP_IPV6L_NODE, &neighbor_prefix_list_cmd);
13389         install_element(BGP_IPV6L_NODE, &no_neighbor_prefix_list_cmd);
13390         install_element(BGP_VPNV4_NODE, &neighbor_prefix_list_cmd);
13391         install_element(BGP_VPNV4_NODE, &no_neighbor_prefix_list_cmd);
13392         install_element(BGP_VPNV6_NODE, &neighbor_prefix_list_cmd);
13393         install_element(BGP_VPNV6_NODE, &no_neighbor_prefix_list_cmd);
13394         install_element(BGP_FLOWSPECV4_NODE, &neighbor_prefix_list_cmd);
13395         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_prefix_list_cmd);
13396         install_element(BGP_FLOWSPECV6_NODE, &neighbor_prefix_list_cmd);
13397         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_prefix_list_cmd);
13398
13399         /* "neighbor filter-list" commands. */
13400         install_element(BGP_NODE, &neighbor_filter_list_hidden_cmd);
13401         install_element(BGP_NODE, &no_neighbor_filter_list_hidden_cmd);
13402         install_element(BGP_IPV4_NODE, &neighbor_filter_list_cmd);
13403         install_element(BGP_IPV4_NODE, &no_neighbor_filter_list_cmd);
13404         install_element(BGP_IPV4M_NODE, &neighbor_filter_list_cmd);
13405         install_element(BGP_IPV4M_NODE, &no_neighbor_filter_list_cmd);
13406         install_element(BGP_IPV4L_NODE, &neighbor_filter_list_cmd);
13407         install_element(BGP_IPV4L_NODE, &no_neighbor_filter_list_cmd);
13408         install_element(BGP_IPV6_NODE, &neighbor_filter_list_cmd);
13409         install_element(BGP_IPV6_NODE, &no_neighbor_filter_list_cmd);
13410         install_element(BGP_IPV6M_NODE, &neighbor_filter_list_cmd);
13411         install_element(BGP_IPV6M_NODE, &no_neighbor_filter_list_cmd);
13412         install_element(BGP_IPV6L_NODE, &neighbor_filter_list_cmd);
13413         install_element(BGP_IPV6L_NODE, &no_neighbor_filter_list_cmd);
13414         install_element(BGP_VPNV4_NODE, &neighbor_filter_list_cmd);
13415         install_element(BGP_VPNV4_NODE, &no_neighbor_filter_list_cmd);
13416         install_element(BGP_VPNV6_NODE, &neighbor_filter_list_cmd);
13417         install_element(BGP_VPNV6_NODE, &no_neighbor_filter_list_cmd);
13418         install_element(BGP_FLOWSPECV4_NODE, &neighbor_filter_list_cmd);
13419         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_filter_list_cmd);
13420         install_element(BGP_FLOWSPECV6_NODE, &neighbor_filter_list_cmd);
13421         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_filter_list_cmd);
13422
13423         /* "neighbor route-map" commands. */
13424         install_element(BGP_NODE, &neighbor_route_map_hidden_cmd);
13425         install_element(BGP_NODE, &no_neighbor_route_map_hidden_cmd);
13426         install_element(BGP_IPV4_NODE, &neighbor_route_map_cmd);
13427         install_element(BGP_IPV4_NODE, &no_neighbor_route_map_cmd);
13428         install_element(BGP_IPV4M_NODE, &neighbor_route_map_cmd);
13429         install_element(BGP_IPV4M_NODE, &no_neighbor_route_map_cmd);
13430         install_element(BGP_IPV4L_NODE, &neighbor_route_map_cmd);
13431         install_element(BGP_IPV4L_NODE, &no_neighbor_route_map_cmd);
13432         install_element(BGP_IPV6_NODE, &neighbor_route_map_cmd);
13433         install_element(BGP_IPV6_NODE, &no_neighbor_route_map_cmd);
13434         install_element(BGP_IPV6M_NODE, &neighbor_route_map_cmd);
13435         install_element(BGP_IPV6M_NODE, &no_neighbor_route_map_cmd);
13436         install_element(BGP_IPV6L_NODE, &neighbor_route_map_cmd);
13437         install_element(BGP_IPV6L_NODE, &no_neighbor_route_map_cmd);
13438         install_element(BGP_VPNV4_NODE, &neighbor_route_map_cmd);
13439         install_element(BGP_VPNV4_NODE, &no_neighbor_route_map_cmd);
13440         install_element(BGP_VPNV6_NODE, &neighbor_route_map_cmd);
13441         install_element(BGP_VPNV6_NODE, &no_neighbor_route_map_cmd);
13442         install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_map_cmd);
13443         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_route_map_cmd);
13444         install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_map_cmd);
13445         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_route_map_cmd);
13446         install_element(BGP_EVPN_NODE, &neighbor_route_map_cmd);
13447         install_element(BGP_EVPN_NODE, &no_neighbor_route_map_cmd);
13448
13449         /* "neighbor unsuppress-map" commands. */
13450         install_element(BGP_NODE, &neighbor_unsuppress_map_hidden_cmd);
13451         install_element(BGP_NODE, &no_neighbor_unsuppress_map_hidden_cmd);
13452         install_element(BGP_IPV4_NODE, &neighbor_unsuppress_map_cmd);
13453         install_element(BGP_IPV4_NODE, &no_neighbor_unsuppress_map_cmd);
13454         install_element(BGP_IPV4M_NODE, &neighbor_unsuppress_map_cmd);
13455         install_element(BGP_IPV4M_NODE, &no_neighbor_unsuppress_map_cmd);
13456         install_element(BGP_IPV4L_NODE, &neighbor_unsuppress_map_cmd);
13457         install_element(BGP_IPV4L_NODE, &no_neighbor_unsuppress_map_cmd);
13458         install_element(BGP_IPV6_NODE, &neighbor_unsuppress_map_cmd);
13459         install_element(BGP_IPV6_NODE, &no_neighbor_unsuppress_map_cmd);
13460         install_element(BGP_IPV6M_NODE, &neighbor_unsuppress_map_cmd);
13461         install_element(BGP_IPV6M_NODE, &no_neighbor_unsuppress_map_cmd);
13462         install_element(BGP_IPV6L_NODE, &neighbor_unsuppress_map_cmd);
13463         install_element(BGP_IPV6L_NODE, &no_neighbor_unsuppress_map_cmd);
13464         install_element(BGP_VPNV4_NODE, &neighbor_unsuppress_map_cmd);
13465         install_element(BGP_VPNV4_NODE, &no_neighbor_unsuppress_map_cmd);
13466         install_element(BGP_VPNV6_NODE, &neighbor_unsuppress_map_cmd);
13467         install_element(BGP_VPNV6_NODE, &no_neighbor_unsuppress_map_cmd);
13468
13469         /* "neighbor maximum-prefix" commands. */
13470         install_element(BGP_NODE, &neighbor_maximum_prefix_hidden_cmd);
13471         install_element(BGP_NODE,
13472                         &neighbor_maximum_prefix_threshold_hidden_cmd);
13473         install_element(BGP_NODE, &neighbor_maximum_prefix_warning_hidden_cmd);
13474         install_element(BGP_NODE,
13475                         &neighbor_maximum_prefix_threshold_warning_hidden_cmd);
13476         install_element(BGP_NODE, &neighbor_maximum_prefix_restart_hidden_cmd);
13477         install_element(BGP_NODE,
13478                         &neighbor_maximum_prefix_threshold_restart_hidden_cmd);
13479         install_element(BGP_NODE, &no_neighbor_maximum_prefix_hidden_cmd);
13480         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_cmd);
13481         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
13482         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_warning_cmd);
13483         install_element(BGP_IPV4_NODE,
13484                         &neighbor_maximum_prefix_threshold_warning_cmd);
13485         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_restart_cmd);
13486         install_element(BGP_IPV4_NODE,
13487                         &neighbor_maximum_prefix_threshold_restart_cmd);
13488         install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_cmd);
13489         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_cmd);
13490         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_cmd);
13491         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_warning_cmd);
13492         install_element(BGP_IPV4M_NODE,
13493                         &neighbor_maximum_prefix_threshold_warning_cmd);
13494         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_restart_cmd);
13495         install_element(BGP_IPV4M_NODE,
13496                         &neighbor_maximum_prefix_threshold_restart_cmd);
13497         install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_cmd);
13498         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_cmd);
13499         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_threshold_cmd);
13500         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_warning_cmd);
13501         install_element(BGP_IPV4L_NODE,
13502                         &neighbor_maximum_prefix_threshold_warning_cmd);
13503         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_restart_cmd);
13504         install_element(BGP_IPV4L_NODE,
13505                         &neighbor_maximum_prefix_threshold_restart_cmd);
13506         install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_cmd);
13507         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_cmd);
13508         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
13509         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
13510         install_element(BGP_IPV6_NODE,
13511                         &neighbor_maximum_prefix_threshold_warning_cmd);
13512         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
13513         install_element(BGP_IPV6_NODE,
13514                         &neighbor_maximum_prefix_threshold_restart_cmd);
13515         install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_cmd);
13516         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_cmd);
13517         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_cmd);
13518         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_warning_cmd);
13519         install_element(BGP_IPV6M_NODE,
13520                         &neighbor_maximum_prefix_threshold_warning_cmd);
13521         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_restart_cmd);
13522         install_element(BGP_IPV6M_NODE,
13523                         &neighbor_maximum_prefix_threshold_restart_cmd);
13524         install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_cmd);
13525         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_cmd);
13526         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_threshold_cmd);
13527         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_warning_cmd);
13528         install_element(BGP_IPV6L_NODE,
13529                         &neighbor_maximum_prefix_threshold_warning_cmd);
13530         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_restart_cmd);
13531         install_element(BGP_IPV6L_NODE,
13532                         &neighbor_maximum_prefix_threshold_restart_cmd);
13533         install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_cmd);
13534         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_cmd);
13535         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
13536         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_warning_cmd);
13537         install_element(BGP_VPNV4_NODE,
13538                         &neighbor_maximum_prefix_threshold_warning_cmd);
13539         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_restart_cmd);
13540         install_element(BGP_VPNV4_NODE,
13541                         &neighbor_maximum_prefix_threshold_restart_cmd);
13542         install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_cmd);
13543         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_cmd);
13544         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
13545         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_warning_cmd);
13546         install_element(BGP_VPNV6_NODE,
13547                         &neighbor_maximum_prefix_threshold_warning_cmd);
13548         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_restart_cmd);
13549         install_element(BGP_VPNV6_NODE,
13550                         &neighbor_maximum_prefix_threshold_restart_cmd);
13551         install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_cmd);
13552
13553         /* "neighbor allowas-in" */
13554         install_element(BGP_NODE, &neighbor_allowas_in_hidden_cmd);
13555         install_element(BGP_NODE, &no_neighbor_allowas_in_hidden_cmd);
13556         install_element(BGP_IPV4_NODE, &neighbor_allowas_in_cmd);
13557         install_element(BGP_IPV4_NODE, &no_neighbor_allowas_in_cmd);
13558         install_element(BGP_IPV4M_NODE, &neighbor_allowas_in_cmd);
13559         install_element(BGP_IPV4M_NODE, &no_neighbor_allowas_in_cmd);
13560         install_element(BGP_IPV4L_NODE, &neighbor_allowas_in_cmd);
13561         install_element(BGP_IPV4L_NODE, &no_neighbor_allowas_in_cmd);
13562         install_element(BGP_IPV6_NODE, &neighbor_allowas_in_cmd);
13563         install_element(BGP_IPV6_NODE, &no_neighbor_allowas_in_cmd);
13564         install_element(BGP_IPV6M_NODE, &neighbor_allowas_in_cmd);
13565         install_element(BGP_IPV6M_NODE, &no_neighbor_allowas_in_cmd);
13566         install_element(BGP_IPV6L_NODE, &neighbor_allowas_in_cmd);
13567         install_element(BGP_IPV6L_NODE, &no_neighbor_allowas_in_cmd);
13568         install_element(BGP_VPNV4_NODE, &neighbor_allowas_in_cmd);
13569         install_element(BGP_VPNV4_NODE, &no_neighbor_allowas_in_cmd);
13570         install_element(BGP_VPNV6_NODE, &neighbor_allowas_in_cmd);
13571         install_element(BGP_VPNV6_NODE, &no_neighbor_allowas_in_cmd);
13572         install_element(BGP_EVPN_NODE, &neighbor_allowas_in_cmd);
13573         install_element(BGP_EVPN_NODE, &no_neighbor_allowas_in_cmd);
13574
13575         /* address-family commands. */
13576         install_element(BGP_NODE, &address_family_ipv4_safi_cmd);
13577         install_element(BGP_NODE, &address_family_ipv6_safi_cmd);
13578 #ifdef KEEP_OLD_VPN_COMMANDS
13579         install_element(BGP_NODE, &address_family_vpnv4_cmd);
13580         install_element(BGP_NODE, &address_family_vpnv6_cmd);
13581 #endif /* KEEP_OLD_VPN_COMMANDS */
13582
13583         install_element(BGP_NODE, &address_family_evpn_cmd);
13584
13585         /* "exit-address-family" command. */
13586         install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
13587         install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
13588         install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
13589         install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
13590         install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
13591         install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
13592         install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
13593         install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
13594         install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
13595         install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
13596         install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
13597
13598         /* "clear ip bgp commands" */
13599         install_element(ENABLE_NODE, &clear_ip_bgp_all_cmd);
13600
13601         /* clear ip bgp prefix  */
13602         install_element(ENABLE_NODE, &clear_ip_bgp_prefix_cmd);
13603         install_element(ENABLE_NODE, &clear_bgp_ipv6_safi_prefix_cmd);
13604         install_element(ENABLE_NODE, &clear_bgp_instance_ipv6_safi_prefix_cmd);
13605
13606         /* "show [ip] bgp summary" commands. */
13607         install_element(VIEW_NODE, &show_bgp_instance_all_ipv6_updgrps_cmd);
13608         install_element(VIEW_NODE, &show_bgp_instance_updgrps_stats_cmd);
13609         install_element(VIEW_NODE, &show_bgp_updgrps_stats_cmd);
13610         install_element(VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_s_cmd);
13611         install_element(VIEW_NODE, &show_ip_bgp_summary_cmd);
13612         install_element(VIEW_NODE, &show_ip_bgp_updgrps_cmd);
13613
13614         /* "show [ip] bgp neighbors" commands. */
13615         install_element(VIEW_NODE, &show_ip_bgp_neighbors_cmd);
13616
13617         /* "show [ip] bgp peer-group" commands. */
13618         install_element(VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
13619
13620         /* "show [ip] bgp paths" commands. */
13621         install_element(VIEW_NODE, &show_ip_bgp_paths_cmd);
13622
13623         /* "show [ip] bgp community" commands. */
13624         install_element(VIEW_NODE, &show_ip_bgp_community_info_cmd);
13625
13626         /* "show ip bgp large-community" commands. */
13627         install_element(VIEW_NODE, &show_ip_bgp_lcommunity_info_cmd);
13628         /* "show [ip] bgp attribute-info" commands. */
13629         install_element(VIEW_NODE, &show_ip_bgp_attr_info_cmd);
13630         /* "show [ip] bgp route-leak" command */
13631         install_element(VIEW_NODE, &show_ip_bgp_route_leak_cmd);
13632
13633         /* "redistribute" commands.  */
13634         install_element(BGP_NODE, &bgp_redistribute_ipv4_hidden_cmd);
13635         install_element(BGP_NODE, &no_bgp_redistribute_ipv4_hidden_cmd);
13636         install_element(BGP_NODE, &bgp_redistribute_ipv4_rmap_hidden_cmd);
13637         install_element(BGP_NODE, &bgp_redistribute_ipv4_metric_hidden_cmd);
13638         install_element(BGP_NODE,
13639                         &bgp_redistribute_ipv4_rmap_metric_hidden_cmd);
13640         install_element(BGP_NODE,
13641                         &bgp_redistribute_ipv4_metric_rmap_hidden_cmd);
13642         install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_hidden_cmd);
13643         install_element(BGP_NODE, &no_bgp_redistribute_ipv4_ospf_hidden_cmd);
13644         install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_hidden_cmd);
13645         install_element(BGP_NODE,
13646                         &bgp_redistribute_ipv4_ospf_metric_hidden_cmd);
13647         install_element(BGP_NODE,
13648                         &bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd);
13649         install_element(BGP_NODE,
13650                         &bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd);
13651         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_cmd);
13652         install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_cmd);
13653         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_cmd);
13654         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_cmd);
13655         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
13656         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
13657         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_cmd);
13658         install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
13659         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
13660         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
13661         install_element(BGP_IPV4_NODE,
13662                         &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
13663         install_element(BGP_IPV4_NODE,
13664                         &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
13665         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_cmd);
13666         install_element(BGP_IPV6_NODE, &no_bgp_redistribute_ipv6_cmd);
13667         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_cmd);
13668         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_cmd);
13669         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_metric_cmd);
13670         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_rmap_cmd);
13671
13672         /* import|export vpn [route-map WORD] */
13673         install_element(BGP_IPV4_NODE, &bgp_imexport_vpn_cmd);
13674         install_element(BGP_IPV6_NODE, &bgp_imexport_vpn_cmd);
13675
13676         install_element(BGP_IPV4_NODE, &bgp_imexport_vrf_cmd);
13677         install_element(BGP_IPV6_NODE, &bgp_imexport_vrf_cmd);
13678
13679         /* ttl_security commands */
13680         install_element(BGP_NODE, &neighbor_ttl_security_cmd);
13681         install_element(BGP_NODE, &no_neighbor_ttl_security_cmd);
13682
13683         /* "show [ip] bgp memory" commands. */
13684         install_element(VIEW_NODE, &show_bgp_memory_cmd);
13685
13686         /* "show bgp martian next-hop" */
13687         install_element(VIEW_NODE, &show_bgp_martian_nexthop_db_cmd);
13688
13689         /* "show [ip] bgp views" commands. */
13690         install_element(VIEW_NODE, &show_bgp_views_cmd);
13691
13692         /* "show [ip] bgp vrfs" commands. */
13693         install_element(VIEW_NODE, &show_bgp_vrfs_cmd);
13694
13695         /* Community-list. */
13696         community_list_vty();
13697
13698         /* vpn-policy commands */
13699         install_element(BGP_IPV4_NODE, &af_rd_vpn_export_cmd);
13700         install_element(BGP_IPV6_NODE, &af_rd_vpn_export_cmd);
13701         install_element(BGP_IPV4_NODE, &af_label_vpn_export_cmd);
13702         install_element(BGP_IPV6_NODE, &af_label_vpn_export_cmd);
13703         install_element(BGP_IPV4_NODE, &af_nexthop_vpn_export_cmd);
13704         install_element(BGP_IPV6_NODE, &af_nexthop_vpn_export_cmd);
13705         install_element(BGP_IPV4_NODE, &af_rt_vpn_imexport_cmd);
13706         install_element(BGP_IPV6_NODE, &af_rt_vpn_imexport_cmd);
13707         install_element(BGP_IPV4_NODE, &af_route_map_vpn_imexport_cmd);
13708         install_element(BGP_IPV6_NODE, &af_route_map_vpn_imexport_cmd);
13709         install_element(BGP_IPV4_NODE, &af_import_vrf_route_map_cmd);
13710         install_element(BGP_IPV6_NODE, &af_import_vrf_route_map_cmd);
13711
13712         install_element(BGP_IPV4_NODE, &af_routetarget_import_cmd);
13713         install_element(BGP_IPV6_NODE, &af_routetarget_import_cmd);
13714
13715         install_element(BGP_IPV4_NODE, &af_no_rd_vpn_export_cmd);
13716         install_element(BGP_IPV6_NODE, &af_no_rd_vpn_export_cmd);
13717         install_element(BGP_IPV4_NODE, &af_no_label_vpn_export_cmd);
13718         install_element(BGP_IPV6_NODE, &af_no_label_vpn_export_cmd);
13719         install_element(BGP_IPV4_NODE, &af_no_nexthop_vpn_export_cmd);
13720         install_element(BGP_IPV6_NODE, &af_no_nexthop_vpn_export_cmd);
13721         install_element(BGP_IPV4_NODE, &af_no_rt_vpn_imexport_cmd);
13722         install_element(BGP_IPV6_NODE, &af_no_rt_vpn_imexport_cmd);
13723         install_element(BGP_IPV4_NODE, &af_no_route_map_vpn_imexport_cmd);
13724         install_element(BGP_IPV6_NODE, &af_no_route_map_vpn_imexport_cmd);
13725         install_element(BGP_IPV4_NODE, &af_no_import_vrf_route_map_cmd);
13726         install_element(BGP_IPV6_NODE, &af_no_import_vrf_route_map_cmd);
13727 }
13728
13729 #include "memory.h"
13730 #include "bgp_regex.h"
13731 #include "bgp_clist.h"
13732 #include "bgp_ecommunity.h"
13733
13734 /* VTY functions.  */
13735
13736 /* Direction value to string conversion.  */
13737 static const char *community_direct_str(int direct)
13738 {
13739         switch (direct) {
13740         case COMMUNITY_DENY:
13741                 return "deny";
13742         case COMMUNITY_PERMIT:
13743                 return "permit";
13744         default:
13745                 return "unknown";
13746         }
13747 }
13748
13749 /* Display error string.  */
13750 static void community_list_perror(struct vty *vty, int ret)
13751 {
13752         switch (ret) {
13753         case COMMUNITY_LIST_ERR_CANT_FIND_LIST:
13754                 vty_out(vty, "%% Can't find community-list\n");
13755                 break;
13756         case COMMUNITY_LIST_ERR_MALFORMED_VAL:
13757                 vty_out(vty, "%% Malformed community-list value\n");
13758                 break;
13759         case COMMUNITY_LIST_ERR_STANDARD_CONFLICT:
13760                 vty_out(vty,
13761                         "%% Community name conflict, previously defined as standard community\n");
13762                 break;
13763         case COMMUNITY_LIST_ERR_EXPANDED_CONFLICT:
13764                 vty_out(vty,
13765                         "%% Community name conflict, previously defined as expanded community\n");
13766                 break;
13767         }
13768 }
13769
13770 /* "community-list" keyword help string.  */
13771 #define COMMUNITY_LIST_STR "Add a community list entry\n"
13772
13773 /*community-list standard */
13774 DEFUN (community_list_standard,
13775        bgp_community_list_standard_cmd,
13776        "bgp community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
13777        BGP_STR
13778        COMMUNITY_LIST_STR
13779        "Community list number (standard)\n"
13780        "Add an standard community-list entry\n"
13781        "Community list name\n"
13782        "Specify community to reject\n"
13783        "Specify community to accept\n"
13784        COMMUNITY_VAL_STR)
13785 {
13786         char *cl_name_or_number = NULL;
13787         int direct = 0;
13788         int style = COMMUNITY_LIST_STANDARD;
13789
13790         int idx = 0;
13791
13792         if (argv_find(argv, argc, "ip", &idx)) {
13793                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
13794                 vty_out(vty, "if you are using this please migrate to the below command.\n");
13795                 vty_out(vty, "'bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
13796                 zlog_warn("Deprecated option: 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
13797         }
13798
13799         argv_find(argv, argc, "(1-99)", &idx);
13800         argv_find(argv, argc, "WORD", &idx);
13801         cl_name_or_number = argv[idx]->arg;
13802         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
13803                                                        : COMMUNITY_DENY;
13804         argv_find(argv, argc, "AA:NN", &idx);
13805         char *str = argv_concat(argv, argc, idx);
13806
13807         int ret = community_list_set(bgp_clist, cl_name_or_number, str, direct,
13808                                      style);
13809
13810         XFREE(MTYPE_TMP, str);
13811
13812         if (ret < 0) {
13813                 /* Display error string.  */
13814                 community_list_perror(vty, ret);
13815                 return CMD_WARNING_CONFIG_FAILED;
13816         }
13817
13818         return CMD_SUCCESS;
13819 }
13820
13821 #if CONFDATE > 20191005
13822 CPP_NOTICE("bgpd: remove deprecated 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' command")
13823 #endif
13824 ALIAS (community_list_standard,
13825        ip_community_list_standard_cmd,
13826        "ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
13827        IP_STR
13828        COMMUNITY_LIST_STR
13829        "Community list number (standard)\n"
13830        "Add an standard community-list entry\n"
13831        "Community list name\n"
13832        "Specify community to reject\n"
13833        "Specify community to accept\n"
13834        COMMUNITY_VAL_STR)
13835
13836 DEFUN (no_community_list_standard_all,
13837        no_bgp_community_list_standard_all_cmd,
13838        "no bgp community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
13839        NO_STR
13840        BGP_STR
13841        COMMUNITY_LIST_STR
13842        "Community list number (standard)\n"
13843        "Add an standard community-list entry\n"
13844        "Community list name\n"
13845        "Specify community to reject\n"
13846        "Specify community to accept\n"
13847        COMMUNITY_VAL_STR)
13848 {
13849         char *cl_name_or_number = NULL;
13850         int direct = 0;
13851         int style = COMMUNITY_LIST_STANDARD;
13852
13853         int idx = 0;
13854
13855         if (argv_find(argv, argc, "ip", &idx)) {
13856                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
13857                 vty_out(vty, "if you are using this please migrate to the below command.\n");
13858                 vty_out(vty, "'no bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
13859                 zlog_warn("Deprecated option: 'no ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> |AA:NN' being used");
13860         }
13861
13862         argv_find(argv, argc, "(1-99)", &idx);
13863         argv_find(argv, argc, "WORD", &idx);
13864         cl_name_or_number = argv[idx]->arg;
13865         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
13866                                                        : COMMUNITY_DENY;
13867         argv_find(argv, argc, "AA:NN", &idx);
13868         char *str = argv_concat(argv, argc, idx);
13869
13870         int ret = community_list_unset(bgp_clist, cl_name_or_number, str,
13871                                        direct, style);
13872
13873         XFREE(MTYPE_TMP, str);
13874
13875         if (ret < 0) {
13876                 community_list_perror(vty, ret);
13877                 return CMD_WARNING_CONFIG_FAILED;
13878         }
13879
13880         return CMD_SUCCESS;
13881 }
13882 ALIAS (no_community_list_standard_all,
13883        no_ip_community_list_standard_all_cmd,
13884        "no ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
13885        NO_STR
13886        IP_STR
13887        COMMUNITY_LIST_STR
13888        "Community list number (standard)\n"
13889        "Add an standard community-list entry\n"
13890        "Community list name\n"
13891        "Specify community to reject\n"
13892        "Specify community to accept\n"
13893        COMMUNITY_VAL_STR)
13894
13895 /*community-list expanded */
13896 DEFUN (community_list_expanded_all,
13897        bgp_community_list_expanded_all_cmd,
13898        "bgp community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
13899        BGP_STR
13900        COMMUNITY_LIST_STR
13901        "Community list number (expanded)\n"
13902        "Add an expanded community-list entry\n"
13903        "Community list name\n"
13904        "Specify community to reject\n"
13905        "Specify community to accept\n"
13906        COMMUNITY_VAL_STR)
13907 {
13908         char *cl_name_or_number = NULL;
13909         int direct = 0;
13910         int style = COMMUNITY_LIST_EXPANDED;
13911
13912         int idx = 0;
13913         if (argv_find(argv, argc, "ip", &idx)) {
13914                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
13915                 vty_out(vty, "if you are using this please migrate to the below command.\n");
13916                 vty_out(vty, "'bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
13917                 zlog_warn("Deprecated option: 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
13918         }
13919         argv_find(argv, argc, "(100-500)", &idx);
13920         argv_find(argv, argc, "WORD", &idx);
13921         cl_name_or_number = argv[idx]->arg;
13922         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
13923                                                        : COMMUNITY_DENY;
13924         argv_find(argv, argc, "AA:NN", &idx);
13925         char *str = argv_concat(argv, argc, idx);
13926
13927         int ret = community_list_set(bgp_clist, cl_name_or_number, str, direct,
13928                                      style);
13929
13930         XFREE(MTYPE_TMP, str);
13931
13932         if (ret < 0) {
13933                 /* Display error string.  */
13934                 community_list_perror(vty, ret);
13935                 return CMD_WARNING_CONFIG_FAILED;
13936         }
13937
13938         return CMD_SUCCESS;
13939 }
13940
13941 ALIAS (community_list_expanded_all,
13942        ip_community_list_expanded_all_cmd,
13943        "ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
13944        IP_STR
13945        COMMUNITY_LIST_STR
13946        "Community list number (expanded)\n"
13947        "Add an expanded community-list entry\n"
13948        "Community list name\n"
13949        "Specify community to reject\n"
13950        "Specify community to accept\n"
13951        COMMUNITY_VAL_STR)
13952
13953 DEFUN (no_community_list_expanded_all,
13954        no_bgp_community_list_expanded_all_cmd,
13955        "no bgp community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
13956        NO_STR
13957        BGP_STR
13958        COMMUNITY_LIST_STR
13959        "Community list number (expanded)\n"
13960        "Add an expanded community-list entry\n"
13961        "Community list name\n"
13962        "Specify community to reject\n"
13963        "Specify community to accept\n"
13964        COMMUNITY_VAL_STR)
13965 {
13966         char *cl_name_or_number = NULL;
13967         int direct = 0;
13968         int style = COMMUNITY_LIST_EXPANDED;
13969
13970         int idx = 0;
13971         if (argv_find(argv, argc, "ip", &idx)) {
13972                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
13973                 vty_out(vty, "if you are using this please migrate to the below command.\n");
13974                 vty_out(vty, "'no community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
13975                 zlog_warn("Deprecated option: 'no community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
13976         }
13977         argv_find(argv, argc, "(100-500)", &idx);
13978         argv_find(argv, argc, "WORD", &idx);
13979         cl_name_or_number = argv[idx]->arg;
13980         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
13981                                                        : COMMUNITY_DENY;
13982         argv_find(argv, argc, "AA:NN", &idx);
13983         char *str = argv_concat(argv, argc, idx);
13984
13985         int ret = community_list_unset(bgp_clist, cl_name_or_number, str,
13986                                        direct, style);
13987
13988         XFREE(MTYPE_TMP, str);
13989
13990         if (ret < 0) {
13991                 community_list_perror(vty, ret);
13992                 return CMD_WARNING_CONFIG_FAILED;
13993         }
13994
13995         return CMD_SUCCESS;
13996 }
13997
13998 ALIAS (no_community_list_expanded_all,
13999        no_ip_community_list_expanded_all_cmd,
14000        "no ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
14001        NO_STR
14002        IP_STR
14003        COMMUNITY_LIST_STR
14004        "Community list number (expanded)\n"
14005        "Add an expanded community-list entry\n"
14006        "Community list name\n"
14007        "Specify community to reject\n"
14008        "Specify community to accept\n"
14009        COMMUNITY_VAL_STR)
14010
14011 /* Return configuration string of community-list entry.  */
14012 static const char *community_list_config_str(struct community_entry *entry)
14013 {
14014         const char *str;
14015
14016         if (entry->any)
14017                 str = "";
14018         else {
14019                 if (entry->style == COMMUNITY_LIST_STANDARD)
14020                         str = community_str(entry->u.com, false);
14021                 else if (entry->style == LARGE_COMMUNITY_LIST_STANDARD)
14022                         str = lcommunity_str(entry->u.lcom, false);
14023                 else
14024                         str = entry->config;
14025         }
14026         return str;
14027 }
14028
14029 static void community_list_show(struct vty *vty, struct community_list *list)
14030 {
14031         struct community_entry *entry;
14032
14033         for (entry = list->head; entry; entry = entry->next) {
14034                 if (entry == list->head) {
14035                         if (all_digit(list->name))
14036                                 vty_out(vty, "Community %s list %s\n",
14037                                         entry->style == COMMUNITY_LIST_STANDARD
14038                                                 ? "standard"
14039                                                 : "(expanded) access",
14040                                         list->name);
14041                         else
14042                                 vty_out(vty, "Named Community %s list %s\n",
14043                                         entry->style == COMMUNITY_LIST_STANDARD
14044                                                 ? "standard"
14045                                                 : "expanded",
14046                                         list->name);
14047                 }
14048                 if (entry->any)
14049                         vty_out(vty, "    %s\n",
14050                                 community_direct_str(entry->direct));
14051                 else
14052                         vty_out(vty, "    %s %s\n",
14053                                 community_direct_str(entry->direct),
14054                                 community_list_config_str(entry));
14055         }
14056 }
14057
14058 DEFUN (show_community_list,
14059        show_bgp_community_list_cmd,
14060        "show bgp community-list",
14061        SHOW_STR
14062        BGP_STR
14063        "List community-list\n")
14064 {
14065         struct community_list *list;
14066         struct community_list_master *cm;
14067
14068         int idx = 0;
14069         if (argv_find(argv, argc, "ip", &idx)) {
14070                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14071                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14072                 vty_out(vty, "'show bgp community-list <(1-500)|WORD>'\n");
14073                 zlog_warn("Deprecated option: 'ip show community-list <(1-500)|WORD>' being used");
14074         }
14075         cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
14076         if (!cm)
14077                 return CMD_SUCCESS;
14078
14079         for (list = cm->num.head; list; list = list->next)
14080                 community_list_show(vty, list);
14081
14082         for (list = cm->str.head; list; list = list->next)
14083                 community_list_show(vty, list);
14084
14085         return CMD_SUCCESS;
14086 }
14087
14088 ALIAS (show_community_list,
14089        show_ip_community_list_cmd,
14090        "show ip community-list",
14091        SHOW_STR
14092        IP_STR
14093        "List community-list\n")
14094
14095 DEFUN (show_community_list_arg,
14096        show_bgp_community_list_arg_cmd,
14097        "show bgp community-list <(1-500)|WORD>",
14098        SHOW_STR
14099        BGP_STR
14100        "List community-list\n"
14101        "Community-list number\n"
14102        "Community-list name\n")
14103 {
14104         int idx_comm_list = 3;
14105         struct community_list *list;
14106
14107         int idx = 0;
14108         if (argv_find(argv, argc, "ip", &idx)) {
14109                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14110                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14111                 vty_out(vty, "'show bgp community-list <(1-500)|WORD>'\n");
14112                 zlog_warn("Deprecated option: 'ip show community-list <(1-500)|WORD>' being used");
14113         }
14114         list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg,
14115                                      COMMUNITY_LIST_MASTER);
14116         if (!list) {
14117                 vty_out(vty, "%% Can't find community-list\n");
14118                 return CMD_WARNING;
14119         }
14120
14121         community_list_show(vty, list);
14122
14123         return CMD_SUCCESS;
14124 }
14125
14126 ALIAS (show_community_list_arg,
14127        show_ip_community_list_arg_cmd,
14128        "show ip community-list <(1-500)|WORD>",
14129        SHOW_STR
14130        IP_STR
14131        "List community-list\n"
14132        "Community-list number\n"
14133        "Community-list name\n")
14134
14135 /*
14136  * Large Community code.
14137  */
14138 static int lcommunity_list_set_vty(struct vty *vty, int argc,
14139                                    struct cmd_token **argv, int style,
14140                                    int reject_all_digit_name)
14141 {
14142         int ret;
14143         int direct;
14144         char *str;
14145         int idx = 0;
14146         char *cl_name;
14147
14148         if (argv_find(argv, argc, "ip", &idx)) {
14149                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14150                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14151                 vty_out(vty, "'bgp large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>'\n");
14152                 zlog_warn("Deprecated option: 'large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' being used");
14153         }
14154         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14155                                                        : COMMUNITY_DENY;
14156
14157         /* All digit name check.  */
14158         idx = 0;
14159         argv_find(argv, argc, "WORD", &idx);
14160         argv_find(argv, argc, "(1-99)", &idx);
14161         argv_find(argv, argc, "(100-500)", &idx);
14162         cl_name = argv[idx]->arg;
14163         if (reject_all_digit_name && all_digit(cl_name)) {
14164                 vty_out(vty, "%% Community name cannot have all digits\n");
14165                 return CMD_WARNING_CONFIG_FAILED;
14166         }
14167
14168         idx = 0;
14169         argv_find(argv, argc, "AA:BB:CC", &idx);
14170         argv_find(argv, argc, "LINE", &idx);
14171         /* Concat community string argument. */
14172         if (idx)
14173                 str = argv_concat(argv, argc, idx);
14174         else
14175                 str = NULL;
14176
14177         ret = lcommunity_list_set(bgp_clist, cl_name, str, direct, style);
14178
14179         /* Free temporary community list string allocated by
14180            argv_concat().  */
14181         if (str)
14182                 XFREE(MTYPE_TMP, str);
14183
14184         if (ret < 0) {
14185                 community_list_perror(vty, ret);
14186                 return CMD_WARNING_CONFIG_FAILED;
14187         }
14188         return CMD_SUCCESS;
14189 }
14190
14191 static int lcommunity_list_unset_vty(struct vty *vty, int argc,
14192                                      struct cmd_token **argv, int style)
14193 {
14194         int ret;
14195         int direct = 0;
14196         char *str = NULL;
14197         int idx = 0;
14198
14199         if (argv_find(argv, argc, "ip", &idx)) {
14200                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14201                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14202                 vty_out(vty, "'no bgp large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>'\n");
14203                 zlog_warn("Deprecated option: 'no ip large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' being used");
14204         }
14205         argv_find(argv, argc, "permit", &idx);
14206         argv_find(argv, argc, "deny", &idx);
14207
14208         if (idx) {
14209                 /* Check the list direct. */
14210                 if (strncmp(argv[idx]->arg, "p", 1) == 0)
14211                         direct = COMMUNITY_PERMIT;
14212                 else
14213                         direct = COMMUNITY_DENY;
14214
14215                 idx = 0;
14216                 argv_find(argv, argc, "LINE", &idx);
14217                 argv_find(argv, argc, "AA:AA:NN", &idx);
14218                 /* Concat community string argument.  */
14219                 str = argv_concat(argv, argc, idx);
14220         }
14221
14222         idx = 0;
14223         argv_find(argv, argc, "(1-99)", &idx);
14224         argv_find(argv, argc, "(100-500)", &idx);
14225         argv_find(argv, argc, "WORD", &idx);
14226
14227         /* Unset community list.  */
14228         ret = lcommunity_list_unset(bgp_clist, argv[idx]->arg, str, direct,
14229                                     style);
14230
14231         /* Free temporary community list string allocated by
14232            argv_concat().  */
14233         if (str)
14234                 XFREE(MTYPE_TMP, str);
14235
14236         if (ret < 0) {
14237                 community_list_perror(vty, ret);
14238                 return CMD_WARNING_CONFIG_FAILED;
14239         }
14240
14241         return CMD_SUCCESS;
14242 }
14243
14244 /* "large-community-list" keyword help string.  */
14245 #define LCOMMUNITY_LIST_STR "Add a large community list entry\n"
14246 #define LCOMMUNITY_VAL_STR  "large community in 'aa:bb:cc' format\n"
14247
14248 #if CONFDATE > 20191005
14249 CPP_NOTICE("bgpd: remove deprecated 'ip large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' command")
14250 #endif
14251 DEFUN (lcommunity_list_standard,
14252        bgp_lcommunity_list_standard_cmd,
14253        "bgp large-community-list (1-99) <deny|permit>",
14254        BGP_STR
14255        LCOMMUNITY_LIST_STR
14256        "Large Community list number (standard)\n"
14257        "Specify large community to reject\n"
14258        "Specify large community to accept\n")
14259 {
14260         return lcommunity_list_set_vty(vty, argc, argv,
14261                                        LARGE_COMMUNITY_LIST_STANDARD, 0);
14262 }
14263
14264 ALIAS (lcommunity_list_standard,
14265        ip_lcommunity_list_standard_cmd,
14266        "ip large-community-list (1-99) <deny|permit>",
14267        IP_STR
14268        LCOMMUNITY_LIST_STR
14269        "Large Community list number (standard)\n"
14270        "Specify large community to reject\n"
14271        "Specify large community to accept\n")
14272
14273 DEFUN (lcommunity_list_standard1,
14274        bgp_lcommunity_list_standard1_cmd,
14275        "bgp large-community-list (1-99) <deny|permit> AA:BB:CC...",
14276        BGP_STR
14277        LCOMMUNITY_LIST_STR
14278        "Large Community list number (standard)\n"
14279        "Specify large community to reject\n"
14280        "Specify large community to accept\n"
14281        LCOMMUNITY_VAL_STR)
14282 {
14283         return lcommunity_list_set_vty(vty, argc, argv,
14284                                        LARGE_COMMUNITY_LIST_STANDARD, 0);
14285 }
14286
14287 ALIAS (lcommunity_list_standard1,
14288        ip_lcommunity_list_standard1_cmd,
14289        "ip large-community-list (1-99) <deny|permit> AA:BB:CC...",
14290        IP_STR
14291        LCOMMUNITY_LIST_STR
14292        "Large Community list number (standard)\n"
14293        "Specify large community to reject\n"
14294        "Specify large community to accept\n"
14295        LCOMMUNITY_VAL_STR)
14296
14297 DEFUN (lcommunity_list_expanded,
14298        bgp_lcommunity_list_expanded_cmd,
14299        "bgp large-community-list (100-500) <deny|permit> LINE...",
14300        BGP_STR
14301        LCOMMUNITY_LIST_STR
14302        "Large Community list number (expanded)\n"
14303        "Specify large community to reject\n"
14304        "Specify large community to accept\n"
14305        "An ordered list as a regular-expression\n")
14306 {
14307         return lcommunity_list_set_vty(vty, argc, argv,
14308                                        LARGE_COMMUNITY_LIST_EXPANDED, 0);
14309 }
14310
14311 ALIAS (lcommunity_list_expanded,
14312        ip_lcommunity_list_expanded_cmd,
14313        "ip large-community-list (100-500) <deny|permit> LINE...",
14314        IP_STR
14315        LCOMMUNITY_LIST_STR
14316        "Large Community list number (expanded)\n"
14317        "Specify large community to reject\n"
14318        "Specify large community to accept\n"
14319        "An ordered list as a regular-expression\n")
14320
14321 DEFUN (lcommunity_list_name_standard,
14322        bgp_lcommunity_list_name_standard_cmd,
14323        "bgp large-community-list standard WORD <deny|permit>",
14324        BGP_STR
14325        LCOMMUNITY_LIST_STR
14326        "Specify standard large-community-list\n"
14327        "Large Community list name\n"
14328        "Specify large community to reject\n"
14329        "Specify large community to accept\n")
14330 {
14331         return lcommunity_list_set_vty(vty, argc, argv,
14332                                        LARGE_COMMUNITY_LIST_STANDARD, 1);
14333 }
14334
14335 ALIAS (lcommunity_list_name_standard,
14336        ip_lcommunity_list_name_standard_cmd,
14337        "ip large-community-list standard WORD <deny|permit>",
14338        IP_STR
14339        LCOMMUNITY_LIST_STR
14340        "Specify standard large-community-list\n"
14341        "Large Community list name\n"
14342        "Specify large community to reject\n"
14343        "Specify large community to accept\n")
14344
14345 DEFUN (lcommunity_list_name_standard1,
14346        bgp_lcommunity_list_name_standard1_cmd,
14347        "bgp large-community-list standard WORD <deny|permit> AA:BB:CC...",
14348        BGP_STR
14349        LCOMMUNITY_LIST_STR
14350        "Specify standard large-community-list\n"
14351        "Large Community list name\n"
14352        "Specify large community to reject\n"
14353        "Specify large community to accept\n"
14354        LCOMMUNITY_VAL_STR)
14355 {
14356         return lcommunity_list_set_vty(vty, argc, argv,
14357                                        LARGE_COMMUNITY_LIST_STANDARD, 1);
14358 }
14359
14360 ALIAS (lcommunity_list_name_standard1,
14361        ip_lcommunity_list_name_standard1_cmd,
14362        "ip large-community-list standard WORD <deny|permit> AA:BB:CC...",
14363        IP_STR
14364        LCOMMUNITY_LIST_STR
14365        "Specify standard large-community-list\n"
14366        "Large Community list name\n"
14367        "Specify large community to reject\n"
14368        "Specify large community to accept\n"
14369        LCOMMUNITY_VAL_STR)
14370
14371 DEFUN (lcommunity_list_name_expanded,
14372        bgp_lcommunity_list_name_expanded_cmd,
14373        "bgp large-community-list expanded WORD <deny|permit> LINE...",
14374        BGP_STR
14375        LCOMMUNITY_LIST_STR
14376        "Specify expanded large-community-list\n"
14377        "Large Community list name\n"
14378        "Specify large community to reject\n"
14379        "Specify large community to accept\n"
14380        "An ordered list as a regular-expression\n")
14381 {
14382         return lcommunity_list_set_vty(vty, argc, argv,
14383                                        LARGE_COMMUNITY_LIST_EXPANDED, 1);
14384 }
14385
14386 ALIAS (lcommunity_list_name_expanded,
14387        ip_lcommunity_list_name_expanded_cmd,
14388        "ip large-community-list expanded WORD <deny|permit> LINE...",
14389        IP_STR
14390        LCOMMUNITY_LIST_STR
14391        "Specify expanded large-community-list\n"
14392        "Large Community list name\n"
14393        "Specify large community to reject\n"
14394        "Specify large community to accept\n"
14395        "An ordered list as a regular-expression\n")
14396
14397 DEFUN (no_lcommunity_list_standard_all,
14398        no_bgp_lcommunity_list_standard_all_cmd,
14399        "no bgp large-community-list <(1-99)|(100-500)|WORD>",
14400        NO_STR
14401        BGP_STR
14402        LCOMMUNITY_LIST_STR
14403        "Large Community list number (standard)\n"
14404        "Large Community list number (expanded)\n"
14405        "Large Community list name\n")
14406 {
14407         return lcommunity_list_unset_vty(vty, argc, argv,
14408                                          LARGE_COMMUNITY_LIST_STANDARD);
14409 }
14410
14411 ALIAS (no_lcommunity_list_standard_all,
14412        no_ip_lcommunity_list_standard_all_cmd,
14413        "no ip large-community-list <(1-99)|(100-500)|WORD>",
14414        NO_STR
14415        IP_STR
14416        LCOMMUNITY_LIST_STR
14417        "Large Community list number (standard)\n"
14418        "Large Community list number (expanded)\n"
14419        "Large Community list name\n")
14420
14421 DEFUN (no_lcommunity_list_name_expanded_all,
14422        no_bgp_lcommunity_list_name_expanded_all_cmd,
14423        "no bgp large-community-list expanded WORD",
14424        NO_STR
14425        BGP_STR
14426        LCOMMUNITY_LIST_STR
14427        "Specify expanded large-community-list\n"
14428        "Large Community list name\n")
14429 {
14430         return lcommunity_list_unset_vty(vty, argc, argv,
14431                                          LARGE_COMMUNITY_LIST_EXPANDED);
14432 }
14433
14434 ALIAS (no_lcommunity_list_name_expanded_all,
14435        no_ip_lcommunity_list_name_expanded_all_cmd,
14436        "no ip large-community-list expanded WORD",
14437        NO_STR
14438        IP_STR
14439        LCOMMUNITY_LIST_STR
14440        "Specify expanded large-community-list\n"
14441        "Large Community list name\n")
14442
14443 DEFUN (no_lcommunity_list_standard,
14444        no_bgp_lcommunity_list_standard_cmd,
14445        "no bgp large-community-list (1-99) <deny|permit> AA:AA:NN...",
14446        NO_STR
14447        BGP_STR
14448        LCOMMUNITY_LIST_STR
14449        "Large Community list number (standard)\n"
14450        "Specify large community to reject\n"
14451        "Specify large community to accept\n"
14452        LCOMMUNITY_VAL_STR)
14453 {
14454         return lcommunity_list_unset_vty(vty, argc, argv,
14455                                          LARGE_COMMUNITY_LIST_STANDARD);
14456 }
14457
14458 ALIAS (no_lcommunity_list_standard,
14459        no_ip_lcommunity_list_standard_cmd,
14460        "no ip large-community-list (1-99) <deny|permit> AA:AA:NN...",
14461        NO_STR
14462        IP_STR
14463        LCOMMUNITY_LIST_STR
14464        "Large Community list number (standard)\n"
14465        "Specify large community to reject\n"
14466        "Specify large community to accept\n"
14467        LCOMMUNITY_VAL_STR)
14468
14469 DEFUN (no_lcommunity_list_expanded,
14470        no_bgp_lcommunity_list_expanded_cmd,
14471        "no bgp large-community-list (100-500) <deny|permit> LINE...",
14472        NO_STR
14473        BGP_STR
14474        LCOMMUNITY_LIST_STR
14475        "Large Community list number (expanded)\n"
14476        "Specify large community to reject\n"
14477        "Specify large community to accept\n"
14478        "An ordered list as a regular-expression\n")
14479 {
14480         return lcommunity_list_unset_vty(vty, argc, argv,
14481                                          LARGE_COMMUNITY_LIST_EXPANDED);
14482 }
14483
14484 ALIAS (no_lcommunity_list_expanded,
14485        no_ip_lcommunity_list_expanded_cmd,
14486        "no ip large-community-list (100-500) <deny|permit> LINE...",
14487        NO_STR
14488        IP_STR
14489        LCOMMUNITY_LIST_STR
14490        "Large Community list number (expanded)\n"
14491        "Specify large community to reject\n"
14492        "Specify large community to accept\n"
14493        "An ordered list as a regular-expression\n")
14494
14495 DEFUN (no_lcommunity_list_name_standard,
14496        no_bgp_lcommunity_list_name_standard_cmd,
14497        "no bgp large-community-list standard WORD <deny|permit> AA:AA:NN...",
14498        NO_STR
14499        BGP_STR
14500        LCOMMUNITY_LIST_STR
14501        "Specify standard large-community-list\n"
14502        "Large Community list name\n"
14503        "Specify large community to reject\n"
14504        "Specify large community to accept\n"
14505        LCOMMUNITY_VAL_STR)
14506 {
14507         return lcommunity_list_unset_vty(vty, argc, argv,
14508                                          LARGE_COMMUNITY_LIST_STANDARD);
14509 }
14510
14511 ALIAS (no_lcommunity_list_name_standard,
14512        no_ip_lcommunity_list_name_standard_cmd,
14513        "no ip large-community-list standard WORD <deny|permit> AA:AA:NN...",
14514        NO_STR
14515        IP_STR
14516        LCOMMUNITY_LIST_STR
14517        "Specify standard large-community-list\n"
14518        "Large Community list name\n"
14519        "Specify large community to reject\n"
14520        "Specify large community to accept\n"
14521        LCOMMUNITY_VAL_STR)
14522
14523 DEFUN (no_lcommunity_list_name_expanded,
14524        no_bgp_lcommunity_list_name_expanded_cmd,
14525        "no bgp large-community-list expanded WORD <deny|permit> LINE...",
14526        NO_STR
14527        BGP_STR
14528        LCOMMUNITY_LIST_STR
14529        "Specify expanded large-community-list\n"
14530        "Large community list name\n"
14531        "Specify large community to reject\n"
14532        "Specify large community to accept\n"
14533        "An ordered list as a regular-expression\n")
14534 {
14535         return lcommunity_list_unset_vty(vty, argc, argv,
14536                                          LARGE_COMMUNITY_LIST_EXPANDED);
14537 }
14538
14539 ALIAS (no_lcommunity_list_name_expanded,
14540        no_ip_lcommunity_list_name_expanded_cmd,
14541        "no ip large-community-list expanded WORD <deny|permit> LINE...",
14542        NO_STR
14543        IP_STR
14544        LCOMMUNITY_LIST_STR
14545        "Specify expanded large-community-list\n"
14546        "Large community list name\n"
14547        "Specify large community to reject\n"
14548        "Specify large community to accept\n"
14549        "An ordered list as a regular-expression\n")
14550
14551 static void lcommunity_list_show(struct vty *vty, struct community_list *list)
14552 {
14553         struct community_entry *entry;
14554
14555         for (entry = list->head; entry; entry = entry->next) {
14556                 if (entry == list->head) {
14557                         if (all_digit(list->name))
14558                                 vty_out(vty, "Large community %s list %s\n",
14559                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
14560                                                 ? "standard"
14561                                                 : "(expanded) access",
14562                                         list->name);
14563                         else
14564                                 vty_out(vty,
14565                                         "Named large community %s list %s\n",
14566                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
14567                                                 ? "standard"
14568                                                 : "expanded",
14569                                         list->name);
14570                 }
14571                 if (entry->any)
14572                         vty_out(vty, "    %s\n",
14573                                 community_direct_str(entry->direct));
14574                 else
14575                         vty_out(vty, "    %s %s\n",
14576                                 community_direct_str(entry->direct),
14577                                 community_list_config_str(entry));
14578         }
14579 }
14580
14581 DEFUN (show_lcommunity_list,
14582        show_bgp_lcommunity_list_cmd,
14583        "show bgp large-community-list",
14584        SHOW_STR
14585        BGP_STR
14586        "List large-community list\n")
14587 {
14588         struct community_list *list;
14589         struct community_list_master *cm;
14590         int idx = 0;
14591
14592         if (argv_find(argv, argc, "ip", &idx)) {
14593                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14594                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14595                 vty_out(vty, "'show bgp large-community-list <(1-500)|WORD>'\n");
14596                 zlog_warn("Deprecated option: 'ip show large-community-list <(1-500)|WORD>' being used");
14597         }
14598
14599         cm = community_list_master_lookup(bgp_clist,
14600                                           LARGE_COMMUNITY_LIST_MASTER);
14601         if (!cm)
14602                 return CMD_SUCCESS;
14603
14604         for (list = cm->num.head; list; list = list->next)
14605                 lcommunity_list_show(vty, list);
14606
14607         for (list = cm->str.head; list; list = list->next)
14608                 lcommunity_list_show(vty, list);
14609
14610         return CMD_SUCCESS;
14611 }
14612
14613 ALIAS (show_lcommunity_list,
14614        show_ip_lcommunity_list_cmd,
14615        "show ip large-community-list",
14616        SHOW_STR
14617        IP_STR
14618        "List large-community list\n")
14619
14620 DEFUN (show_lcommunity_list_arg,
14621        show_bgp_lcommunity_list_arg_cmd,
14622        "show bgp large-community-list <(1-500)|WORD>",
14623        SHOW_STR
14624        BGP_STR
14625        "List large-community list\n"
14626        "large-community-list number\n"
14627        "large-community-list name\n")
14628 {
14629         struct community_list *list;
14630         int idx = 0;
14631
14632         if (argv_find(argv, argc, "ip", &idx)) {
14633                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14634                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14635                 vty_out(vty, "'show bgp large-community-list <(1-500)|WORD>'\n");
14636                 zlog_warn("Deprecated option: 'ip show large-community-list <(1-500)|WORD>' being used");
14637         }
14638
14639         list = community_list_lookup(bgp_clist, argv[3]->arg,
14640                                      LARGE_COMMUNITY_LIST_MASTER);
14641         if (!list) {
14642                 vty_out(vty, "%% Can't find extcommunity-list\n");
14643                 return CMD_WARNING;
14644         }
14645
14646         lcommunity_list_show(vty, list);
14647
14648         return CMD_SUCCESS;
14649 }
14650
14651 ALIAS (show_lcommunity_list_arg,
14652        show_ip_lcommunity_list_arg_cmd,
14653        "show ip large-community-list <(1-500)|WORD>",
14654        SHOW_STR
14655        IP_STR
14656        "List large-community list\n"
14657        "large-community-list number\n"
14658        "large-community-list name\n")
14659
14660 /* "extcommunity-list" keyword help string.  */
14661 #define EXTCOMMUNITY_LIST_STR "Add a extended community list entry\n"
14662 #define EXTCOMMUNITY_VAL_STR  "Extended community attribute in 'rt aa:nn_or_IPaddr:nn' OR 'soo aa:nn_or_IPaddr:nn' format\n"
14663
14664 DEFUN (extcommunity_list_standard,
14665        bgp_extcommunity_list_standard_cmd,
14666        "bgp extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14667        BGP_STR
14668        EXTCOMMUNITY_LIST_STR
14669        "Extended Community list number (standard)\n"
14670        "Specify standard extcommunity-list\n"
14671        "Community list name\n"
14672        "Specify community to reject\n"
14673        "Specify community to accept\n"
14674        EXTCOMMUNITY_VAL_STR)
14675 {
14676         int style = EXTCOMMUNITY_LIST_STANDARD;
14677         int direct = 0;
14678         char *cl_number_or_name = NULL;
14679
14680         int idx = 0;
14681         if (argv_find(argv, argc, "ip", &idx)) {
14682                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14683                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14684                 vty_out(vty, "'bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
14685                 zlog_warn("Deprecated option: 'ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
14686         }
14687         argv_find(argv, argc, "(1-99)", &idx);
14688         argv_find(argv, argc, "WORD", &idx);
14689         cl_number_or_name = argv[idx]->arg;
14690         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14691                                                        : COMMUNITY_DENY;
14692         argv_find(argv, argc, "AA:NN", &idx);
14693         char *str = argv_concat(argv, argc, idx);
14694
14695         int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str,
14696                                         direct, style);
14697
14698         XFREE(MTYPE_TMP, str);
14699
14700         if (ret < 0) {
14701                 community_list_perror(vty, ret);
14702                 return CMD_WARNING_CONFIG_FAILED;
14703         }
14704
14705         return CMD_SUCCESS;
14706 }
14707
14708 #if CONFDATE > 20191005
14709 CPP_NOTICE("bgpd: remove deprecated 'ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' command")
14710 #endif
14711 ALIAS (extcommunity_list_standard,
14712        ip_extcommunity_list_standard_cmd,
14713        "ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14714        IP_STR
14715        EXTCOMMUNITY_LIST_STR
14716        "Extended Community list number (standard)\n"
14717        "Specify standard extcommunity-list\n"
14718        "Community list name\n"
14719        "Specify community to reject\n"
14720        "Specify community to accept\n"
14721        EXTCOMMUNITY_VAL_STR)
14722
14723 DEFUN (extcommunity_list_name_expanded,
14724        bgp_extcommunity_list_name_expanded_cmd,
14725        "bgp extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
14726        BGP_STR
14727        EXTCOMMUNITY_LIST_STR
14728        "Extended Community list number (expanded)\n"
14729        "Specify expanded extcommunity-list\n"
14730        "Extended Community list name\n"
14731        "Specify community to reject\n"
14732        "Specify community to accept\n"
14733        "An ordered list as a regular-expression\n")
14734 {
14735         int style = EXTCOMMUNITY_LIST_EXPANDED;
14736         int direct = 0;
14737         char *cl_number_or_name = NULL;
14738
14739         int idx = 0;
14740         if (argv_find(argv, argc, "ip", &idx)) {
14741                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14742                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14743                 vty_out(vty, "'extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
14744                 zlog_warn("Deprecated option: ‘ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
14745         }
14746
14747         argv_find(argv, argc, "(100-500)", &idx);
14748         argv_find(argv, argc, "WORD", &idx);
14749         cl_number_or_name = argv[idx]->arg;
14750         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14751                                                        : COMMUNITY_DENY;
14752         argv_find(argv, argc, "LINE", &idx);
14753         char *str = argv_concat(argv, argc, idx);
14754
14755         int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str,
14756                                         direct, style);
14757
14758         XFREE(MTYPE_TMP, str);
14759
14760         if (ret < 0) {
14761                 community_list_perror(vty, ret);
14762                 return CMD_WARNING_CONFIG_FAILED;
14763         }
14764
14765         return CMD_SUCCESS;
14766 }
14767
14768 ALIAS (extcommunity_list_name_expanded,
14769        ip_extcommunity_list_name_expanded_cmd,
14770        "ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
14771        IP_STR
14772        EXTCOMMUNITY_LIST_STR
14773        "Extended Community list number (expanded)\n"
14774        "Specify expanded extcommunity-list\n"
14775        "Extended Community list name\n"
14776        "Specify community to reject\n"
14777        "Specify community to accept\n"
14778        "An ordered list as a regular-expression\n")
14779
14780 DEFUN (no_extcommunity_list_standard_all,
14781        no_bgp_extcommunity_list_standard_all_cmd,
14782        "no bgp extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14783        NO_STR
14784        BGP_STR
14785        EXTCOMMUNITY_LIST_STR
14786        "Extended Community list number (standard)\n"
14787        "Specify standard extcommunity-list\n"
14788        "Community list name\n"
14789        "Specify community to reject\n"
14790        "Specify community to accept\n"
14791        EXTCOMMUNITY_VAL_STR)
14792 {
14793         int style = EXTCOMMUNITY_LIST_STANDARD;
14794         int direct = 0;
14795         char *cl_number_or_name = NULL;
14796
14797         int idx = 0;
14798         if (argv_find(argv, argc, "ip", &idx)) {
14799                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
14800                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14801                 vty_out(vty, "'no bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
14802                 zlog_warn("Deprecated option: ‘no ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
14803         }
14804         argv_find(argv, argc, "(1-99)", &idx);
14805         argv_find(argv, argc, "WORD", &idx);
14806         cl_number_or_name = argv[idx]->arg;
14807         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14808                                                        : COMMUNITY_DENY;
14809         argv_find(argv, argc, "AA:NN", &idx);
14810         char *str = argv_concat(argv, argc, idx);
14811
14812         int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
14813                                           direct, style);
14814
14815         XFREE(MTYPE_TMP, str);
14816
14817         if (ret < 0) {
14818                 community_list_perror(vty, ret);
14819                 return CMD_WARNING_CONFIG_FAILED;
14820         }
14821
14822         return CMD_SUCCESS;
14823 }
14824
14825 ALIAS (no_extcommunity_list_standard_all,
14826        no_ip_extcommunity_list_standard_all_cmd,
14827        "no ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14828        NO_STR
14829        IP_STR
14830        EXTCOMMUNITY_LIST_STR
14831        "Extended Community list number (standard)\n"
14832        "Specify standard extcommunity-list\n"
14833        "Community list name\n"
14834        "Specify community to reject\n"
14835        "Specify community to accept\n"
14836        EXTCOMMUNITY_VAL_STR)
14837
14838 DEFUN (no_extcommunity_list_expanded_all,
14839        no_bgp_extcommunity_list_expanded_all_cmd,
14840        "no bgp extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
14841        NO_STR
14842        BGP_STR
14843        EXTCOMMUNITY_LIST_STR
14844        "Extended Community list number (expanded)\n"
14845        "Specify expanded extcommunity-list\n"
14846        "Extended Community list name\n"
14847        "Specify community to reject\n"
14848        "Specify community to accept\n"
14849        "An ordered list as a regular-expression\n")
14850 {
14851         int style = EXTCOMMUNITY_LIST_EXPANDED;
14852         int direct = 0;
14853         char *cl_number_or_name = NULL;
14854
14855         int idx = 0;
14856         if (argv_find(argv, argc, "ip", &idx)) {
14857                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14858                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14859                 vty_out(vty, "'no bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
14860                 zlog_warn("Deprecated option: ‘no ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
14861         }
14862         argv_find(argv, argc, "(100-500)", &idx);
14863         argv_find(argv, argc, "WORD", &idx);
14864         cl_number_or_name = argv[idx]->arg;
14865         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14866                                                        : COMMUNITY_DENY;
14867         argv_find(argv, argc, "LINE", &idx);
14868         char *str = argv_concat(argv, argc, idx);
14869
14870         int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
14871                                           direct, style);
14872
14873         XFREE(MTYPE_TMP, str);
14874
14875         if (ret < 0) {
14876                 community_list_perror(vty, ret);
14877                 return CMD_WARNING_CONFIG_FAILED;
14878         }
14879
14880         return CMD_SUCCESS;
14881 }
14882
14883 ALIAS (no_extcommunity_list_expanded_all,
14884        no_ip_extcommunity_list_expanded_all_cmd,
14885        "no ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
14886        NO_STR
14887        IP_STR
14888        EXTCOMMUNITY_LIST_STR
14889        "Extended Community list number (expanded)\n"
14890        "Specify expanded extcommunity-list\n"
14891        "Extended Community list name\n"
14892        "Specify community to reject\n"
14893        "Specify community to accept\n"
14894        "An ordered list as a regular-expression\n")
14895
14896 static void extcommunity_list_show(struct vty *vty, struct community_list *list)
14897 {
14898         struct community_entry *entry;
14899
14900         for (entry = list->head; entry; entry = entry->next) {
14901                 if (entry == list->head) {
14902                         if (all_digit(list->name))
14903                                 vty_out(vty, "Extended community %s list %s\n",
14904                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
14905                                                 ? "standard"
14906                                                 : "(expanded) access",
14907                                         list->name);
14908                         else
14909                                 vty_out(vty,
14910                                         "Named extended community %s list %s\n",
14911                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
14912                                                 ? "standard"
14913                                                 : "expanded",
14914                                         list->name);
14915                 }
14916                 if (entry->any)
14917                         vty_out(vty, "    %s\n",
14918                                 community_direct_str(entry->direct));
14919                 else
14920                         vty_out(vty, "    %s %s\n",
14921                                 community_direct_str(entry->direct),
14922                                 community_list_config_str(entry));
14923         }
14924 }
14925
14926 DEFUN (show_extcommunity_list,
14927        show_bgp_extcommunity_list_cmd,
14928        "show bgp extcommunity-list",
14929        SHOW_STR
14930        BGP_STR
14931        "List extended-community list\n")
14932 {
14933         struct community_list *list;
14934         struct community_list_master *cm;
14935         int idx = 0;
14936
14937         if (argv_find(argv, argc, "ip", &idx)) {
14938                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
14939                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14940                 vty_out(vty, "'show bgp extcommunity-list <(1-500)|WORD>'\n");
14941                 zlog_warn("Deprecated option: 'ip show extcommunity-list <(1-500)|WORD>' being used");
14942         }
14943         cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
14944         if (!cm)
14945                 return CMD_SUCCESS;
14946
14947         for (list = cm->num.head; list; list = list->next)
14948                 extcommunity_list_show(vty, list);
14949
14950         for (list = cm->str.head; list; list = list->next)
14951                 extcommunity_list_show(vty, list);
14952
14953         return CMD_SUCCESS;
14954 }
14955
14956 ALIAS (show_extcommunity_list,
14957        show_ip_extcommunity_list_cmd,
14958        "show ip extcommunity-list",
14959        SHOW_STR
14960        IP_STR
14961        "List extended-community list\n")
14962
14963 DEFUN (show_extcommunity_list_arg,
14964        show_bgp_extcommunity_list_arg_cmd,
14965        "show bgp extcommunity-list <(1-500)|WORD>",
14966        SHOW_STR
14967        BGP_STR
14968        "List extended-community list\n"
14969        "Extcommunity-list number\n"
14970        "Extcommunity-list name\n")
14971 {
14972         int idx_comm_list = 3;
14973         struct community_list *list;
14974         int idx = 0;
14975
14976         if (argv_find(argv, argc, "ip", &idx)) {
14977                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14978                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14979                 vty_out(vty, "'show bgp extcommunity-list <(1-500)|WORD>'\n");
14980                 zlog_warn("Deprecated option: 'ip show extcommunity-list <(1-500)|WORD>' being used");
14981         }
14982         list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg,
14983                                      EXTCOMMUNITY_LIST_MASTER);
14984         if (!list) {
14985                 vty_out(vty, "%% Can't find extcommunity-list\n");
14986                 return CMD_WARNING;
14987         }
14988
14989         extcommunity_list_show(vty, list);
14990
14991         return CMD_SUCCESS;
14992 }
14993
14994 ALIAS (show_extcommunity_list_arg,
14995        show_ip_extcommunity_list_arg_cmd,
14996        "show ip extcommunity-list <(1-500)|WORD>",
14997        SHOW_STR
14998        IP_STR
14999        "List extended-community list\n"
15000        "Extcommunity-list number\n"
15001        "Extcommunity-list name\n")
15002
15003 /* Display community-list and extcommunity-list configuration.  */
15004 static int community_list_config_write(struct vty *vty)
15005 {
15006         struct community_list *list;
15007         struct community_entry *entry;
15008         struct community_list_master *cm;
15009         int write = 0;
15010
15011         /* Community-list.  */
15012         cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
15013
15014         for (list = cm->num.head; list; list = list->next)
15015                 for (entry = list->head; entry; entry = entry->next) {
15016                         vty_out(vty, "bgp community-list %s %s %s\n", list->name,
15017                                 community_direct_str(entry->direct),
15018                                 community_list_config_str(entry));
15019                         write++;
15020                 }
15021         for (list = cm->str.head; list; list = list->next)
15022                 for (entry = list->head; entry; entry = entry->next) {
15023                         vty_out(vty, "bgp community-list %s %s %s %s\n",
15024                                 entry->style == COMMUNITY_LIST_STANDARD
15025                                         ? "standard"
15026                                         : "expanded",
15027                                 list->name, community_direct_str(entry->direct),
15028                                 community_list_config_str(entry));
15029                         write++;
15030                 }
15031
15032         /* Extcommunity-list.  */
15033         cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
15034
15035         for (list = cm->num.head; list; list = list->next)
15036                 for (entry = list->head; entry; entry = entry->next) {
15037                         vty_out(vty, "bgp extcommunity-list %s %s %s\n",
15038                                 list->name, community_direct_str(entry->direct),
15039                                 community_list_config_str(entry));
15040                         write++;
15041                 }
15042         for (list = cm->str.head; list; list = list->next)
15043                 for (entry = list->head; entry; entry = entry->next) {
15044                         vty_out(vty, "bgp extcommunity-list %s %s %s %s\n",
15045                                 entry->style == EXTCOMMUNITY_LIST_STANDARD
15046                                         ? "standard"
15047                                         : "expanded",
15048                                 list->name, community_direct_str(entry->direct),
15049                                 community_list_config_str(entry));
15050                         write++;
15051                 }
15052
15053
15054         /* lcommunity-list.  */
15055         cm = community_list_master_lookup(bgp_clist,
15056                                           LARGE_COMMUNITY_LIST_MASTER);
15057
15058         for (list = cm->num.head; list; list = list->next)
15059                 for (entry = list->head; entry; entry = entry->next) {
15060                         vty_out(vty, "bgp large-community-list %s %s %s\n",
15061                                 list->name, community_direct_str(entry->direct),
15062                                 community_list_config_str(entry));
15063                         write++;
15064                 }
15065         for (list = cm->str.head; list; list = list->next)
15066                 for (entry = list->head; entry; entry = entry->next) {
15067                         vty_out(vty, "bgp large-community-list %s %s %s %s\n",
15068                                 entry->style == LARGE_COMMUNITY_LIST_STANDARD
15069                                         ? "standard"
15070                                         : "expanded",
15071                                 list->name, community_direct_str(entry->direct),
15072                                 community_list_config_str(entry));
15073                         write++;
15074                 }
15075
15076         return write;
15077 }
15078
15079 static struct cmd_node community_list_node = {
15080         COMMUNITY_LIST_NODE, "", 1 /* Export to vtysh.  */
15081 };
15082
15083 static void community_list_vty(void)
15084 {
15085         install_node(&community_list_node, community_list_config_write);
15086
15087         /* Community-list.  */
15088         install_element(CONFIG_NODE, &bgp_community_list_standard_cmd);
15089         install_element(CONFIG_NODE, &bgp_community_list_expanded_all_cmd);
15090         install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_cmd);
15091         install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_cmd);
15092         install_element(VIEW_NODE, &show_bgp_community_list_cmd);
15093         install_element(VIEW_NODE, &show_bgp_community_list_arg_cmd);
15094         install_element(CONFIG_NODE, &ip_community_list_standard_cmd);
15095         install_element(CONFIG_NODE, &ip_community_list_expanded_all_cmd);
15096         install_element(CONFIG_NODE, &no_ip_community_list_standard_all_cmd);
15097         install_element(CONFIG_NODE, &no_ip_community_list_expanded_all_cmd);
15098         install_element(VIEW_NODE, &show_ip_community_list_cmd);
15099         install_element(VIEW_NODE, &show_ip_community_list_arg_cmd);
15100
15101         /* Extcommunity-list.  */
15102         install_element(CONFIG_NODE, &bgp_extcommunity_list_standard_cmd);
15103         install_element(CONFIG_NODE, &bgp_extcommunity_list_name_expanded_cmd);
15104         install_element(CONFIG_NODE, &no_bgp_extcommunity_list_standard_all_cmd);
15105         install_element(CONFIG_NODE, &no_bgp_extcommunity_list_expanded_all_cmd);
15106         install_element(VIEW_NODE, &show_bgp_extcommunity_list_cmd);
15107         install_element(VIEW_NODE, &show_bgp_extcommunity_list_arg_cmd);
15108         install_element(CONFIG_NODE, &ip_extcommunity_list_standard_cmd);
15109         install_element(CONFIG_NODE, &ip_extcommunity_list_name_expanded_cmd);
15110         install_element(CONFIG_NODE, &no_ip_extcommunity_list_standard_all_cmd);
15111         install_element(CONFIG_NODE, &no_ip_extcommunity_list_expanded_all_cmd);
15112         install_element(VIEW_NODE, &show_ip_extcommunity_list_cmd);
15113         install_element(VIEW_NODE, &show_ip_extcommunity_list_arg_cmd);
15114
15115         /* Large Community List */
15116         install_element(CONFIG_NODE, &bgp_lcommunity_list_standard_cmd);
15117         install_element(CONFIG_NODE, &bgp_lcommunity_list_standard1_cmd);
15118         install_element(CONFIG_NODE, &bgp_lcommunity_list_expanded_cmd);
15119         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard_cmd);
15120         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard1_cmd);
15121         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_expanded_cmd);
15122         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_all_cmd);
15123         install_element(CONFIG_NODE,
15124                         &no_bgp_lcommunity_list_name_expanded_all_cmd);
15125         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_cmd);
15126         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_expanded_cmd);
15127         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_standard_cmd);
15128         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_expanded_cmd);
15129         install_element(VIEW_NODE, &show_bgp_lcommunity_list_cmd);
15130         install_element(VIEW_NODE, &show_bgp_lcommunity_list_arg_cmd);
15131         install_element(CONFIG_NODE, &ip_lcommunity_list_standard_cmd);
15132         install_element(CONFIG_NODE, &ip_lcommunity_list_standard1_cmd);
15133         install_element(CONFIG_NODE, &ip_lcommunity_list_expanded_cmd);
15134         install_element(CONFIG_NODE, &ip_lcommunity_list_name_standard_cmd);
15135         install_element(CONFIG_NODE, &ip_lcommunity_list_name_standard1_cmd);
15136         install_element(CONFIG_NODE, &ip_lcommunity_list_name_expanded_cmd);
15137         install_element(CONFIG_NODE, &no_ip_lcommunity_list_standard_all_cmd);
15138         install_element(CONFIG_NODE,
15139                         &no_ip_lcommunity_list_name_expanded_all_cmd);
15140         install_element(CONFIG_NODE, &no_ip_lcommunity_list_standard_cmd);
15141         install_element(CONFIG_NODE, &no_ip_lcommunity_list_expanded_cmd);
15142         install_element(CONFIG_NODE, &no_ip_lcommunity_list_name_standard_cmd);
15143         install_element(CONFIG_NODE, &no_ip_lcommunity_list_name_expanded_cmd);
15144         install_element(VIEW_NODE, &show_ip_lcommunity_list_cmd);
15145         install_element(VIEW_NODE, &show_ip_lcommunity_list_arg_cmd);
15146 }