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 "lib/zclient.h"
  26 #include "prefix.h"
  27 #include "plist.h"
  28 #include "buffer.h"
  29 #include "linklist.h"
  30 #include "stream.h"
  31 #include "thread.h"
  32 #include "log.h"
  33 #include "memory.h"
  34 #include "memory_vty.h"
  35 #include "hash.h"
  36 #include "queue.h"
  37 #include "filter.h"
  38 #include "frrstr.h"
  39
  40 #include "bgpd/bgpd.h"
  41 #include "bgpd/bgp_attr_evpn.h"
  42 #include "bgpd/bgp_advertise.h"
  43 #include "bgpd/bgp_attr.h"
  44 #include "bgpd/bgp_aspath.h"
  45 #include "bgpd/bgp_community.h"
  46 #include "bgpd/bgp_ecommunity.h"
  47 #include "bgpd/bgp_lcommunity.h"
  48 #include "bgpd/bgp_damp.h"
  49 #include "bgpd/bgp_debug.h"
  50 #include "bgpd/bgp_errors.h"
  51 #include "bgpd/bgp_fsm.h"
  52 #include "bgpd/bgp_nexthop.h"
  53 #include "bgpd/bgp_open.h"
  54 #include "bgpd/bgp_regex.h"
  55 #include "bgpd/bgp_route.h"
  56 #include "bgpd/bgp_mplsvpn.h"
  57 #include "bgpd/bgp_zebra.h"
  58 #include "bgpd/bgp_table.h"
  59 #include "bgpd/bgp_vty.h"
  60 #include "bgpd/bgp_mpath.h"
  61 #include "bgpd/bgp_packet.h"
  62 #include "bgpd/bgp_updgrp.h"
  63 #include "bgpd/bgp_bfd.h"
  64 #include "bgpd/bgp_io.h"
  65 #include "bgpd/bgp_evpn.h"
  66 #include "bgpd/bgp_addpath.h"
  67 #include "bgpd/bgp_mac.h"
  68
  69 static struct peer_group *listen_range_exists(struct bgp *bgp,
  70                                               struct prefix *range, int exact);
  71
  72 static enum node_type bgp_node_type(afi_t afi, safi_t safi)
  73 {
  74         switch (afi) {
  75         case AFI_IP:
  76                 switch (safi) {
  77                 case SAFI_UNICAST:
  78                         return BGP_IPV4_NODE;
  79                         break;
  80                 case SAFI_MULTICAST:
  81                         return BGP_IPV4M_NODE;
  82                         break;
  83                 case SAFI_LABELED_UNICAST:
  84                         return BGP_IPV4L_NODE;
  85                         break;
  86                 case SAFI_MPLS_VPN:
  87                         return BGP_VPNV4_NODE;
  88                         break;
  89                 case SAFI_FLOWSPEC:
  90                         return BGP_FLOWSPECV4_NODE;
  91                 default:
  92                         /* not expected */
  93                         return BGP_IPV4_NODE;
  94                         break;
  95                 }
  96                 break;
  97         case AFI_IP6:
  98                 switch (safi) {
  99                 case SAFI_UNICAST:
 100                         return BGP_IPV6_NODE;
 101                         break;
 102                 case SAFI_MULTICAST:
 103                         return BGP_IPV6M_NODE;
 104                         break;
 105                 case SAFI_LABELED_UNICAST:
 106                         return BGP_IPV6L_NODE;
 107                         break;
 108                 case SAFI_MPLS_VPN:
 109                         return BGP_VPNV6_NODE;
 110                         break;
 111                 case SAFI_FLOWSPEC:
 112                         return BGP_FLOWSPECV6_NODE;
 113                 default:
 114                         /* not expected */
 115                         return BGP_IPV4_NODE;
 116                         break;
 117                 }
 118                 break;
 119         case AFI_L2VPN:
 120                 return BGP_EVPN_NODE;
 121                 break;
 122         case AFI_UNSPEC:
 123         case AFI_MAX:
 124                 // We should never be here but to clarify the switch statement..
 125                 return BGP_IPV4_NODE;
 126                 break;
 127         }
 128
 129         // Impossible to happen
 130         return BGP_IPV4_NODE;
 131 }
 132
 133 /* Utility function to get address family from current node.  */
 134 afi_t bgp_node_afi(struct vty *vty)
 135 {
 136         afi_t afi;
 137         switch (vty->node) {
 138         case BGP_IPV6_NODE:
 139         case BGP_IPV6M_NODE:
 140         case BGP_IPV6L_NODE:
 141         case BGP_VPNV6_NODE:
 142         case BGP_FLOWSPECV6_NODE:
 143                 afi = AFI_IP6;
 144                 break;
 145         case BGP_EVPN_NODE:
 146                 afi = AFI_L2VPN;
 147                 break;
 148         default:
 149                 afi = AFI_IP;
 150                 break;
 151         }
 152         return afi;
 153 }
 154
 155 /* Utility function to get subsequent address family from current
 156    node.  */
 157 safi_t bgp_node_safi(struct vty *vty)
 158 {
 159         safi_t safi;
 160         switch (vty->node) {
 161         case BGP_VPNV4_NODE:
 162         case BGP_VPNV6_NODE:
 163                 safi = SAFI_MPLS_VPN;
 164                 break;
 165         case BGP_IPV4M_NODE:
 166         case BGP_IPV6M_NODE:
 167                 safi = SAFI_MULTICAST;
 168                 break;
 169         case BGP_EVPN_NODE:
 170                 safi = SAFI_EVPN;
 171                 break;
 172         case BGP_IPV4L_NODE:
 173         case BGP_IPV6L_NODE:
 174                 safi = SAFI_LABELED_UNICAST;
 175                 break;
 176         case BGP_FLOWSPECV4_NODE:
 177         case BGP_FLOWSPECV6_NODE:
 178                 safi = SAFI_FLOWSPEC;
 179                 break;
 180         default:
 181                 safi = SAFI_UNICAST;
 182                 break;
 183         }
 184         return safi;
 185 }
 186
 187 /**
 188  * Converts an AFI in string form to afi_t
 189  *
 190  * @param afi string, one of
 191  *  - "ipv4"
 192  *  - "ipv6"
 193  *  - "l2vpn"
 194  * @return the corresponding afi_t
 195  */
 196 afi_t bgp_vty_afi_from_str(const char *afi_str)
 197 {
 198         afi_t afi = AFI_MAX; /* unknown */
 199         if (strmatch(afi_str, "ipv4"))
 200                 afi = AFI_IP;
 201         else if (strmatch(afi_str, "ipv6"))
 202                 afi = AFI_IP6;
 203         else if (strmatch(afi_str, "l2vpn"))
 204                 afi = AFI_L2VPN;
 205         return afi;
 206 }
 207
 208 int argv_find_and_parse_afi(struct cmd_token **argv, int argc, int *index,
 209                             afi_t *afi)
 210 {
 211         int ret = 0;
 212         if (argv_find(argv, argc, "ipv4", index)) {
 213                 ret = 1;
 214                 if (afi)
 215                         *afi = AFI_IP;
 216         } else if (argv_find(argv, argc, "ipv6", index)) {
 217                 ret = 1;
 218                 if (afi)
 219                         *afi = AFI_IP6;
 220         } else if (argv_find(argv, argc, "l2vpn", index)) {
 221                 ret = 1;
 222                 if (afi)
 223                         *afi = AFI_L2VPN;
 224         }
 225         return ret;
 226 }
 227
 228 /* supports <unicast|multicast|vpn|labeled-unicast> */
 229 safi_t bgp_vty_safi_from_str(const char *safi_str)
 230 {
 231         safi_t safi = SAFI_MAX; /* unknown */
 232         if (strmatch(safi_str, "multicast"))
 233                 safi = SAFI_MULTICAST;
 234         else if (strmatch(safi_str, "unicast"))
 235                 safi = SAFI_UNICAST;
 236         else if (strmatch(safi_str, "vpn"))
 237                 safi = SAFI_MPLS_VPN;
 238         else if (strmatch(safi_str, "evpn"))
 239                 safi = SAFI_EVPN;
 240         else if (strmatch(safi_str, "labeled-unicast"))
 241                 safi = SAFI_LABELED_UNICAST;
 242         else if (strmatch(safi_str, "flowspec"))
 243                 safi = SAFI_FLOWSPEC;
 244         return safi;
 245 }
 246
 247 int argv_find_and_parse_safi(struct cmd_token **argv, int argc, int *index,
 248                              safi_t *safi)
 249 {
 250         int ret = 0;
 251         if (argv_find(argv, argc, "unicast", index)) {
 252                 ret = 1;
 253                 if (safi)
 254                         *safi = SAFI_UNICAST;
 255         } else if (argv_find(argv, argc, "multicast", index)) {
 256                 ret = 1;
 257                 if (safi)
 258                         *safi = SAFI_MULTICAST;
 259         } else if (argv_find(argv, argc, "labeled-unicast", index)) {
 260                 ret = 1;
 261                 if (safi)
 262                         *safi = SAFI_LABELED_UNICAST;
 263         } else if (argv_find(argv, argc, "vpn", index)) {
 264                 ret = 1;
 265                 if (safi)
 266                         *safi = SAFI_MPLS_VPN;
 267         } else if (argv_find(argv, argc, "evpn", index)) {
 268                 ret = 1;
 269                 if (safi)
 270                         *safi = SAFI_EVPN;
 271         } else if (argv_find(argv, argc, "flowspec", index)) {
 272                 ret = 1;
 273                 if (safi)
 274                         *safi = SAFI_FLOWSPEC;
 275         }
 276         return ret;
 277 }
 278
 279 /*
 280  * bgp_vty_find_and_parse_afi_safi_bgp
 281  *
 282  * For a given 'show ...' command, correctly parse the afi/safi/bgp out from it
 283  * This function *assumes* that the calling function pre-sets the afi/safi/bgp
 284  * to appropriate values for the calling function.  This is to allow the
 285  * calling function to make decisions appropriate for the show command
 286  * that is being parsed.
 287  *
 288  * The show commands are generally of the form:
 289  * "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>
 290  * [<unicast|multicast|vpn|labeled-unicast>]] ..."
 291  *
 292  * Since we use argv_find if the show command in particular doesn't have:
 293  * [ip]
 294  * [<view|vrf> VIEWVRFNAME]
 295  * [<ipv4|ipv6> [<unicast|multicast|vpn|labeled-unicast>]]
 296  * The command parsing should still be ok.
 297  *
 298  * vty  -> The vty for the command so we can output some useful data in
 299  *         the event of a parse error in the vrf.
 300  * argv -> The command tokens
 301  * argc -> How many command tokens we have
 302  * idx  -> The current place in the command, generally should be 0 for this
 303  * function
 304  * afi  -> The parsed afi if it was included in the show command, returned here
 305  * safi -> The parsed safi if it was included in the show command, returned here
 306  * bgp  -> Pointer to the bgp data structure we need to fill in.
 307  * use_json -> json is configured or not
 308  *
 309  * The function returns the correct location in the parse tree for the
 310  * last token found.
 311  *
 312  * Returns 0 for failure to parse correctly, else the idx position of where
 313  * it found the last token.
 314  */
 315 int bgp_vty_find_and_parse_afi_safi_bgp(struct vty *vty,
 316                                         struct cmd_token **argv, int argc,
 317                                         int *idx, afi_t *afi, safi_t *safi,
 318                                         struct bgp **bgp, bool use_json)
 319 {
 320         char *vrf_name = NULL;
 321
 322         assert(afi);
 323         assert(safi);
 324         assert(bgp);
 325
 326         if (argv_find(argv, argc, "ip", idx))
 327                 *afi = AFI_IP;
 328
 329         if (argv_find(argv, argc, "view", idx))
 330                 vrf_name = argv[*idx + 1]->arg;
 331         else if (argv_find(argv, argc, "vrf", idx)) {
 332                 vrf_name = argv[*idx + 1]->arg;
 333                 if (strmatch(vrf_name, VRF_DEFAULT_NAME))
 334                         vrf_name = NULL;
 335         }
 336         if (vrf_name) {
 337                 if (strmatch(vrf_name, "all"))
 338                         *bgp = NULL;
 339                 else {
 340                         *bgp = bgp_lookup_by_name(vrf_name);
 341                         if (!*bgp) {
 342                                 if (use_json) {
 343                                         json_object *json = NULL;
 344                                         json = json_object_new_object();
 345                                         json_object_string_add(
 346                                           json, "warning",
 347                                           "View/Vrf is unknown");
 348                                         vty_out(vty, "%s\n",
 349                                                 json_object_to_json_string_ext(json,
 350                                                         JSON_C_TO_STRING_PRETTY));
 351                                         json_object_free(json);
 352                                 }
 353                                 else
 354                                         vty_out(vty, "View/Vrf %s is unknown\n",
 355                                                 vrf_name);
 356                                 *idx = 0;
 357                                 return 0;
 358                         }
 359                 }
 360         } else {
 361                 *bgp = bgp_get_default();
 362                 if (!*bgp) {
 363                         if (use_json) {
 364                                 json_object *json = NULL;
 365                                 json = json_object_new_object();
 366                                 json_object_string_add(
 367                                         json, "warning",
 368                                         "Default BGP instance not found");
 369                                 vty_out(vty, "%s\n",
 370                                         json_object_to_json_string_ext(json,
 371                                                 JSON_C_TO_STRING_PRETTY));
 372                                 json_object_free(json);
 373                         }
 374                         else
 375                                 vty_out(vty,
 376                                         "Default BGP instance not found\n");
 377                         *idx = 0;
 378                         return 0;
 379                 }
 380         }
 381
 382         if (argv_find_and_parse_afi(argv, argc, idx, afi))
 383                 argv_find_and_parse_safi(argv, argc, idx, safi);
 384
 385         *idx += 1;
 386         return *idx;
 387 }
 388
 389 static int peer_address_self_check(struct bgp *bgp, union sockunion *su)
 390 {
 391         struct interface *ifp = NULL;
 392
 393         if (su->sa.sa_family == AF_INET)
 394                 ifp = if_lookup_by_ipv4_exact(&su->sin.sin_addr, bgp->vrf_id);
 395         else if (su->sa.sa_family == AF_INET6)
 396                 ifp = if_lookup_by_ipv6_exact(&su->sin6.sin6_addr,
 397                                               su->sin6.sin6_scope_id,
 398                                               bgp->vrf_id);
 399
 400         if (ifp)
 401                 return 1;
 402
 403         return 0;
 404 }
 405
 406 /* Utility function for looking up peer from VTY.  */
 407 /* This is used only for configuration, so disallow if attempted on
 408  * a dynamic neighbor.
 409  */
 410 static struct peer *peer_lookup_vty(struct vty *vty, const char *ip_str)
 411 {
 412         struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 413         int ret;
 414         union sockunion su;
 415         struct peer *peer;
 416
 417         if (!bgp) {
 418                 return NULL;
 419         }
 420
 421         ret = str2sockunion(ip_str, &su);
 422         if (ret < 0) {
 423                 peer = peer_lookup_by_conf_if(bgp, ip_str);
 424                 if (!peer) {
 425                         if ((peer = peer_lookup_by_hostname(bgp, ip_str))
 426                             == NULL) {
 427                                 vty_out(vty,
 428                                         "%% Malformed address or name: %s\n",
 429                                         ip_str);
 430                                 return NULL;
 431                         }
 432                 }
 433         } else {
 434                 peer = peer_lookup(bgp, &su);
 435                 if (!peer) {
 436                         vty_out(vty,
 437                                 "%% Specify remote-as or peer-group commands first\n");
 438                         return NULL;
 439                 }
 440                 if (peer_dynamic_neighbor(peer)) {
 441                         vty_out(vty,
 442                                 "%% Operation not allowed on a dynamic neighbor\n");
 443                         return NULL;
 444                 }
 445         }
 446         return peer;
 447 }
 448
 449 /* Utility function for looking up peer or peer group.  */
 450 /* This is used only for configuration, so disallow if attempted on
 451  * a dynamic neighbor.
 452  */
 453 struct peer *peer_and_group_lookup_vty(struct vty *vty, const char *peer_str)
 454 {
 455         struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 456         int ret;
 457         union sockunion su;
 458         struct peer *peer = NULL;
 459         struct peer_group *group = NULL;
 460
 461         if (!bgp) {
 462                 return NULL;
 463         }
 464
 465         ret = str2sockunion(peer_str, &su);
 466         if (ret == 0) {
 467                 /* IP address, locate peer. */
 468                 peer = peer_lookup(bgp, &su);
 469         } else {
 470                 /* Not IP, could match either peer configured on interface or a
 471                  * group. */
 472                 peer = peer_lookup_by_conf_if(bgp, peer_str);
 473                 if (!peer)
 474                         group = peer_group_lookup(bgp, peer_str);
 475         }
 476
 477         if (peer) {
 478                 if (peer_dynamic_neighbor(peer)) {
 479                         vty_out(vty,
 480                                 "%% Operation not allowed on a dynamic neighbor\n");
 481                         return NULL;
 482                 }
 483
 484                 return peer;
 485         }
 486
 487         if (group)
 488                 return group->conf;
 489
 490         vty_out(vty, "%% Specify remote-as or peer-group commands first\n");
 491
 492         return NULL;
 493 }
 494
 495 int bgp_vty_return(struct vty *vty, int ret)
 496 {
 497         const char *str = NULL;
 498
 499         switch (ret) {
 500         case BGP_ERR_INVALID_VALUE:
 501                 str = "Invalid value";
 502                 break;
 503         case BGP_ERR_INVALID_FLAG:
 504                 str = "Invalid flag";
 505                 break;
 506         case BGP_ERR_PEER_GROUP_SHUTDOWN:
 507                 str = "Peer-group has been shutdown. Activate the peer-group first";
 508                 break;
 509         case BGP_ERR_PEER_FLAG_CONFLICT:
 510                 str = "Can't set override-capability and strict-capability-match at the same time";
 511                 break;
 512         case BGP_ERR_PEER_GROUP_NO_REMOTE_AS:
 513                 str = "Specify remote-as or peer-group remote AS first";
 514                 break;
 515         case BGP_ERR_PEER_GROUP_CANT_CHANGE:
 516                 str = "Cannot change the peer-group. Deconfigure first";
 517                 break;
 518         case BGP_ERR_PEER_GROUP_MISMATCH:
 519                 str = "Peer is not a member of this peer-group";
 520                 break;
 521         case BGP_ERR_PEER_FILTER_CONFLICT:
 522                 str = "Prefix/distribute list can not co-exist";
 523                 break;
 524         case BGP_ERR_NOT_INTERNAL_PEER:
 525                 str = "Invalid command. Not an internal neighbor";
 526                 break;
 527         case BGP_ERR_REMOVE_PRIVATE_AS:
 528                 str = "remove-private-AS cannot be configured for IBGP peers";
 529                 break;
 530         case BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP:
 531                 str = "Local-AS allowed only for EBGP peers";
 532                 break;
 533         case BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS:
 534                 str = "Cannot have local-as same as BGP AS number";
 535                 break;
 536         case BGP_ERR_TCPSIG_FAILED:
 537                 str = "Error while applying TCP-Sig to session(s)";
 538                 break;
 539         case BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK:
 540                 str = "ebgp-multihop and ttl-security cannot be configured together";
 541                 break;
 542         case BGP_ERR_NO_IBGP_WITH_TTLHACK:
 543                 str = "ttl-security only allowed for EBGP peers";
 544                 break;
 545         case BGP_ERR_AS_OVERRIDE:
 546                 str = "as-override cannot be configured for IBGP peers";
 547                 break;
 548         case BGP_ERR_INVALID_DYNAMIC_NEIGHBORS_LIMIT:
 549                 str = "Invalid limit for number of dynamic neighbors";
 550                 break;
 551         case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_EXISTS:
 552                 str = "Dynamic neighbor listen range already exists";
 553                 break;
 554         case BGP_ERR_INVALID_FOR_DYNAMIC_PEER:
 555                 str = "Operation not allowed on a dynamic neighbor";
 556                 break;
 557         case BGP_ERR_INVALID_FOR_DIRECT_PEER:
 558                 str = "Operation not allowed on a directly connected neighbor";
 559                 break;
 560         case BGP_ERR_PEER_SAFI_CONFLICT:
 561                 str = "Cannot activate peer for both 'ipv4 unicast' and 'ipv4 labeled-unicast'";
 562                 break;
 563         }
 564         if (str) {
 565                 vty_out(vty, "%% %s\n", str);
 566                 return CMD_WARNING_CONFIG_FAILED;
 567         }
 568         return CMD_SUCCESS;
 569 }
 570
 571 /* BGP clear sort. */
 572 enum clear_sort {
 573         clear_all,
 574         clear_peer,
 575         clear_group,
 576         clear_external,
 577         clear_as
 578 };
 579
 580 static void bgp_clear_vty_error(struct vty *vty, struct peer *peer, afi_t afi,
 581                                 safi_t safi, int error)
 582 {
 583         switch (error) {
 584         case BGP_ERR_AF_UNCONFIGURED:
 585                 vty_out(vty,
 586                         "%%BGP: Enable %s address family for the neighbor %s\n",
 587                         afi_safi_print(afi, safi), peer->host);
 588                 break;
 589         case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
 590                 vty_out(vty,
 591                         "%%BGP: Inbound soft reconfig for %s not possible as it\n      has neither refresh capability, nor inbound soft reconfig\n",
 592                         peer->host);
 593                 break;
 594         default:
 595                 break;
 596         }
 597 }
 598
 599 /* `clear ip bgp' functions. */
 600 static int bgp_clear(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
 601                      enum clear_sort sort, enum bgp_clear_type stype,
 602                      const char *arg)
 603 {
 604         int ret;
 605         bool found = false;
 606         struct peer *peer;
 607         struct listnode *node, *nnode;
 608
 609         /* Clear all neighbors. */
 610         /*
 611          * Pass along pointer to next node to peer_clear() when walking all
 612          * nodes on the BGP instance as that may get freed if it is a
 613          * doppelganger
 614          */
 615         if (sort == clear_all) {
 616                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 617                         if (!peer->afc[afi][safi])
 618                                 continue;
 619
 620                         if (stype == BGP_CLEAR_SOFT_NONE)
 621                                 ret = peer_clear(peer, &nnode);
 622                         else
 623                                 ret = peer_clear_soft(peer, afi, safi, stype);
 624
 625                         if (ret < 0)
 626                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 627                 }
 628
 629                 /* This is to apply read-only mode on this clear. */
 630                 if (stype == BGP_CLEAR_SOFT_NONE)
 631                         bgp->update_delay_over = 0;
 632
 633                 return CMD_SUCCESS;
 634         }
 635
 636         /* Clear specified neighbor. */
 637         if (sort == clear_peer) {
 638                 union sockunion su;
 639
 640                 /* Make sockunion for lookup. */
 641                 ret = str2sockunion(arg, &su);
 642                 if (ret < 0) {
 643                         peer = peer_lookup_by_conf_if(bgp, arg);
 644                         if (!peer) {
 645                                 peer = peer_lookup_by_hostname(bgp, arg);
 646                                 if (!peer) {
 647                                         vty_out(vty,
 648                                                 "Malformed address or name: %s\n",
 649                                                 arg);
 650                                         return CMD_WARNING;
 651                                 }
 652                         }
 653                 } else {
 654                         peer = peer_lookup(bgp, &su);
 655                         if (!peer) {
 656                                 vty_out(vty,
 657                                         "%%BGP: Unknown neighbor - \"%s\"\n",
 658                                         arg);
 659                                 return CMD_WARNING;
 660                         }
 661                 }
 662
 663                 if (!peer->afc[afi][safi])
 664                         ret = BGP_ERR_AF_UNCONFIGURED;
 665                 else if (stype == BGP_CLEAR_SOFT_NONE)
 666                         ret = peer_clear(peer, NULL);
 667                 else
 668                         ret = peer_clear_soft(peer, afi, safi, stype);
 669
 670                 if (ret < 0)
 671                         bgp_clear_vty_error(vty, peer, afi, safi, ret);
 672
 673                 return CMD_SUCCESS;
 674         }
 675
 676         /* Clear all neighbors belonging to a specific peer-group. */
 677         if (sort == clear_group) {
 678                 struct peer_group *group;
 679
 680                 group = peer_group_lookup(bgp, arg);
 681                 if (!group) {
 682                         vty_out(vty, "%%BGP: No such peer-group %s\n", arg);
 683                         return CMD_WARNING;
 684                 }
 685
 686                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
 687                         if (!peer->afc[afi][safi])
 688                                 continue;
 689
 690                         if (stype == BGP_CLEAR_SOFT_NONE)
 691                                 ret = peer_clear(peer, NULL);
 692                         else
 693                                 ret = peer_clear_soft(peer, afi, safi, stype);
 694
 695                         if (ret < 0)
 696                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 697                         else
 698                                 found = true;
 699                 }
 700
 701                 if (!found)
 702                         vty_out(vty,
 703                                 "%%BGP: No %s peer belonging to peer-group %s is configured\n",
 704                                 afi_safi_print(afi, safi), arg);
 705
 706                 return CMD_SUCCESS;
 707         }
 708
 709         /* Clear all external (eBGP) neighbors. */
 710         if (sort == clear_external) {
 711                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 712                         if (peer->sort == BGP_PEER_IBGP)
 713                                 continue;
 714
 715                         if (!peer->afc[afi][safi])
 716                                 continue;
 717
 718                         if (stype == BGP_CLEAR_SOFT_NONE)
 719                                 ret = peer_clear(peer, &nnode);
 720                         else
 721                                 ret = peer_clear_soft(peer, afi, safi, stype);
 722
 723                         if (ret < 0)
 724                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 725                         else
 726                                 found = true;
 727                 }
 728
 729                 if (!found)
 730                         vty_out(vty,
 731                                 "%%BGP: No external %s peer is configured\n",
 732                                 afi_safi_print(afi, safi));
 733
 734                 return CMD_SUCCESS;
 735         }
 736
 737         /* Clear all neighbors belonging to a specific AS. */
 738         if (sort == clear_as) {
 739                 as_t as = strtoul(arg, NULL, 10);
 740
 741                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
 742                         if (peer->as != as)
 743                                 continue;
 744
 745                         if (!peer->afc[afi][safi])
 746                                 ret = BGP_ERR_AF_UNCONFIGURED;
 747                         else if (stype == BGP_CLEAR_SOFT_NONE)
 748                                 ret = peer_clear(peer, &nnode);
 749                         else
 750                                 ret = peer_clear_soft(peer, afi, safi, stype);
 751
 752                         if (ret < 0)
 753                                 bgp_clear_vty_error(vty, peer, afi, safi, ret);
 754                         else
 755                                 found = true;
 756                 }
 757
 758                 if (!found)
 759                         vty_out(vty,
 760                                 "%%BGP: No %s peer is configured with AS %s\n",
 761                                 afi_safi_print(afi, safi), arg);
 762
 763                 return CMD_SUCCESS;
 764         }
 765
 766         return CMD_SUCCESS;
 767 }
 768
 769 static int bgp_clear_vty(struct vty *vty, const char *name, afi_t afi,
 770                          safi_t safi, enum clear_sort sort,
 771                          enum bgp_clear_type stype, const char *arg)
 772 {
 773         struct bgp *bgp;
 774
 775         /* BGP structure lookup. */
 776         if (name) {
 777                 bgp = bgp_lookup_by_name(name);
 778                 if (bgp == NULL) {
 779                         vty_out(vty, "Can't find BGP instance %s\n", name);
 780                         return CMD_WARNING;
 781                 }
 782         } else {
 783                 bgp = bgp_get_default();
 784                 if (bgp == NULL) {
 785                         vty_out(vty, "No BGP process is configured\n");
 786                         return CMD_WARNING;
 787                 }
 788         }
 789
 790         return bgp_clear(vty, bgp, afi, safi, sort, stype, arg);
 791 }
 792
 793 /* clear soft inbound */
 794 static void bgp_clear_star_soft_in(struct vty *vty, const char *name)
 795 {
 796         afi_t afi;
 797         safi_t safi;
 798
 799         FOREACH_AFI_SAFI (afi, safi)
 800                 bgp_clear_vty(vty, name, afi, safi, clear_all,
 801                               BGP_CLEAR_SOFT_IN, NULL);
 802 }
 803
 804 /* clear soft outbound */
 805 static void bgp_clear_star_soft_out(struct vty *vty, const char *name)
 806 {
 807         afi_t afi;
 808         safi_t safi;
 809
 810         FOREACH_AFI_SAFI (afi, safi)
 811                 bgp_clear_vty(vty, name, afi, safi, clear_all,
 812                               BGP_CLEAR_SOFT_OUT, NULL);
 813 }
 814
 815
 816 #ifndef VTYSH_EXTRACT_PL
 817 #include "bgpd/bgp_vty_clippy.c"
 818 #endif
 819
 820 DEFUN_HIDDEN (bgp_local_mac,
 821               bgp_local_mac_cmd,
 822               "bgp local-mac vni " CMD_VNI_RANGE " mac WORD seq (0-4294967295)",
 823               BGP_STR
 824               "Local MAC config\n"
 825               "VxLAN Network Identifier\n"
 826               "VNI number\n"
 827               "local mac\n"
 828               "mac address\n"
 829               "mac-mobility sequence\n"
 830               "seq number\n")
 831 {
 832         int rv;
 833         vni_t vni;
 834         struct ethaddr mac;
 835         struct ipaddr ip;
 836         uint32_t seq;
 837         struct bgp *bgp;
 838
 839         vni = strtoul(argv[3]->arg, NULL, 10);
 840         if (!prefix_str2mac(argv[5]->arg, &mac)) {
 841                 vty_out(vty, "%% Malformed MAC address\n");
 842                 return CMD_WARNING;
 843         }
 844         memset(&ip, 0, sizeof(ip));
 845         seq = strtoul(argv[7]->arg, NULL, 10);
 846
 847         bgp = bgp_get_default();
 848         if (!bgp) {
 849                 vty_out(vty, "Default BGP instance is not there\n");
 850                 return CMD_WARNING;
 851         }
 852
 853         rv = bgp_evpn_local_macip_add(bgp, vni, &mac, &ip, 0 /* flags */, seq);
 854         if (rv < 0) {
 855                 vty_out(vty, "Internal error\n");
 856                 return CMD_WARNING;
 857         }
 858
 859         return CMD_SUCCESS;
 860 }
 861
 862 DEFUN_HIDDEN (no_bgp_local_mac,
 863               no_bgp_local_mac_cmd,
 864               "no bgp local-mac vni " CMD_VNI_RANGE " mac WORD",
 865               NO_STR
 866               BGP_STR
 867               "Local MAC config\n"
 868               "VxLAN Network Identifier\n"
 869               "VNI number\n"
 870               "local mac\n"
 871               "mac address\n")
 872 {
 873         int rv;
 874         vni_t vni;
 875         struct ethaddr mac;
 876         struct ipaddr ip;
 877         struct bgp *bgp;
 878
 879         vni = strtoul(argv[4]->arg, NULL, 10);
 880         if (!prefix_str2mac(argv[6]->arg, &mac)) {
 881                 vty_out(vty, "%% Malformed MAC address\n");
 882                 return CMD_WARNING;
 883         }
 884         memset(&ip, 0, sizeof(ip));
 885
 886         bgp = bgp_get_default();
 887         if (!bgp) {
 888                 vty_out(vty, "Default BGP instance is not there\n");
 889                 return CMD_WARNING;
 890         }
 891
 892         rv = bgp_evpn_local_macip_del(bgp, vni, &mac, &ip, ZEBRA_NEIGH_ACTIVE);
 893         if (rv < 0) {
 894                 vty_out(vty, "Internal error\n");
 895                 return CMD_WARNING;
 896         }
 897
 898         return CMD_SUCCESS;
 899 }
 900
 901 DEFUN (no_synchronization,
 902        no_synchronization_cmd,
 903        "no synchronization",
 904        NO_STR
 905        "Perform IGP synchronization\n")
 906 {
 907         return CMD_SUCCESS;
 908 }
 909
 910 DEFUN (no_auto_summary,
 911        no_auto_summary_cmd,
 912        "no auto-summary",
 913        NO_STR
 914        "Enable automatic network number summarization\n")
 915 {
 916         return CMD_SUCCESS;
 917 }
 918
 919 /* "router bgp" commands. */
 920 DEFUN_NOSH (router_bgp,
 921        router_bgp_cmd,
 922        "router bgp [(1-4294967295)$instasn [<view|vrf> VIEWVRFNAME]]",
 923        ROUTER_STR
 924        BGP_STR
 925        AS_STR
 926        BGP_INSTANCE_HELP_STR)
 927 {
 928         int idx_asn = 2;
 929         int idx_view_vrf = 3;
 930         int idx_vrf = 4;
 931         int is_new_bgp = 0;
 932         int ret;
 933         as_t as;
 934         struct bgp *bgp;
 935         const char *name = NULL;
 936         enum bgp_instance_type inst_type;
 937
 938         // "router bgp" without an ASN
 939         if (argc == 2) {
 940                 // Pending: Make VRF option available for ASN less config
 941                 bgp = bgp_get_default();
 942
 943                 if (bgp == NULL) {
 944                         vty_out(vty, "%% No BGP process is configured\n");
 945                         return CMD_WARNING_CONFIG_FAILED;
 946                 }
 947
 948                 if (listcount(bm->bgp) > 1) {
 949                         vty_out(vty, "%% Please specify ASN and VRF\n");
 950                         return CMD_WARNING_CONFIG_FAILED;
 951                 }
 952         }
 953
 954         // "router bgp X"
 955         else {
 956                 as = strtoul(argv[idx_asn]->arg, NULL, 10);
 957
 958                 inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 959                 if (argc > 3) {
 960                         name = argv[idx_vrf]->arg;
 961
 962                         if (!strcmp(argv[idx_view_vrf]->text, "vrf")) {
 963                                 if (strmatch(name, VRF_DEFAULT_NAME))
 964                                         name = NULL;
 965                                 else
 966                                         inst_type = BGP_INSTANCE_TYPE_VRF;
 967                         } else if (!strcmp(argv[idx_view_vrf]->text, "view"))
 968                                 inst_type = BGP_INSTANCE_TYPE_VIEW;
 969                 }
 970
 971                 if (inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 972                         is_new_bgp = (bgp_lookup(as, name) == NULL);
 973
 974                 ret = bgp_get(&bgp, &as, name, inst_type);
 975                 switch (ret) {
 976                 case BGP_ERR_AS_MISMATCH:
 977                         vty_out(vty, "BGP is already running; AS is %u\n", as);
 978                         return CMD_WARNING_CONFIG_FAILED;
 979                 case BGP_ERR_INSTANCE_MISMATCH:
 980                         vty_out(vty,
 981                                 "BGP instance name and AS number mismatch\n");
 982                         vty_out(vty,
 983                                 "BGP instance is already running; AS is %u\n",
 984                                 as);
 985                         return CMD_WARNING_CONFIG_FAILED;
 986                 }
 987
 988                 /*
 989                  * If we just instantiated the default instance, complete
 990                  * any pending VRF-VPN leaking that was configured via
 991                  * earlier "router bgp X vrf FOO" blocks.
 992                  */
 993                 if (is_new_bgp && inst_type == BGP_INSTANCE_TYPE_DEFAULT)
 994                         vpn_leak_postchange_all();
 995
 996                 if (inst_type == BGP_INSTANCE_TYPE_VRF)
 997                         bgp_vpn_leak_export(bgp);
 998                 /* Pending: handle when user tries to change a view to vrf n vv.
 999                  */
1000         }
1001
1002         /* unset the auto created flag as the user config is now present */
1003         UNSET_FLAG(bgp->vrf_flags, BGP_VRF_AUTO);
1004         VTY_PUSH_CONTEXT(BGP_NODE, bgp);
1005
1006         return CMD_SUCCESS;
1007 }
1008
1009 /* "no router bgp" commands. */
1010 DEFUN (no_router_bgp,
1011        no_router_bgp_cmd,
1012        "no router bgp [(1-4294967295)$instasn [<view|vrf> VIEWVRFNAME]]",
1013        NO_STR
1014        ROUTER_STR
1015        BGP_STR
1016        AS_STR
1017        BGP_INSTANCE_HELP_STR)
1018 {
1019         int idx_asn = 3;
1020         int idx_vrf = 5;
1021         as_t as;
1022         struct bgp *bgp;
1023         const char *name = NULL;
1024
1025         // "no router bgp" without an ASN
1026         if (argc == 3) {
1027                 // Pending: Make VRF option available for ASN less config
1028                 bgp = bgp_get_default();
1029
1030                 if (bgp == NULL) {
1031                         vty_out(vty, "%% No BGP process is configured\n");
1032                         return CMD_WARNING_CONFIG_FAILED;
1033                 }
1034
1035                 if (listcount(bm->bgp) > 1) {
1036                         vty_out(vty, "%% Please specify ASN and VRF\n");
1037                         return CMD_WARNING_CONFIG_FAILED;
1038                 }
1039
1040                 if (bgp->l3vni) {
1041                         vty_out(vty, "%% Please unconfigure l3vni %u",
1042                                 bgp->l3vni);
1043                         return CMD_WARNING_CONFIG_FAILED;
1044                 }
1045         } else {
1046                 as = strtoul(argv[idx_asn]->arg, NULL, 10);
1047
1048                 if (argc > 4)
1049                         name = argv[idx_vrf]->arg;
1050
1051                 /* Lookup bgp structure. */
1052                 bgp = bgp_lookup(as, name);
1053                 if (!bgp) {
1054                         vty_out(vty, "%% Can't find BGP instance\n");
1055                         return CMD_WARNING_CONFIG_FAILED;
1056                 }
1057
1058                 if (bgp->l3vni) {
1059                         vty_out(vty, "%% Please unconfigure l3vni %u\n",
1060                                 bgp->l3vni);
1061                         return CMD_WARNING_CONFIG_FAILED;
1062                 }
1063
1064                 /* Cannot delete default instance if vrf instances exist */
1065                 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
1066                         struct listnode *node;
1067                         struct bgp *tmp_bgp;
1068
1069                         for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, tmp_bgp)) {
1070                                 if (tmp_bgp->inst_type
1071                                     == BGP_INSTANCE_TYPE_VRF) {
1072                                         vty_out(vty,
1073                                                 "%% Cannot delete default BGP instance. Dependent VRF instances exist\n");
1074                                         return CMD_WARNING_CONFIG_FAILED;
1075                                 }
1076                         }
1077                 }
1078         }
1079
1080         if (bgp_vpn_leak_unimport(bgp, vty))
1081                 return CMD_WARNING_CONFIG_FAILED;
1082
1083         bgp_delete(bgp);
1084
1085         return CMD_SUCCESS;
1086 }
1087
1088
1089 /* BGP router-id.  */
1090
1091 DEFPY (bgp_router_id,
1092        bgp_router_id_cmd,
1093        "bgp router-id A.B.C.D",
1094        BGP_STR
1095        "Override configured router identifier\n"
1096        "Manually configured router identifier\n")
1097 {
1098         VTY_DECLVAR_CONTEXT(bgp, bgp);
1099         bgp_router_id_static_set(bgp, router_id);
1100         return CMD_SUCCESS;
1101 }
1102
1103 DEFPY (no_bgp_router_id,
1104        no_bgp_router_id_cmd,
1105        "no bgp router-id [A.B.C.D]",
1106        NO_STR
1107        BGP_STR
1108        "Override configured router identifier\n"
1109        "Manually configured router identifier\n")
1110 {
1111         VTY_DECLVAR_CONTEXT(bgp, bgp);
1112
1113         if (router_id_str) {
1114                 if (!IPV4_ADDR_SAME(&bgp->router_id_static, &router_id)) {
1115                         vty_out(vty, "%% BGP router-id doesn't match\n");
1116                         return CMD_WARNING_CONFIG_FAILED;
1117                 }
1118         }
1119
1120         router_id.s_addr = 0;
1121         bgp_router_id_static_set(bgp, router_id);
1122
1123         return CMD_SUCCESS;
1124 }
1125
1126
1127 /* BGP Cluster ID.  */
1128 DEFUN (bgp_cluster_id,
1129        bgp_cluster_id_cmd,
1130        "bgp cluster-id <A.B.C.D|(1-4294967295)>",
1131        BGP_STR
1132        "Configure Route-Reflector Cluster-id\n"
1133        "Route-Reflector Cluster-id in IP address format\n"
1134        "Route-Reflector Cluster-id as 32 bit quantity\n")
1135 {
1136         VTY_DECLVAR_CONTEXT(bgp, bgp);
1137         int idx_ipv4 = 2;
1138         int ret;
1139         struct in_addr cluster;
1140
1141         ret = inet_aton(argv[idx_ipv4]->arg, &cluster);
1142         if (!ret) {
1143                 vty_out(vty, "%% Malformed bgp cluster identifier\n");
1144                 return CMD_WARNING_CONFIG_FAILED;
1145         }
1146
1147         bgp_cluster_id_set(bgp, &cluster);
1148         bgp_clear_star_soft_out(vty, bgp->name);
1149
1150         return CMD_SUCCESS;
1151 }
1152
1153 DEFUN (no_bgp_cluster_id,
1154        no_bgp_cluster_id_cmd,
1155        "no bgp cluster-id [<A.B.C.D|(1-4294967295)>]",
1156        NO_STR
1157        BGP_STR
1158        "Configure Route-Reflector Cluster-id\n"
1159        "Route-Reflector Cluster-id in IP address format\n"
1160        "Route-Reflector Cluster-id as 32 bit quantity\n")
1161 {
1162         VTY_DECLVAR_CONTEXT(bgp, bgp);
1163         bgp_cluster_id_unset(bgp);
1164         bgp_clear_star_soft_out(vty, bgp->name);
1165
1166         return CMD_SUCCESS;
1167 }
1168
1169 DEFUN (bgp_confederation_identifier,
1170        bgp_confederation_identifier_cmd,
1171        "bgp confederation identifier (1-4294967295)",
1172        "BGP specific commands\n"
1173        "AS confederation parameters\n"
1174        "AS number\n"
1175        "Set routing domain confederation AS\n")
1176 {
1177         VTY_DECLVAR_CONTEXT(bgp, bgp);
1178         int idx_number = 3;
1179         as_t as;
1180
1181         as = strtoul(argv[idx_number]->arg, NULL, 10);
1182
1183         bgp_confederation_id_set(bgp, as);
1184
1185         return CMD_SUCCESS;
1186 }
1187
1188 DEFUN (no_bgp_confederation_identifier,
1189        no_bgp_confederation_identifier_cmd,
1190        "no bgp confederation identifier [(1-4294967295)]",
1191        NO_STR
1192        "BGP specific commands\n"
1193        "AS confederation parameters\n"
1194        "AS number\n"
1195        "Set routing domain confederation AS\n")
1196 {
1197         VTY_DECLVAR_CONTEXT(bgp, bgp);
1198         bgp_confederation_id_unset(bgp);
1199
1200         return CMD_SUCCESS;
1201 }
1202
1203 DEFUN (bgp_confederation_peers,
1204        bgp_confederation_peers_cmd,
1205        "bgp confederation peers (1-4294967295)...",
1206        "BGP specific commands\n"
1207        "AS confederation parameters\n"
1208        "Peer ASs in BGP confederation\n"
1209        AS_STR)
1210 {
1211         VTY_DECLVAR_CONTEXT(bgp, bgp);
1212         int idx_asn = 3;
1213         as_t as;
1214         int i;
1215
1216         for (i = idx_asn; i < argc; i++) {
1217                 as = strtoul(argv[i]->arg, NULL, 10);
1218
1219                 if (bgp->as == as) {
1220                         vty_out(vty,
1221                                 "%% Local member-AS not allowed in confed peer list\n");
1222                         continue;
1223                 }
1224
1225                 bgp_confederation_peers_add(bgp, as);
1226         }
1227         return CMD_SUCCESS;
1228 }
1229
1230 DEFUN (no_bgp_confederation_peers,
1231        no_bgp_confederation_peers_cmd,
1232        "no bgp confederation peers (1-4294967295)...",
1233        NO_STR
1234        "BGP specific commands\n"
1235        "AS confederation parameters\n"
1236        "Peer ASs in BGP confederation\n"
1237        AS_STR)
1238 {
1239         VTY_DECLVAR_CONTEXT(bgp, bgp);
1240         int idx_asn = 4;
1241         as_t as;
1242         int i;
1243
1244         for (i = idx_asn; i < argc; i++) {
1245                 as = strtoul(argv[i]->arg, NULL, 10);
1246
1247                 bgp_confederation_peers_remove(bgp, as);
1248         }
1249         return CMD_SUCCESS;
1250 }
1251
1252 /**
1253  * Central routine for maximum-paths configuration.
1254  * @peer_type: BGP_PEER_EBGP or BGP_PEER_IBGP
1255  * @set: 1 for setting values, 0 for removing the max-paths config.
1256  */
1257 static int bgp_maxpaths_config_vty(struct vty *vty, int peer_type,
1258                                    const char *mpaths, uint16_t options,
1259                                    int set)
1260 {
1261         VTY_DECLVAR_CONTEXT(bgp, bgp);
1262         uint16_t maxpaths = 0;
1263         int ret;
1264         afi_t afi;
1265         safi_t safi;
1266
1267         afi = bgp_node_afi(vty);
1268         safi = bgp_node_safi(vty);
1269
1270         if (set) {
1271                 maxpaths = strtol(mpaths, NULL, 10);
1272                 if (maxpaths > multipath_num) {
1273                         vty_out(vty,
1274                                 "%% Maxpaths Specified: %d is > than multipath num specified on bgp command line %d",
1275                                 maxpaths, multipath_num);
1276                         return CMD_WARNING_CONFIG_FAILED;
1277                 }
1278                 ret = bgp_maximum_paths_set(bgp, afi, safi, peer_type, maxpaths,
1279                                             options);
1280         } else
1281                 ret = bgp_maximum_paths_unset(bgp, afi, safi, peer_type);
1282
1283         if (ret < 0) {
1284                 vty_out(vty,
1285                         "%% Failed to %sset maximum-paths %s %u for afi %u, safi %u\n",
1286                         (set == 1) ? "" : "un",
1287                         (peer_type == BGP_PEER_EBGP) ? "ebgp" : "ibgp",
1288                         maxpaths, afi, safi);
1289                 return CMD_WARNING_CONFIG_FAILED;
1290         }
1291
1292         bgp_recalculate_all_bestpaths(bgp);
1293
1294         return CMD_SUCCESS;
1295 }
1296
1297 DEFUN (bgp_maxmed_admin,
1298        bgp_maxmed_admin_cmd,
1299        "bgp max-med administrative ",
1300        BGP_STR
1301        "Advertise routes with max-med\n"
1302        "Administratively applied, for an indefinite period\n")
1303 {
1304         VTY_DECLVAR_CONTEXT(bgp, bgp);
1305
1306         bgp->v_maxmed_admin = 1;
1307         bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1308
1309         bgp_maxmed_update(bgp);
1310
1311         return CMD_SUCCESS;
1312 }
1313
1314 DEFUN (bgp_maxmed_admin_medv,
1315        bgp_maxmed_admin_medv_cmd,
1316        "bgp max-med administrative (0-4294967295)",
1317        BGP_STR
1318        "Advertise routes with max-med\n"
1319        "Administratively applied, for an indefinite period\n"
1320        "Max MED value to be used\n")
1321 {
1322         VTY_DECLVAR_CONTEXT(bgp, bgp);
1323         int idx_number = 3;
1324
1325         bgp->v_maxmed_admin = 1;
1326         bgp->maxmed_admin_value = strtoul(argv[idx_number]->arg, NULL, 10);
1327
1328         bgp_maxmed_update(bgp);
1329
1330         return CMD_SUCCESS;
1331 }
1332
1333 DEFUN (no_bgp_maxmed_admin,
1334        no_bgp_maxmed_admin_cmd,
1335        "no bgp max-med administrative [(0-4294967295)]",
1336        NO_STR
1337        BGP_STR
1338        "Advertise routes with max-med\n"
1339        "Administratively applied, for an indefinite period\n"
1340        "Max MED value to be used\n")
1341 {
1342         VTY_DECLVAR_CONTEXT(bgp, bgp);
1343         bgp->v_maxmed_admin = BGP_MAXMED_ADMIN_UNCONFIGURED;
1344         bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1345         bgp_maxmed_update(bgp);
1346
1347         return CMD_SUCCESS;
1348 }
1349
1350 DEFUN (bgp_maxmed_onstartup,
1351        bgp_maxmed_onstartup_cmd,
1352        "bgp max-med on-startup (5-86400) [(0-4294967295)]",
1353        BGP_STR
1354        "Advertise routes with max-med\n"
1355        "Effective on a startup\n"
1356        "Time (seconds) period for max-med\n"
1357        "Max MED value to be used\n")
1358 {
1359         VTY_DECLVAR_CONTEXT(bgp, bgp);
1360         int idx = 0;
1361
1362         argv_find(argv, argc, "(5-86400)", &idx);
1363         bgp->v_maxmed_onstartup = strtoul(argv[idx]->arg, NULL, 10);
1364         if (argv_find(argv, argc, "(0-4294967295)", &idx))
1365                 bgp->maxmed_onstartup_value = strtoul(argv[idx]->arg, NULL, 10);
1366         else
1367                 bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1368
1369         bgp_maxmed_update(bgp);
1370
1371         return CMD_SUCCESS;
1372 }
1373
1374 DEFUN (no_bgp_maxmed_onstartup,
1375        no_bgp_maxmed_onstartup_cmd,
1376        "no bgp max-med on-startup [(5-86400) [(0-4294967295)]]",
1377        NO_STR
1378        BGP_STR
1379        "Advertise routes with max-med\n"
1380        "Effective on a startup\n"
1381        "Time (seconds) period for max-med\n"
1382        "Max MED value to be used\n")
1383 {
1384         VTY_DECLVAR_CONTEXT(bgp, bgp);
1385
1386         /* Cancel max-med onstartup if its on */
1387         if (bgp->t_maxmed_onstartup) {
1388                 THREAD_TIMER_OFF(bgp->t_maxmed_onstartup);
1389                 bgp->maxmed_onstartup_over = 1;
1390         }
1391
1392         bgp->v_maxmed_onstartup = BGP_MAXMED_ONSTARTUP_UNCONFIGURED;
1393         bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1394
1395         bgp_maxmed_update(bgp);
1396
1397         return CMD_SUCCESS;
1398 }
1399
1400 static int bgp_update_delay_config_vty(struct vty *vty, const char *delay,
1401                                        const char *wait)
1402 {
1403         VTY_DECLVAR_CONTEXT(bgp, bgp);
1404         uint16_t update_delay;
1405         uint16_t establish_wait;
1406
1407         update_delay = strtoul(delay, NULL, 10);
1408
1409         if (!wait) /* update-delay <delay> */
1410         {
1411                 bgp->v_update_delay = update_delay;
1412                 bgp->v_establish_wait = bgp->v_update_delay;
1413                 return CMD_SUCCESS;
1414         }
1415
1416         /* update-delay <delay> <establish-wait> */
1417         establish_wait = atoi(wait);
1418         if (update_delay < establish_wait) {
1419                 vty_out(vty,
1420                         "%%Failed: update-delay less than the establish-wait!\n");
1421                 return CMD_WARNING_CONFIG_FAILED;
1422         }
1423
1424         bgp->v_update_delay = update_delay;
1425         bgp->v_establish_wait = establish_wait;
1426
1427         return CMD_SUCCESS;
1428 }
1429
1430 static int bgp_update_delay_deconfig_vty(struct vty *vty)
1431 {
1432         VTY_DECLVAR_CONTEXT(bgp, bgp);
1433
1434         bgp->v_update_delay = BGP_UPDATE_DELAY_DEF;
1435         bgp->v_establish_wait = bgp->v_update_delay;
1436
1437         return CMD_SUCCESS;
1438 }
1439
1440 void bgp_config_write_update_delay(struct vty *vty, struct bgp *bgp)
1441 {
1442         if (bgp->v_update_delay != BGP_UPDATE_DELAY_DEF) {
1443                 vty_out(vty, " update-delay %d", bgp->v_update_delay);
1444                 if (bgp->v_update_delay != bgp->v_establish_wait)
1445                         vty_out(vty, " %d", bgp->v_establish_wait);
1446                 vty_out(vty, "\n");
1447         }
1448 }
1449
1450
1451 /* Update-delay configuration */
1452 DEFUN (bgp_update_delay,
1453        bgp_update_delay_cmd,
1454        "update-delay (0-3600)",
1455        "Force initial delay for best-path and updates\n"
1456        "Seconds\n")
1457 {
1458         int idx_number = 1;
1459         return bgp_update_delay_config_vty(vty, argv[idx_number]->arg, NULL);
1460 }
1461
1462 DEFUN (bgp_update_delay_establish_wait,
1463        bgp_update_delay_establish_wait_cmd,
1464        "update-delay (0-3600) (1-3600)",
1465        "Force initial delay for best-path and updates\n"
1466        "Seconds\n"
1467        "Seconds\n")
1468 {
1469         int idx_number = 1;
1470         int idx_number_2 = 2;
1471         return bgp_update_delay_config_vty(vty, argv[idx_number]->arg,
1472                                            argv[idx_number_2]->arg);
1473 }
1474
1475 /* Update-delay deconfiguration */
1476 DEFUN (no_bgp_update_delay,
1477        no_bgp_update_delay_cmd,
1478        "no update-delay [(0-3600) [(1-3600)]]",
1479        NO_STR
1480        "Force initial delay for best-path and updates\n"
1481        "Seconds\n"
1482        "Seconds\n")
1483 {
1484         return bgp_update_delay_deconfig_vty(vty);
1485 }
1486
1487
1488 static int bgp_wpkt_quanta_config_vty(struct vty *vty, const char *num,
1489                                       char set)
1490 {
1491         VTY_DECLVAR_CONTEXT(bgp, bgp);
1492
1493         if (set) {
1494                 uint32_t quanta = strtoul(num, NULL, 10);
1495                 atomic_store_explicit(&bgp->wpkt_quanta, quanta,
1496                                       memory_order_relaxed);
1497         } else {
1498                 atomic_store_explicit(&bgp->wpkt_quanta, BGP_WRITE_PACKET_MAX,
1499                                       memory_order_relaxed);
1500         }
1501
1502         return CMD_SUCCESS;
1503 }
1504
1505 static int bgp_rpkt_quanta_config_vty(struct vty *vty, const char *num,
1506                                       char set)
1507 {
1508         VTY_DECLVAR_CONTEXT(bgp, bgp);
1509
1510         if (set) {
1511                 uint32_t quanta = strtoul(num, NULL, 10);
1512                 atomic_store_explicit(&bgp->rpkt_quanta, quanta,
1513                                       memory_order_relaxed);
1514         } else {
1515                 atomic_store_explicit(&bgp->rpkt_quanta, BGP_READ_PACKET_MAX,
1516                                       memory_order_relaxed);
1517         }
1518
1519         return CMD_SUCCESS;
1520 }
1521
1522 void bgp_config_write_wpkt_quanta(struct vty *vty, struct bgp *bgp)
1523 {
1524         uint32_t quanta =
1525                 atomic_load_explicit(&bgp->wpkt_quanta, memory_order_relaxed);
1526         if (quanta != BGP_WRITE_PACKET_MAX)
1527                 vty_out(vty, " write-quanta %d\n", quanta);
1528 }
1529
1530 void bgp_config_write_rpkt_quanta(struct vty *vty, struct bgp *bgp)
1531 {
1532         uint32_t quanta =
1533                 atomic_load_explicit(&bgp->rpkt_quanta, memory_order_relaxed);
1534         if (quanta != BGP_READ_PACKET_MAX)
1535                 vty_out(vty, " read-quanta %d\n", quanta);
1536 }
1537
1538 /* Packet quanta configuration */
1539 DEFUN (bgp_wpkt_quanta,
1540        bgp_wpkt_quanta_cmd,
1541        "write-quanta (1-10)",
1542        "How many packets to write to peer socket per run\n"
1543        "Number of packets\n")
1544 {
1545         int idx_number = 1;
1546         return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 1);
1547 }
1548
1549 DEFUN (no_bgp_wpkt_quanta,
1550        no_bgp_wpkt_quanta_cmd,
1551        "no write-quanta (1-10)",
1552        NO_STR
1553        "How many packets to write to peer socket per I/O cycle\n"
1554        "Number of packets\n")
1555 {
1556         int idx_number = 2;
1557         return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 0);
1558 }
1559
1560 DEFUN (bgp_rpkt_quanta,
1561        bgp_rpkt_quanta_cmd,
1562        "read-quanta (1-10)",
1563        "How many packets to read from peer socket per I/O cycle\n"
1564        "Number of packets\n")
1565 {
1566         int idx_number = 1;
1567         return bgp_rpkt_quanta_config_vty(vty, argv[idx_number]->arg, 1);
1568 }
1569
1570 DEFUN (no_bgp_rpkt_quanta,
1571        no_bgp_rpkt_quanta_cmd,
1572        "no read-quanta (1-10)",
1573        NO_STR
1574        "How many packets to read from peer socket per I/O cycle\n"
1575        "Number of packets\n")
1576 {
1577         int idx_number = 2;
1578         return bgp_rpkt_quanta_config_vty(vty, argv[idx_number]->arg, 0);
1579 }
1580
1581 void bgp_config_write_coalesce_time(struct vty *vty, struct bgp *bgp)
1582 {
1583         if (!bgp->heuristic_coalesce)
1584                 vty_out(vty, " coalesce-time %u\n", bgp->coalesce_time);
1585 }
1586
1587
1588 DEFUN (bgp_coalesce_time,
1589        bgp_coalesce_time_cmd,
1590        "coalesce-time (0-4294967295)",
1591        "Subgroup coalesce timer\n"
1592        "Subgroup coalesce timer value (in ms)\n")
1593 {
1594         VTY_DECLVAR_CONTEXT(bgp, bgp);
1595
1596         int idx = 0;
1597         argv_find(argv, argc, "(0-4294967295)", &idx);
1598         bgp->heuristic_coalesce = false;
1599         bgp->coalesce_time = strtoul(argv[idx]->arg, NULL, 10);
1600         return CMD_SUCCESS;
1601 }
1602
1603 DEFUN (no_bgp_coalesce_time,
1604        no_bgp_coalesce_time_cmd,
1605        "no coalesce-time (0-4294967295)",
1606        NO_STR
1607        "Subgroup coalesce timer\n"
1608        "Subgroup coalesce timer value (in ms)\n")
1609 {
1610         VTY_DECLVAR_CONTEXT(bgp, bgp);
1611
1612         bgp->heuristic_coalesce = true;
1613         bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
1614         return CMD_SUCCESS;
1615 }
1616
1617 /* Maximum-paths configuration */
1618 DEFUN (bgp_maxpaths,
1619        bgp_maxpaths_cmd,
1620        "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
1621        "Forward packets over multiple paths\n"
1622        "Number of paths\n")
1623 {
1624         int idx_number = 1;
1625         return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP,
1626                                        argv[idx_number]->arg, 0, 1);
1627 }
1628
1629 ALIAS_HIDDEN(bgp_maxpaths, bgp_maxpaths_hidden_cmd,
1630              "maximum-paths " CMD_RANGE_STR(1, MULTIPATH_NUM),
1631              "Forward packets over multiple paths\n"
1632              "Number of paths\n")
1633
1634 DEFUN (bgp_maxpaths_ibgp,
1635        bgp_maxpaths_ibgp_cmd,
1636        "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
1637        "Forward packets over multiple paths\n"
1638        "iBGP-multipath\n"
1639        "Number of paths\n")
1640 {
1641         int idx_number = 2;
1642         return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP,
1643                                        argv[idx_number]->arg, 0, 1);
1644 }
1645
1646 ALIAS_HIDDEN(bgp_maxpaths_ibgp, bgp_maxpaths_ibgp_hidden_cmd,
1647              "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM),
1648              "Forward packets over multiple paths\n"
1649              "iBGP-multipath\n"
1650              "Number of paths\n")
1651
1652 DEFUN (bgp_maxpaths_ibgp_cluster,
1653        bgp_maxpaths_ibgp_cluster_cmd,
1654        "maximum-paths ibgp " CMD_RANGE_STR(1, MULTIPATH_NUM) " equal-cluster-length",
1655        "Forward packets over multiple paths\n"
1656        "iBGP-multipath\n"
1657        "Number of paths\n"
1658        "Match the cluster length\n")
1659 {
1660         int idx_number = 2;
1661         return bgp_maxpaths_config_vty(
1662                 vty, BGP_PEER_IBGP, argv[idx_number]->arg,
1663                 BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN, 1);
1664 }
1665
1666 ALIAS_HIDDEN(bgp_maxpaths_ibgp_cluster, bgp_maxpaths_ibgp_cluster_hidden_cmd,
1667              "maximum-paths ibgp " CMD_RANGE_STR(
1668                      1, MULTIPATH_NUM) " equal-cluster-length",
1669              "Forward packets over multiple paths\n"
1670              "iBGP-multipath\n"
1671              "Number of paths\n"
1672              "Match the cluster length\n")
1673
1674 DEFUN (no_bgp_maxpaths,
1675        no_bgp_maxpaths_cmd,
1676        "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
1677        NO_STR
1678        "Forward packets over multiple paths\n"
1679        "Number of paths\n")
1680 {
1681         return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, NULL, 0, 0);
1682 }
1683
1684 ALIAS_HIDDEN(no_bgp_maxpaths, no_bgp_maxpaths_hidden_cmd,
1685              "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]", NO_STR
1686              "Forward packets over multiple paths\n"
1687              "Number of paths\n")
1688
1689 DEFUN (no_bgp_maxpaths_ibgp,
1690        no_bgp_maxpaths_ibgp_cmd,
1691        "no maximum-paths ibgp [" CMD_RANGE_STR(1, MULTIPATH_NUM) " [equal-cluster-length]]",
1692        NO_STR
1693        "Forward packets over multiple paths\n"
1694        "iBGP-multipath\n"
1695        "Number of paths\n"
1696        "Match the cluster length\n")
1697 {
1698         return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, NULL, 0, 0);
1699 }
1700
1701 ALIAS_HIDDEN(no_bgp_maxpaths_ibgp, no_bgp_maxpaths_ibgp_hidden_cmd,
1702              "no maximum-paths ibgp [" CMD_RANGE_STR(
1703                      1, MULTIPATH_NUM) " [equal-cluster-length]]",
1704              NO_STR
1705              "Forward packets over multiple paths\n"
1706              "iBGP-multipath\n"
1707              "Number of paths\n"
1708              "Match the cluster length\n")
1709
1710 void bgp_config_write_maxpaths(struct vty *vty, struct bgp *bgp, afi_t afi,
1711                                safi_t safi)
1712 {
1713         if (bgp->maxpaths[afi][safi].maxpaths_ebgp != MULTIPATH_NUM) {
1714                 vty_out(vty, "  maximum-paths %d\n",
1715                         bgp->maxpaths[afi][safi].maxpaths_ebgp);
1716         }
1717
1718         if (bgp->maxpaths[afi][safi].maxpaths_ibgp != MULTIPATH_NUM) {
1719                 vty_out(vty, "  maximum-paths ibgp %d",
1720                         bgp->maxpaths[afi][safi].maxpaths_ibgp);
1721                 if (CHECK_FLAG(bgp->maxpaths[afi][safi].ibgp_flags,
1722                                BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN))
1723                         vty_out(vty, " equal-cluster-length");
1724                 vty_out(vty, "\n");
1725         }
1726 }
1727
1728 /* BGP timers.  */
1729
1730 DEFUN (bgp_timers,
1731        bgp_timers_cmd,
1732        "timers bgp (0-65535) (0-65535)",
1733        "Adjust routing timers\n"
1734        "BGP timers\n"
1735        "Keepalive interval\n"
1736        "Holdtime\n")
1737 {
1738         VTY_DECLVAR_CONTEXT(bgp, bgp);
1739         int idx_number = 2;
1740         int idx_number_2 = 3;
1741         unsigned long keepalive = 0;
1742         unsigned long holdtime = 0;
1743
1744         keepalive = strtoul(argv[idx_number]->arg, NULL, 10);
1745         holdtime = strtoul(argv[idx_number_2]->arg, NULL, 10);
1746
1747         /* Holdtime value check. */
1748         if (holdtime < 3 && holdtime != 0) {
1749                 vty_out(vty,
1750                         "%% hold time value must be either 0 or greater than 3\n");
1751                 return CMD_WARNING_CONFIG_FAILED;
1752         }
1753
1754         bgp_timers_set(bgp, keepalive, holdtime);
1755
1756         return CMD_SUCCESS;
1757 }
1758
1759 DEFUN (no_bgp_timers,
1760        no_bgp_timers_cmd,
1761        "no timers bgp [(0-65535) (0-65535)]",
1762        NO_STR
1763        "Adjust routing timers\n"
1764        "BGP timers\n"
1765        "Keepalive interval\n"
1766        "Holdtime\n")
1767 {
1768         VTY_DECLVAR_CONTEXT(bgp, bgp);
1769         bgp_timers_unset(bgp);
1770
1771         return CMD_SUCCESS;
1772 }
1773
1774
1775 DEFUN (bgp_client_to_client_reflection,
1776        bgp_client_to_client_reflection_cmd,
1777        "bgp client-to-client reflection",
1778        "BGP specific commands\n"
1779        "Configure client to client route reflection\n"
1780        "reflection of routes allowed\n")
1781 {
1782         VTY_DECLVAR_CONTEXT(bgp, bgp);
1783         bgp_flag_unset(bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1784         bgp_clear_star_soft_out(vty, bgp->name);
1785
1786         return CMD_SUCCESS;
1787 }
1788
1789 DEFUN (no_bgp_client_to_client_reflection,
1790        no_bgp_client_to_client_reflection_cmd,
1791        "no bgp client-to-client reflection",
1792        NO_STR
1793        "BGP specific commands\n"
1794        "Configure client to client route reflection\n"
1795        "reflection of routes allowed\n")
1796 {
1797         VTY_DECLVAR_CONTEXT(bgp, bgp);
1798         bgp_flag_set(bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1799         bgp_clear_star_soft_out(vty, bgp->name);
1800
1801         return CMD_SUCCESS;
1802 }
1803
1804 /* "bgp always-compare-med" configuration. */
1805 DEFUN (bgp_always_compare_med,
1806        bgp_always_compare_med_cmd,
1807        "bgp always-compare-med",
1808        "BGP specific commands\n"
1809        "Allow comparing MED from different neighbors\n")
1810 {
1811         VTY_DECLVAR_CONTEXT(bgp, bgp);
1812         bgp_flag_set(bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1813         bgp_recalculate_all_bestpaths(bgp);
1814
1815         return CMD_SUCCESS;
1816 }
1817
1818 DEFUN (no_bgp_always_compare_med,
1819        no_bgp_always_compare_med_cmd,
1820        "no bgp always-compare-med",
1821        NO_STR
1822        "BGP specific commands\n"
1823        "Allow comparing MED from different neighbors\n")
1824 {
1825         VTY_DECLVAR_CONTEXT(bgp, bgp);
1826         bgp_flag_unset(bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1827         bgp_recalculate_all_bestpaths(bgp);
1828
1829         return CMD_SUCCESS;
1830 }
1831
1832
1833 DEFUN(bgp_ebgp_requires_policy, bgp_ebgp_requires_policy_cmd,
1834       "bgp ebgp-requires-policy",
1835       "BGP specific commands\n"
1836       "Require in and out policy for eBGP peers (RFC8212)\n")
1837 {
1838         VTY_DECLVAR_CONTEXT(bgp, bgp);
1839         bgp->ebgp_requires_policy = DEFAULT_EBGP_POLICY_ENABLED;
1840         return CMD_SUCCESS;
1841 }
1842
1843 DEFUN(no_bgp_ebgp_requires_policy, no_bgp_ebgp_requires_policy_cmd,
1844       "no bgp ebgp-requires-policy",
1845       NO_STR
1846       "BGP specific commands\n"
1847       "Require in and out policy for eBGP peers (RFC8212)\n")
1848 {
1849         VTY_DECLVAR_CONTEXT(bgp, bgp);
1850         bgp->ebgp_requires_policy = DEFAULT_EBGP_POLICY_DISABLED;
1851         return CMD_SUCCESS;
1852 }
1853
1854
1855 /* "bgp deterministic-med" configuration. */
1856 DEFUN (bgp_deterministic_med,
1857        bgp_deterministic_med_cmd,
1858        "bgp deterministic-med",
1859        "BGP specific commands\n"
1860        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1861 {
1862         VTY_DECLVAR_CONTEXT(bgp, bgp);
1863
1864         if (!bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)) {
1865                 bgp_flag_set(bgp, BGP_FLAG_DETERMINISTIC_MED);
1866                 bgp_recalculate_all_bestpaths(bgp);
1867         }
1868
1869         return CMD_SUCCESS;
1870 }
1871
1872 DEFUN (no_bgp_deterministic_med,
1873        no_bgp_deterministic_med_cmd,
1874        "no bgp deterministic-med",
1875        NO_STR
1876        "BGP specific commands\n"
1877        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1878 {
1879         VTY_DECLVAR_CONTEXT(bgp, bgp);
1880         int bestpath_per_as_used;
1881         afi_t afi;
1882         safi_t safi;
1883         struct peer *peer;
1884         struct listnode *node, *nnode;
1885
1886         if (bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED)) {
1887                 bestpath_per_as_used = 0;
1888
1889                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
1890                         FOREACH_AFI_SAFI (afi, safi)
1891                                 if (bgp_addpath_dmed_required(
1892                                         peer->addpath_type[afi][safi])) {
1893                                         bestpath_per_as_used = 1;
1894                                         break;
1895                                 }
1896
1897                         if (bestpath_per_as_used)
1898                                 break;
1899                 }
1900
1901                 if (bestpath_per_as_used) {
1902                         vty_out(vty,
1903                                 "bgp deterministic-med cannot be disabled while addpath-tx-bestpath-per-AS is in use\n");
1904                         return CMD_WARNING_CONFIG_FAILED;
1905                 } else {
1906                         bgp_flag_unset(bgp, BGP_FLAG_DETERMINISTIC_MED);
1907                         bgp_recalculate_all_bestpaths(bgp);
1908                 }
1909         }
1910
1911         return CMD_SUCCESS;
1912 }
1913
1914 /* "bgp graceful-restart" configuration. */
1915 DEFUN (bgp_graceful_restart,
1916        bgp_graceful_restart_cmd,
1917        "bgp graceful-restart",
1918        "BGP specific commands\n"
1919        "Graceful restart capability parameters\n")
1920 {
1921         VTY_DECLVAR_CONTEXT(bgp, bgp);
1922         bgp_flag_set(bgp, BGP_FLAG_GRACEFUL_RESTART);
1923         return CMD_SUCCESS;
1924 }
1925
1926 DEFUN (no_bgp_graceful_restart,
1927        no_bgp_graceful_restart_cmd,
1928        "no bgp graceful-restart",
1929        NO_STR
1930        "BGP specific commands\n"
1931        "Graceful restart capability parameters\n")
1932 {
1933         VTY_DECLVAR_CONTEXT(bgp, bgp);
1934         bgp_flag_unset(bgp, BGP_FLAG_GRACEFUL_RESTART);
1935         return CMD_SUCCESS;
1936 }
1937
1938 DEFUN (bgp_graceful_restart_stalepath_time,
1939        bgp_graceful_restart_stalepath_time_cmd,
1940        "bgp graceful-restart stalepath-time (1-4095)",
1941        "BGP specific commands\n"
1942        "Graceful restart capability parameters\n"
1943        "Set the max time to hold onto restarting peer's stale paths\n"
1944        "Delay value (seconds)\n")
1945 {
1946         VTY_DECLVAR_CONTEXT(bgp, bgp);
1947         int idx_number = 3;
1948         uint32_t stalepath;
1949
1950         stalepath = strtoul(argv[idx_number]->arg, NULL, 10);
1951         bgp->stalepath_time = stalepath;
1952         return CMD_SUCCESS;
1953 }
1954
1955 DEFUN (bgp_graceful_restart_restart_time,
1956        bgp_graceful_restart_restart_time_cmd,
1957        "bgp graceful-restart restart-time (1-4095)",
1958        "BGP specific commands\n"
1959        "Graceful restart capability parameters\n"
1960        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1961        "Delay value (seconds)\n")
1962 {
1963         VTY_DECLVAR_CONTEXT(bgp, bgp);
1964         int idx_number = 3;
1965         uint32_t restart;
1966
1967         restart = strtoul(argv[idx_number]->arg, NULL, 10);
1968         bgp->restart_time = restart;
1969         return CMD_SUCCESS;
1970 }
1971
1972 DEFUN (no_bgp_graceful_restart_stalepath_time,
1973        no_bgp_graceful_restart_stalepath_time_cmd,
1974        "no bgp graceful-restart stalepath-time [(1-4095)]",
1975        NO_STR
1976        "BGP specific commands\n"
1977        "Graceful restart capability parameters\n"
1978        "Set the max time to hold onto restarting peer's stale paths\n"
1979        "Delay value (seconds)\n")
1980 {
1981         VTY_DECLVAR_CONTEXT(bgp, bgp);
1982
1983         bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
1984         return CMD_SUCCESS;
1985 }
1986
1987 DEFUN (no_bgp_graceful_restart_restart_time,
1988        no_bgp_graceful_restart_restart_time_cmd,
1989        "no bgp graceful-restart restart-time [(1-4095)]",
1990        NO_STR
1991        "BGP specific commands\n"
1992        "Graceful restart capability parameters\n"
1993        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1994        "Delay value (seconds)\n")
1995 {
1996         VTY_DECLVAR_CONTEXT(bgp, bgp);
1997
1998         bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
1999         return CMD_SUCCESS;
2000 }
2001
2002 DEFUN (bgp_graceful_restart_preserve_fw,
2003        bgp_graceful_restart_preserve_fw_cmd,
2004        "bgp graceful-restart preserve-fw-state",
2005        "BGP specific commands\n"
2006        "Graceful restart capability parameters\n"
2007        "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
2008 {
2009         VTY_DECLVAR_CONTEXT(bgp, bgp);
2010         bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD);
2011         return CMD_SUCCESS;
2012 }
2013
2014 DEFUN (no_bgp_graceful_restart_preserve_fw,
2015        no_bgp_graceful_restart_preserve_fw_cmd,
2016        "no bgp graceful-restart preserve-fw-state",
2017        NO_STR
2018        "BGP specific commands\n"
2019        "Graceful restart capability parameters\n"
2020        "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
2021 {
2022         VTY_DECLVAR_CONTEXT(bgp, bgp);
2023         bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD);
2024         return CMD_SUCCESS;
2025 }
2026
2027 /* "bgp graceful-shutdown" configuration */
2028 DEFUN (bgp_graceful_shutdown,
2029        bgp_graceful_shutdown_cmd,
2030        "bgp graceful-shutdown",
2031        BGP_STR
2032        "Graceful shutdown parameters\n")
2033 {
2034         VTY_DECLVAR_CONTEXT(bgp, bgp);
2035
2036         if (!bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
2037                 bgp_flag_set(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN);
2038                 bgp_static_redo_import_check(bgp);
2039                 bgp_redistribute_redo(bgp);
2040                 bgp_clear_star_soft_out(vty, bgp->name);
2041                 bgp_clear_star_soft_in(vty, bgp->name);
2042         }
2043
2044         return CMD_SUCCESS;
2045 }
2046
2047 DEFUN (no_bgp_graceful_shutdown,
2048        no_bgp_graceful_shutdown_cmd,
2049        "no bgp graceful-shutdown",
2050        NO_STR
2051        BGP_STR
2052        "Graceful shutdown parameters\n")
2053 {
2054         VTY_DECLVAR_CONTEXT(bgp, bgp);
2055
2056         if (bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)) {
2057                 bgp_flag_unset(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN);
2058                 bgp_static_redo_import_check(bgp);
2059                 bgp_redistribute_redo(bgp);
2060                 bgp_clear_star_soft_out(vty, bgp->name);
2061                 bgp_clear_star_soft_in(vty, bgp->name);
2062         }
2063
2064         return CMD_SUCCESS;
2065 }
2066
2067 /* "bgp fast-external-failover" configuration. */
2068 DEFUN (bgp_fast_external_failover,
2069        bgp_fast_external_failover_cmd,
2070        "bgp fast-external-failover",
2071        BGP_STR
2072        "Immediately reset session if a link to a directly connected external peer goes down\n")
2073 {
2074         VTY_DECLVAR_CONTEXT(bgp, bgp);
2075         bgp_flag_unset(bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
2076         return CMD_SUCCESS;
2077 }
2078
2079 DEFUN (no_bgp_fast_external_failover,
2080        no_bgp_fast_external_failover_cmd,
2081        "no bgp fast-external-failover",
2082        NO_STR
2083        BGP_STR
2084        "Immediately reset session if a link to a directly connected external peer goes down\n")
2085 {
2086         VTY_DECLVAR_CONTEXT(bgp, bgp);
2087         bgp_flag_set(bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
2088         return CMD_SUCCESS;
2089 }
2090
2091 /* "bgp bestpath compare-routerid" configuration.  */
2092 DEFUN (bgp_bestpath_compare_router_id,
2093        bgp_bestpath_compare_router_id_cmd,
2094        "bgp bestpath compare-routerid",
2095        "BGP specific commands\n"
2096        "Change the default bestpath selection\n"
2097        "Compare router-id for identical EBGP paths\n")
2098 {
2099         VTY_DECLVAR_CONTEXT(bgp, bgp);
2100         bgp_flag_set(bgp, BGP_FLAG_COMPARE_ROUTER_ID);
2101         bgp_recalculate_all_bestpaths(bgp);
2102
2103         return CMD_SUCCESS;
2104 }
2105
2106 DEFUN (no_bgp_bestpath_compare_router_id,
2107        no_bgp_bestpath_compare_router_id_cmd,
2108        "no bgp bestpath compare-routerid",
2109        NO_STR
2110        "BGP specific commands\n"
2111        "Change the default bestpath selection\n"
2112        "Compare router-id for identical EBGP paths\n")
2113 {
2114         VTY_DECLVAR_CONTEXT(bgp, bgp);
2115         bgp_flag_unset(bgp, BGP_FLAG_COMPARE_ROUTER_ID);
2116         bgp_recalculate_all_bestpaths(bgp);
2117
2118         return CMD_SUCCESS;
2119 }
2120
2121 /* "bgp bestpath as-path ignore" configuration.  */
2122 DEFUN (bgp_bestpath_aspath_ignore,
2123        bgp_bestpath_aspath_ignore_cmd,
2124        "bgp bestpath as-path ignore",
2125        "BGP specific commands\n"
2126        "Change the default bestpath selection\n"
2127        "AS-path attribute\n"
2128        "Ignore as-path length in selecting a route\n")
2129 {
2130         VTY_DECLVAR_CONTEXT(bgp, bgp);
2131         bgp_flag_set(bgp, BGP_FLAG_ASPATH_IGNORE);
2132         bgp_recalculate_all_bestpaths(bgp);
2133
2134         return CMD_SUCCESS;
2135 }
2136
2137 DEFUN (no_bgp_bestpath_aspath_ignore,
2138        no_bgp_bestpath_aspath_ignore_cmd,
2139        "no bgp bestpath as-path ignore",
2140        NO_STR
2141        "BGP specific commands\n"
2142        "Change the default bestpath selection\n"
2143        "AS-path attribute\n"
2144        "Ignore as-path length in selecting a route\n")
2145 {
2146         VTY_DECLVAR_CONTEXT(bgp, bgp);
2147         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_IGNORE);
2148         bgp_recalculate_all_bestpaths(bgp);
2149
2150         return CMD_SUCCESS;
2151 }
2152
2153 /* "bgp bestpath as-path confed" configuration.  */
2154 DEFUN (bgp_bestpath_aspath_confed,
2155        bgp_bestpath_aspath_confed_cmd,
2156        "bgp bestpath as-path confed",
2157        "BGP specific commands\n"
2158        "Change the default bestpath selection\n"
2159        "AS-path attribute\n"
2160        "Compare path lengths including confederation sets & sequences in selecting a route\n")
2161 {
2162         VTY_DECLVAR_CONTEXT(bgp, bgp);
2163         bgp_flag_set(bgp, BGP_FLAG_ASPATH_CONFED);
2164         bgp_recalculate_all_bestpaths(bgp);
2165
2166         return CMD_SUCCESS;
2167 }
2168
2169 DEFUN (no_bgp_bestpath_aspath_confed,
2170        no_bgp_bestpath_aspath_confed_cmd,
2171        "no bgp bestpath as-path confed",
2172        NO_STR
2173        "BGP specific commands\n"
2174        "Change the default bestpath selection\n"
2175        "AS-path attribute\n"
2176        "Compare path lengths including confederation sets & sequences in selecting a route\n")
2177 {
2178         VTY_DECLVAR_CONTEXT(bgp, bgp);
2179         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_CONFED);
2180         bgp_recalculate_all_bestpaths(bgp);
2181
2182         return CMD_SUCCESS;
2183 }
2184
2185 /* "bgp bestpath as-path multipath-relax" configuration.  */
2186 DEFUN (bgp_bestpath_aspath_multipath_relax,
2187        bgp_bestpath_aspath_multipath_relax_cmd,
2188        "bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2189        "BGP specific commands\n"
2190        "Change the default bestpath selection\n"
2191        "AS-path attribute\n"
2192        "Allow load sharing across routes that have different AS paths (but same length)\n"
2193        "Generate an AS_SET\n"
2194        "Do not generate an AS_SET\n")
2195 {
2196         VTY_DECLVAR_CONTEXT(bgp, bgp);
2197         int idx = 0;
2198         bgp_flag_set(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2199
2200         /* no-as-set is now the default behavior so we can silently
2201          * ignore it */
2202         if (argv_find(argv, argc, "as-set", &idx))
2203                 bgp_flag_set(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2204         else
2205                 bgp_flag_unset(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2206
2207         bgp_recalculate_all_bestpaths(bgp);
2208
2209         return CMD_SUCCESS;
2210 }
2211
2212 DEFUN (no_bgp_bestpath_aspath_multipath_relax,
2213        no_bgp_bestpath_aspath_multipath_relax_cmd,
2214        "no bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2215        NO_STR
2216        "BGP specific commands\n"
2217        "Change the default bestpath selection\n"
2218        "AS-path attribute\n"
2219        "Allow load sharing across routes that have different AS paths (but same length)\n"
2220        "Generate an AS_SET\n"
2221        "Do not generate an AS_SET\n")
2222 {
2223         VTY_DECLVAR_CONTEXT(bgp, bgp);
2224         bgp_flag_unset(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2225         bgp_flag_unset(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2226         bgp_recalculate_all_bestpaths(bgp);
2227
2228         return CMD_SUCCESS;
2229 }
2230
2231 /* "bgp log-neighbor-changes" configuration.  */
2232 DEFUN (bgp_log_neighbor_changes,
2233        bgp_log_neighbor_changes_cmd,
2234        "bgp log-neighbor-changes",
2235        "BGP specific commands\n"
2236        "Log neighbor up/down and reset reason\n")
2237 {
2238         VTY_DECLVAR_CONTEXT(bgp, bgp);
2239         bgp_flag_set(bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2240         return CMD_SUCCESS;
2241 }
2242
2243 DEFUN (no_bgp_log_neighbor_changes,
2244        no_bgp_log_neighbor_changes_cmd,
2245        "no bgp log-neighbor-changes",
2246        NO_STR
2247        "BGP specific commands\n"
2248        "Log neighbor up/down and reset reason\n")
2249 {
2250         VTY_DECLVAR_CONTEXT(bgp, bgp);
2251         bgp_flag_unset(bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2252         return CMD_SUCCESS;
2253 }
2254
2255 /* "bgp bestpath med" configuration. */
2256 DEFUN (bgp_bestpath_med,
2257        bgp_bestpath_med_cmd,
2258        "bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2259        "BGP specific commands\n"
2260        "Change the default bestpath selection\n"
2261        "MED attribute\n"
2262        "Compare MED among confederation paths\n"
2263        "Treat missing MED as the least preferred one\n"
2264        "Treat missing MED as the least preferred one\n"
2265        "Compare MED among confederation paths\n")
2266 {
2267         VTY_DECLVAR_CONTEXT(bgp, bgp);
2268
2269         int idx = 0;
2270         if (argv_find(argv, argc, "confed", &idx))
2271                 bgp_flag_set(bgp, BGP_FLAG_MED_CONFED);
2272         idx = 0;
2273         if (argv_find(argv, argc, "missing-as-worst", &idx))
2274                 bgp_flag_set(bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2275
2276         bgp_recalculate_all_bestpaths(bgp);
2277
2278         return CMD_SUCCESS;
2279 }
2280
2281 DEFUN (no_bgp_bestpath_med,
2282        no_bgp_bestpath_med_cmd,
2283        "no bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2284        NO_STR
2285        "BGP specific commands\n"
2286        "Change the default bestpath selection\n"
2287        "MED attribute\n"
2288        "Compare MED among confederation paths\n"
2289        "Treat missing MED as the least preferred one\n"
2290        "Treat missing MED as the least preferred one\n"
2291        "Compare MED among confederation paths\n")
2292 {
2293         VTY_DECLVAR_CONTEXT(bgp, bgp);
2294
2295         int idx = 0;
2296         if (argv_find(argv, argc, "confed", &idx))
2297                 bgp_flag_unset(bgp, BGP_FLAG_MED_CONFED);
2298         idx = 0;
2299         if (argv_find(argv, argc, "missing-as-worst", &idx))
2300                 bgp_flag_unset(bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2301
2302         bgp_recalculate_all_bestpaths(bgp);
2303
2304         return CMD_SUCCESS;
2305 }
2306
2307 /* "no bgp default ipv4-unicast". */
2308 DEFUN (no_bgp_default_ipv4_unicast,
2309        no_bgp_default_ipv4_unicast_cmd,
2310        "no bgp default ipv4-unicast",
2311        NO_STR
2312        "BGP specific commands\n"
2313        "Configure BGP defaults\n"
2314        "Activate ipv4-unicast for a peer by default\n")
2315 {
2316         VTY_DECLVAR_CONTEXT(bgp, bgp);
2317         bgp_flag_set(bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2318         return CMD_SUCCESS;
2319 }
2320
2321 DEFUN (bgp_default_ipv4_unicast,
2322        bgp_default_ipv4_unicast_cmd,
2323        "bgp default ipv4-unicast",
2324        "BGP specific commands\n"
2325        "Configure BGP defaults\n"
2326        "Activate ipv4-unicast for a peer by default\n")
2327 {
2328         VTY_DECLVAR_CONTEXT(bgp, bgp);
2329         bgp_flag_unset(bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2330         return CMD_SUCCESS;
2331 }
2332
2333 /* Display hostname in certain command outputs */
2334 DEFUN (bgp_default_show_hostname,
2335        bgp_default_show_hostname_cmd,
2336        "bgp default show-hostname",
2337        "BGP specific commands\n"
2338        "Configure BGP defaults\n"
2339        "Show hostname in certain command outputs\n")
2340 {
2341         VTY_DECLVAR_CONTEXT(bgp, bgp);
2342         bgp_flag_set(bgp, BGP_FLAG_SHOW_HOSTNAME);
2343         return CMD_SUCCESS;
2344 }
2345
2346 DEFUN (no_bgp_default_show_hostname,
2347        no_bgp_default_show_hostname_cmd,
2348        "no bgp default show-hostname",
2349        NO_STR
2350        "BGP specific commands\n"
2351        "Configure BGP defaults\n"
2352        "Show hostname in certain command outputs\n")
2353 {
2354         VTY_DECLVAR_CONTEXT(bgp, bgp);
2355         bgp_flag_unset(bgp, BGP_FLAG_SHOW_HOSTNAME);
2356         return CMD_SUCCESS;
2357 }
2358
2359 /* "bgp network import-check" configuration.  */
2360 DEFUN (bgp_network_import_check,
2361        bgp_network_import_check_cmd,
2362        "bgp network import-check",
2363        "BGP specific commands\n"
2364        "BGP network command\n"
2365        "Check BGP network route exists in IGP\n")
2366 {
2367         VTY_DECLVAR_CONTEXT(bgp, bgp);
2368         if (!bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK)) {
2369                 bgp_flag_set(bgp, BGP_FLAG_IMPORT_CHECK);
2370                 bgp_static_redo_import_check(bgp);
2371         }
2372
2373         return CMD_SUCCESS;
2374 }
2375
2376 ALIAS_HIDDEN(bgp_network_import_check, bgp_network_import_check_exact_cmd,
2377              "bgp network import-check exact",
2378              "BGP specific commands\n"
2379              "BGP network command\n"
2380              "Check BGP network route exists in IGP\n"
2381              "Match route precisely\n")
2382
2383 DEFUN (no_bgp_network_import_check,
2384        no_bgp_network_import_check_cmd,
2385        "no bgp network import-check",
2386        NO_STR
2387        "BGP specific commands\n"
2388        "BGP network command\n"
2389        "Check BGP network route exists in IGP\n")
2390 {
2391         VTY_DECLVAR_CONTEXT(bgp, bgp);
2392         if (bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK)) {
2393                 bgp_flag_unset(bgp, BGP_FLAG_IMPORT_CHECK);
2394                 bgp_static_redo_import_check(bgp);
2395         }
2396
2397         return CMD_SUCCESS;
2398 }
2399
2400 DEFUN (bgp_default_local_preference,
2401        bgp_default_local_preference_cmd,
2402        "bgp default local-preference (0-4294967295)",
2403        "BGP specific commands\n"
2404        "Configure BGP defaults\n"
2405        "local preference (higher=more preferred)\n"
2406        "Configure default local preference value\n")
2407 {
2408         VTY_DECLVAR_CONTEXT(bgp, bgp);
2409         int idx_number = 3;
2410         uint32_t local_pref;
2411
2412         local_pref = strtoul(argv[idx_number]->arg, NULL, 10);
2413
2414         bgp_default_local_preference_set(bgp, local_pref);
2415         bgp_clear_star_soft_in(vty, bgp->name);
2416
2417         return CMD_SUCCESS;
2418 }
2419
2420 DEFUN (no_bgp_default_local_preference,
2421        no_bgp_default_local_preference_cmd,
2422        "no bgp default local-preference [(0-4294967295)]",
2423        NO_STR
2424        "BGP specific commands\n"
2425        "Configure BGP defaults\n"
2426        "local preference (higher=more preferred)\n"
2427        "Configure default local preference value\n")
2428 {
2429         VTY_DECLVAR_CONTEXT(bgp, bgp);
2430         bgp_default_local_preference_unset(bgp);
2431         bgp_clear_star_soft_in(vty, bgp->name);
2432
2433         return CMD_SUCCESS;
2434 }
2435
2436
2437 DEFUN (bgp_default_subgroup_pkt_queue_max,
2438        bgp_default_subgroup_pkt_queue_max_cmd,
2439        "bgp default subgroup-pkt-queue-max (20-100)",
2440        "BGP specific commands\n"
2441        "Configure BGP defaults\n"
2442        "subgroup-pkt-queue-max\n"
2443        "Configure subgroup packet queue max\n")
2444 {
2445         VTY_DECLVAR_CONTEXT(bgp, bgp);
2446         int idx_number = 3;
2447         uint32_t max_size;
2448
2449         max_size = strtoul(argv[idx_number]->arg, NULL, 10);
2450
2451         bgp_default_subgroup_pkt_queue_max_set(bgp, max_size);
2452
2453         return CMD_SUCCESS;
2454 }
2455
2456 DEFUN (no_bgp_default_subgroup_pkt_queue_max,
2457        no_bgp_default_subgroup_pkt_queue_max_cmd,
2458        "no bgp default subgroup-pkt-queue-max [(20-100)]",
2459        NO_STR
2460        "BGP specific commands\n"
2461        "Configure BGP defaults\n"
2462        "subgroup-pkt-queue-max\n"
2463        "Configure subgroup packet queue max\n")
2464 {
2465         VTY_DECLVAR_CONTEXT(bgp, bgp);
2466         bgp_default_subgroup_pkt_queue_max_unset(bgp);
2467         return CMD_SUCCESS;
2468 }
2469
2470
2471 DEFUN (bgp_rr_allow_outbound_policy,
2472        bgp_rr_allow_outbound_policy_cmd,
2473        "bgp route-reflector allow-outbound-policy",
2474        "BGP specific commands\n"
2475        "Allow modifications made by out route-map\n"
2476        "on ibgp neighbors\n")
2477 {
2478         VTY_DECLVAR_CONTEXT(bgp, bgp);
2479
2480         if (!bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
2481                 bgp_flag_set(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2482                 update_group_announce_rrclients(bgp);
2483                 bgp_clear_star_soft_out(vty, bgp->name);
2484         }
2485
2486         return CMD_SUCCESS;
2487 }
2488
2489 DEFUN (no_bgp_rr_allow_outbound_policy,
2490        no_bgp_rr_allow_outbound_policy_cmd,
2491        "no bgp route-reflector allow-outbound-policy",
2492        NO_STR
2493        "BGP specific commands\n"
2494        "Allow modifications made by out route-map\n"
2495        "on ibgp neighbors\n")
2496 {
2497         VTY_DECLVAR_CONTEXT(bgp, bgp);
2498
2499         if (bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
2500                 bgp_flag_unset(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2501                 update_group_announce_rrclients(bgp);
2502                 bgp_clear_star_soft_out(vty, bgp->name);
2503         }
2504
2505         return CMD_SUCCESS;
2506 }
2507
2508 DEFUN (bgp_listen_limit,
2509        bgp_listen_limit_cmd,
2510        "bgp listen limit (1-5000)",
2511        "BGP specific commands\n"
2512        "Configure BGP defaults\n"
2513        "maximum number of BGP Dynamic Neighbors that can be created\n"
2514        "Configure Dynamic Neighbors listen limit value\n")
2515 {
2516         VTY_DECLVAR_CONTEXT(bgp, bgp);
2517         int idx_number = 3;
2518         int listen_limit;
2519
2520         listen_limit = strtoul(argv[idx_number]->arg, NULL, 10);
2521
2522         bgp_listen_limit_set(bgp, listen_limit);
2523
2524         return CMD_SUCCESS;
2525 }
2526
2527 DEFUN (no_bgp_listen_limit,
2528        no_bgp_listen_limit_cmd,
2529        "no bgp listen limit [(1-5000)]",
2530        "BGP specific commands\n"
2531        "Configure BGP defaults\n"
2532        "unset maximum number of BGP Dynamic Neighbors that can be created\n"
2533        "Configure Dynamic Neighbors listen limit value to default\n"
2534        "Configure Dynamic Neighbors listen limit value\n")
2535 {
2536         VTY_DECLVAR_CONTEXT(bgp, bgp);
2537         bgp_listen_limit_unset(bgp);
2538         return CMD_SUCCESS;
2539 }
2540
2541
2542 /*
2543  * Check if this listen range is already configured. Check for exact
2544  * match or overlap based on input.
2545  */
2546 static struct peer_group *listen_range_exists(struct bgp *bgp,
2547                                               struct prefix *range, int exact)
2548 {
2549         struct listnode *node, *nnode;
2550         struct listnode *node1, *nnode1;
2551         struct peer_group *group;
2552         struct prefix *lr;
2553         afi_t afi;
2554         int match;
2555
2556         afi = family2afi(range->family);
2557         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
2558                 for (ALL_LIST_ELEMENTS(group->listen_range[afi], node1, nnode1,
2559                                        lr)) {
2560                         if (exact)
2561                                 match = prefix_same(range, lr);
2562                         else
2563                                 match = (prefix_match(range, lr)
2564                                          || prefix_match(lr, range));
2565                         if (match)
2566                                 return group;
2567                 }
2568         }
2569
2570         return NULL;
2571 }
2572
2573 DEFUN (bgp_listen_range,
2574        bgp_listen_range_cmd,
2575        "bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
2576        "BGP specific commands\n"
2577        "Configure BGP dynamic neighbors listen range\n"
2578        "Configure BGP dynamic neighbors listen range\n"
2579        NEIGHBOR_ADDR_STR
2580        "Member of the peer-group\n"
2581        "Peer-group name\n")
2582 {
2583         VTY_DECLVAR_CONTEXT(bgp, bgp);
2584         struct prefix range;
2585         struct peer_group *group, *existing_group;
2586         afi_t afi;
2587         int ret;
2588         int idx = 0;
2589
2590         argv_find(argv, argc, "A.B.C.D/M", &idx);
2591         argv_find(argv, argc, "X:X::X:X/M", &idx);
2592         char *prefix = argv[idx]->arg;
2593         argv_find(argv, argc, "PGNAME", &idx);
2594         char *peergroup = argv[idx]->arg;
2595
2596         /* Convert IP prefix string to struct prefix. */
2597         ret = str2prefix(prefix, &range);
2598         if (!ret) {
2599                 vty_out(vty, "%% Malformed listen range\n");
2600                 return CMD_WARNING_CONFIG_FAILED;
2601         }
2602
2603         afi = family2afi(range.family);
2604
2605         if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
2606                 vty_out(vty,
2607                         "%% Malformed listen range (link-local address)\n");
2608                 return CMD_WARNING_CONFIG_FAILED;
2609         }
2610
2611         apply_mask(&range);
2612
2613         /* Check if same listen range is already configured. */
2614         existing_group = listen_range_exists(bgp, &range, 1);
2615         if (existing_group) {
2616                 if (strcmp(existing_group->name, peergroup) == 0)
2617                         return CMD_SUCCESS;
2618                 else {
2619                         vty_out(vty,
2620                                 "%% Same listen range is attached to peer-group %s\n",
2621                                 existing_group->name);
2622                         return CMD_WARNING_CONFIG_FAILED;
2623                 }
2624         }
2625
2626         /* Check if an overlapping listen range exists. */
2627         if (listen_range_exists(bgp, &range, 0)) {
2628                 vty_out(vty,
2629                         "%% Listen range overlaps with existing listen range\n");
2630                 return CMD_WARNING_CONFIG_FAILED;
2631         }
2632
2633         group = peer_group_lookup(bgp, peergroup);
2634         if (!group) {
2635                 vty_out(vty, "%% Configure the peer-group first\n");
2636                 return CMD_WARNING_CONFIG_FAILED;
2637         }
2638
2639         ret = peer_group_listen_range_add(group, &range);
2640         return bgp_vty_return(vty, ret);
2641 }
2642
2643 DEFUN (no_bgp_listen_range,
2644        no_bgp_listen_range_cmd,
2645        "no bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group PGNAME",
2646        NO_STR
2647        "BGP specific commands\n"
2648        "Unconfigure BGP dynamic neighbors listen range\n"
2649        "Unconfigure BGP dynamic neighbors listen range\n"
2650        NEIGHBOR_ADDR_STR
2651        "Member of the peer-group\n"
2652        "Peer-group name\n")
2653 {
2654         VTY_DECLVAR_CONTEXT(bgp, bgp);
2655         struct prefix range;
2656         struct peer_group *group;
2657         afi_t afi;
2658         int ret;
2659         int idx = 0;
2660
2661         argv_find(argv, argc, "A.B.C.D/M", &idx);
2662         argv_find(argv, argc, "X:X::X:X/M", &idx);
2663         char *prefix = argv[idx]->arg;
2664         argv_find(argv, argc, "WORD", &idx);
2665         char *peergroup = argv[idx]->arg;
2666
2667         /* Convert IP prefix string to struct prefix. */
2668         ret = str2prefix(prefix, &range);
2669         if (!ret) {
2670                 vty_out(vty, "%% Malformed listen range\n");
2671                 return CMD_WARNING_CONFIG_FAILED;
2672         }
2673
2674         afi = family2afi(range.family);
2675
2676         if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&range.u.prefix6)) {
2677                 vty_out(vty,
2678                         "%% Malformed listen range (link-local address)\n");
2679                 return CMD_WARNING_CONFIG_FAILED;
2680         }
2681
2682         apply_mask(&range);
2683
2684         group = peer_group_lookup(bgp, peergroup);
2685         if (!group) {
2686                 vty_out(vty, "%% Peer-group does not exist\n");
2687                 return CMD_WARNING_CONFIG_FAILED;
2688         }
2689
2690         ret = peer_group_listen_range_del(group, &range);
2691         return bgp_vty_return(vty, ret);
2692 }
2693
2694 void bgp_config_write_listen(struct vty *vty, struct bgp *bgp)
2695 {
2696         struct peer_group *group;
2697         struct listnode *node, *nnode, *rnode, *nrnode;
2698         struct prefix *range;
2699         afi_t afi;
2700         char buf[PREFIX2STR_BUFFER];
2701
2702         if (bgp->dynamic_neighbors_limit != BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT)
2703                 vty_out(vty, " bgp listen limit %d\n",
2704                         bgp->dynamic_neighbors_limit);
2705
2706         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
2707                 for (afi = AFI_IP; afi < AFI_MAX; afi++) {
2708                         for (ALL_LIST_ELEMENTS(group->listen_range[afi], rnode,
2709                                                nrnode, range)) {
2710                                 prefix2str(range, buf, sizeof(buf));
2711                                 vty_out(vty,
2712                                         " bgp listen range %s peer-group %s\n",
2713                                         buf, group->name);
2714                         }
2715                 }
2716         }
2717 }
2718
2719
2720 DEFUN (bgp_disable_connected_route_check,
2721        bgp_disable_connected_route_check_cmd,
2722        "bgp disable-ebgp-connected-route-check",
2723        "BGP specific commands\n"
2724        "Disable checking if nexthop is connected on ebgp sessions\n")
2725 {
2726         VTY_DECLVAR_CONTEXT(bgp, bgp);
2727         bgp_flag_set(bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2728         bgp_clear_star_soft_in(vty, bgp->name);
2729
2730         return CMD_SUCCESS;
2731 }
2732
2733 DEFUN (no_bgp_disable_connected_route_check,
2734        no_bgp_disable_connected_route_check_cmd,
2735        "no bgp disable-ebgp-connected-route-check",
2736        NO_STR
2737        "BGP specific commands\n"
2738        "Disable checking if nexthop is connected on ebgp sessions\n")
2739 {
2740         VTY_DECLVAR_CONTEXT(bgp, bgp);
2741         bgp_flag_unset(bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2742         bgp_clear_star_soft_in(vty, bgp->name);
2743
2744         return CMD_SUCCESS;
2745 }
2746
2747
2748 static int peer_remote_as_vty(struct vty *vty, const char *peer_str,
2749                               const char *as_str, afi_t afi, safi_t safi)
2750 {
2751         VTY_DECLVAR_CONTEXT(bgp, bgp);
2752         int ret;
2753         as_t as;
2754         int as_type = AS_SPECIFIED;
2755         union sockunion su;
2756
2757         if (as_str[0] == 'i') {
2758                 as = 0;
2759                 as_type = AS_INTERNAL;
2760         } else if (as_str[0] == 'e') {
2761                 as = 0;
2762                 as_type = AS_EXTERNAL;
2763         } else {
2764                 /* Get AS number.  */
2765                 as = strtoul(as_str, NULL, 10);
2766         }
2767
2768         /* If peer is peer group or interface peer, call proper function. */
2769         ret = str2sockunion(peer_str, &su);
2770         if (ret < 0) {
2771                 struct peer *peer;
2772
2773                 /* Check if existing interface peer */
2774                 peer = peer_lookup_by_conf_if(bgp, peer_str);
2775
2776                 ret = peer_remote_as(bgp, NULL, peer_str, &as, as_type, afi,
2777                                      safi);
2778
2779                 /* if not interface peer, check peer-group settings */
2780                 if (ret < 0 && !peer) {
2781                         ret = peer_group_remote_as(bgp, peer_str, &as, as_type);
2782                         if (ret < 0) {
2783                                 vty_out(vty,
2784                                         "%% Create the peer-group or interface first\n");
2785                                 return CMD_WARNING_CONFIG_FAILED;
2786                         }
2787                         return CMD_SUCCESS;
2788                 }
2789         } else {
2790                 if (peer_address_self_check(bgp, &su)) {
2791                         vty_out(vty,
2792                                 "%% Can not configure the local system as neighbor\n");
2793                         return CMD_WARNING_CONFIG_FAILED;
2794                 }
2795                 ret = peer_remote_as(bgp, &su, NULL, &as, as_type, afi, safi);
2796         }
2797
2798         /* This peer belongs to peer group.  */
2799         switch (ret) {
2800         case BGP_ERR_PEER_GROUP_MEMBER:
2801                 vty_out(vty,
2802                         "%% Peer-group member cannot override remote-as of peer-group\n");
2803                 return CMD_WARNING_CONFIG_FAILED;
2804         case BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT:
2805                 vty_out(vty,
2806                         "%% Peer-group members must be all internal or all external\n");
2807                 return CMD_WARNING_CONFIG_FAILED;
2808         }
2809         return bgp_vty_return(vty, ret);
2810 }
2811
2812 DEFUN (bgp_default_shutdown,
2813        bgp_default_shutdown_cmd,
2814        "[no] bgp default shutdown",
2815        NO_STR
2816        BGP_STR
2817        "Configure BGP defaults\n"
2818        "Apply administrative shutdown to newly configured peers\n")
2819 {
2820         VTY_DECLVAR_CONTEXT(bgp, bgp);
2821         bgp->autoshutdown = !strmatch(argv[0]->text, "no");
2822         return CMD_SUCCESS;
2823 }
2824
2825 DEFUN (neighbor_remote_as,
2826        neighbor_remote_as_cmd,
2827        "neighbor <A.B.C.D|X:X::X:X|WORD> remote-as <(1-4294967295)|internal|external>",
2828        NEIGHBOR_STR
2829        NEIGHBOR_ADDR_STR2
2830        "Specify a BGP neighbor\n"
2831        AS_STR
2832        "Internal BGP peer\n"
2833        "External BGP peer\n")
2834 {
2835         int idx_peer = 1;
2836         int idx_remote_as = 3;
2837         return peer_remote_as_vty(vty, argv[idx_peer]->arg,
2838                                   argv[idx_remote_as]->arg, AFI_IP,
2839                                   SAFI_UNICAST);
2840 }
2841
2842 static int peer_conf_interface_get(struct vty *vty, const char *conf_if,
2843                                    afi_t afi, safi_t safi, int v6only,
2844                                    const char *peer_group_name,
2845                                    const char *as_str)
2846 {
2847         VTY_DECLVAR_CONTEXT(bgp, bgp);
2848         as_t as = 0;
2849         int as_type = AS_UNSPECIFIED;
2850         struct peer *peer;
2851         struct peer_group *group;
2852         int ret = 0;
2853         union sockunion su;
2854
2855         group = peer_group_lookup(bgp, conf_if);
2856
2857         if (group) {
2858                 vty_out(vty, "%% Name conflict with peer-group \n");
2859                 return CMD_WARNING_CONFIG_FAILED;
2860         }
2861
2862         if (as_str) {
2863                 if (as_str[0] == 'i') {
2864                         as_type = AS_INTERNAL;
2865                 } else if (as_str[0] == 'e') {
2866                         as_type = AS_EXTERNAL;
2867                 } else {
2868                         /* Get AS number.  */
2869                         as = strtoul(as_str, NULL, 10);
2870                         as_type = AS_SPECIFIED;
2871                 }
2872         }
2873
2874         peer = peer_lookup_by_conf_if(bgp, conf_if);
2875         if (peer) {
2876                 if (as_str)
2877                         ret = peer_remote_as(bgp, NULL, conf_if, &as, as_type,
2878                                              afi, safi);
2879         } else {
2880                 if (bgp_flag_check(bgp, BGP_FLAG_NO_DEFAULT_IPV4)
2881                     && afi == AFI_IP && safi == SAFI_UNICAST)
2882                         peer = peer_create(NULL, conf_if, bgp, bgp->as, as,
2883                                            as_type, 0, 0, NULL);
2884                 else
2885                         peer = peer_create(NULL, conf_if, bgp, bgp->as, as,
2886                                            as_type, afi, safi, NULL);
2887
2888                 if (!peer) {
2889                         vty_out(vty, "%% BGP failed to create peer\n");
2890                         return CMD_WARNING_CONFIG_FAILED;
2891                 }
2892
2893                 if (v6only)
2894                         peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
2895
2896                 /* Request zebra to initiate IPv6 RAs on this interface. We do
2897                  * this
2898                  * any unnumbered peer in order to not worry about run-time
2899                  * transitions
2900                  * (e.g., peering is initially IPv4, but the IPv4 /30 or /31
2901                  * address
2902                  * gets deleted later etc.)
2903                  */
2904                 if (peer->ifp)
2905                         bgp_zebra_initiate_radv(bgp, peer);
2906         }
2907
2908         if ((v6only && !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))
2909             || (!v6only && CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY))) {
2910                 if (v6only)
2911                         peer_flag_set(peer, PEER_FLAG_IFPEER_V6ONLY);
2912                 else
2913                         peer_flag_unset(peer, PEER_FLAG_IFPEER_V6ONLY);
2914
2915                 /* v6only flag changed. Reset bgp seesion */
2916                 if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status)) {
2917                         peer->last_reset = PEER_DOWN_V6ONLY_CHANGE;
2918                         bgp_notify_send(peer, BGP_NOTIFY_CEASE,
2919                                         BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2920                 } else
2921                         bgp_session_reset(peer);
2922         }
2923
2924         if (!CHECK_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE)) {
2925                 SET_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE);
2926                 SET_FLAG(peer->flags_invert, PEER_FLAG_CAPABILITY_ENHE);
2927                 SET_FLAG(peer->flags_override, PEER_FLAG_CAPABILITY_ENHE);
2928         }
2929
2930         if (peer_group_name) {
2931                 group = peer_group_lookup(bgp, peer_group_name);
2932                 if (!group) {
2933                         vty_out(vty, "%% Configure the peer-group first\n");
2934                         return CMD_WARNING_CONFIG_FAILED;
2935                 }
2936
2937                 ret = peer_group_bind(bgp, &su, peer, group, &as);
2938         }
2939
2940         return bgp_vty_return(vty, ret);
2941 }
2942
2943 DEFUN (neighbor_interface_config,
2944        neighbor_interface_config_cmd,
2945        "neighbor WORD interface [peer-group PGNAME]",
2946        NEIGHBOR_STR
2947        "Interface name or neighbor tag\n"
2948        "Enable BGP on interface\n"
2949        "Member of the peer-group\n"
2950        "Peer-group name\n")
2951 {
2952         int idx_word = 1;
2953         int idx_peer_group_word = 4;
2954
2955         if (argc > idx_peer_group_word)
2956                 return peer_conf_interface_get(
2957                         vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 0,
2958                         argv[idx_peer_group_word]->arg, NULL);
2959         else
2960                 return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2961                                                SAFI_UNICAST, 0, NULL, NULL);
2962 }
2963
2964 DEFUN (neighbor_interface_config_v6only,
2965        neighbor_interface_config_v6only_cmd,
2966        "neighbor WORD interface v6only [peer-group PGNAME]",
2967        NEIGHBOR_STR
2968        "Interface name or neighbor tag\n"
2969        "Enable BGP on interface\n"
2970        "Enable BGP with v6 link-local only\n"
2971        "Member of the peer-group\n"
2972        "Peer-group name\n")
2973 {
2974         int idx_word = 1;
2975         int idx_peer_group_word = 5;
2976
2977         if (argc > idx_peer_group_word)
2978                 return peer_conf_interface_get(
2979                         vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 1,
2980                         argv[idx_peer_group_word]->arg, NULL);
2981
2982         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
2983                                        SAFI_UNICAST, 1, NULL, NULL);
2984 }
2985
2986
2987 DEFUN (neighbor_interface_config_remote_as,
2988        neighbor_interface_config_remote_as_cmd,
2989        "neighbor WORD interface remote-as <(1-4294967295)|internal|external>",
2990        NEIGHBOR_STR
2991        "Interface name or neighbor tag\n"
2992        "Enable BGP on interface\n"
2993        "Specify a BGP neighbor\n"
2994        AS_STR
2995        "Internal BGP peer\n"
2996        "External BGP peer\n")
2997 {
2998         int idx_word = 1;
2999         int idx_remote_as = 4;
3000         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
3001                                        SAFI_UNICAST, 0, NULL,
3002                                        argv[idx_remote_as]->arg);
3003 }
3004
3005 DEFUN (neighbor_interface_v6only_config_remote_as,
3006        neighbor_interface_v6only_config_remote_as_cmd,
3007        "neighbor WORD interface v6only remote-as <(1-4294967295)|internal|external>",
3008        NEIGHBOR_STR
3009        "Interface name or neighbor tag\n"
3010        "Enable BGP with v6 link-local only\n"
3011        "Enable BGP on interface\n"
3012        "Specify a BGP neighbor\n"
3013        AS_STR
3014        "Internal BGP peer\n"
3015        "External BGP peer\n")
3016 {
3017         int idx_word = 1;
3018         int idx_remote_as = 5;
3019         return peer_conf_interface_get(vty, argv[idx_word]->arg, AFI_IP,
3020                                        SAFI_UNICAST, 1, NULL,
3021                                        argv[idx_remote_as]->arg);
3022 }
3023
3024 DEFUN (neighbor_peer_group,
3025        neighbor_peer_group_cmd,
3026        "neighbor WORD peer-group",
3027        NEIGHBOR_STR
3028        "Interface name or neighbor tag\n"
3029        "Configure peer-group\n")
3030 {
3031         VTY_DECLVAR_CONTEXT(bgp, bgp);
3032         int idx_word = 1;
3033         struct peer *peer;
3034         struct peer_group *group;
3035
3036         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
3037         if (peer) {
3038                 vty_out(vty, "%% Name conflict with interface: \n");
3039                 return CMD_WARNING_CONFIG_FAILED;
3040         }
3041
3042         group = peer_group_get(bgp, argv[idx_word]->arg);
3043         if (!group) {
3044                 vty_out(vty, "%% BGP failed to find or create peer-group\n");
3045                 return CMD_WARNING_CONFIG_FAILED;
3046         }
3047
3048         return CMD_SUCCESS;
3049 }
3050
3051 DEFUN (no_neighbor,
3052        no_neighbor_cmd,
3053        "no neighbor <WORD|<A.B.C.D|X:X::X:X> [remote-as <(1-4294967295)|internal|external>]>",
3054        NO_STR
3055        NEIGHBOR_STR
3056        NEIGHBOR_ADDR_STR2
3057        "Specify a BGP neighbor\n"
3058        AS_STR
3059        "Internal BGP peer\n"
3060        "External BGP peer\n")
3061 {
3062         VTY_DECLVAR_CONTEXT(bgp, bgp);
3063         int idx_peer = 2;
3064         int ret;
3065         union sockunion su;
3066         struct peer_group *group;
3067         struct peer *peer;
3068         struct peer *other;
3069
3070         ret = str2sockunion(argv[idx_peer]->arg, &su);
3071         if (ret < 0) {
3072                 /* look up for neighbor by interface name config. */
3073                 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
3074                 if (peer) {
3075                         /* Request zebra to terminate IPv6 RAs on this
3076                          * interface. */
3077                         if (peer->ifp)
3078                                 bgp_zebra_terminate_radv(peer->bgp, peer);
3079                         peer_delete(peer);
3080                         return CMD_SUCCESS;
3081                 }
3082
3083                 group = peer_group_lookup(bgp, argv[idx_peer]->arg);
3084                 if (group)
3085                         peer_group_delete(group);
3086                 else {
3087                         vty_out(vty, "%% Create the peer-group first\n");
3088                         return CMD_WARNING_CONFIG_FAILED;
3089                 }
3090         } else {
3091                 peer = peer_lookup(bgp, &su);
3092                 if (peer) {
3093                         if (peer_dynamic_neighbor(peer)) {
3094                                 vty_out(vty,
3095                                         "%% Operation not allowed on a dynamic neighbor\n");
3096                                 return CMD_WARNING_CONFIG_FAILED;
3097                         }
3098
3099                         other = peer->doppelganger;
3100                         peer_delete(peer);
3101                         if (other && other->status != Deleted)
3102                                 peer_delete(other);
3103                 }
3104         }
3105
3106         return CMD_SUCCESS;
3107 }
3108
3109 DEFUN (no_neighbor_interface_config,
3110        no_neighbor_interface_config_cmd,
3111        "no neighbor WORD interface [v6only] [peer-group PGNAME] [remote-as <(1-4294967295)|internal|external>]",
3112        NO_STR
3113        NEIGHBOR_STR
3114        "Interface name\n"
3115        "Configure BGP on interface\n"
3116        "Enable BGP with v6 link-local only\n"
3117        "Member of the peer-group\n"
3118        "Peer-group name\n"
3119        "Specify a BGP neighbor\n"
3120        AS_STR
3121        "Internal BGP peer\n"
3122        "External BGP peer\n")
3123 {
3124         VTY_DECLVAR_CONTEXT(bgp, bgp);
3125         int idx_word = 2;
3126         struct peer *peer;
3127
3128         /* look up for neighbor by interface name config. */
3129         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
3130         if (peer) {
3131                 /* Request zebra to terminate IPv6 RAs on this interface. */
3132                 if (peer->ifp)
3133                         bgp_zebra_terminate_radv(peer->bgp, peer);
3134                 peer_delete(peer);
3135         } else {
3136                 vty_out(vty, "%% Create the bgp interface first\n");
3137                 return CMD_WARNING_CONFIG_FAILED;
3138         }
3139         return CMD_SUCCESS;
3140 }
3141
3142 DEFUN (no_neighbor_peer_group,
3143        no_neighbor_peer_group_cmd,
3144        "no neighbor WORD peer-group",
3145        NO_STR
3146        NEIGHBOR_STR
3147        "Neighbor tag\n"
3148        "Configure peer-group\n")
3149 {
3150         VTY_DECLVAR_CONTEXT(bgp, bgp);
3151         int idx_word = 2;
3152         struct peer_group *group;
3153
3154         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3155         if (group)
3156                 peer_group_delete(group);
3157         else {
3158                 vty_out(vty, "%% Create the peer-group first\n");
3159                 return CMD_WARNING_CONFIG_FAILED;
3160         }
3161         return CMD_SUCCESS;
3162 }
3163
3164 DEFUN (no_neighbor_interface_peer_group_remote_as,
3165        no_neighbor_interface_peer_group_remote_as_cmd,
3166        "no neighbor WORD remote-as <(1-4294967295)|internal|external>",
3167        NO_STR
3168        NEIGHBOR_STR
3169        "Interface name or neighbor tag\n"
3170        "Specify a BGP neighbor\n"
3171        AS_STR
3172        "Internal BGP peer\n"
3173        "External BGP peer\n")
3174 {
3175         VTY_DECLVAR_CONTEXT(bgp, bgp);
3176         int idx_word = 2;
3177         struct peer_group *group;
3178         struct peer *peer;
3179
3180         /* look up for neighbor by interface name config. */
3181         peer = peer_lookup_by_conf_if(bgp, argv[idx_word]->arg);
3182         if (peer) {
3183                 peer_as_change(peer, 0, AS_UNSPECIFIED);
3184                 return CMD_SUCCESS;
3185         }
3186
3187         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3188         if (group)
3189                 peer_group_remote_as_delete(group);
3190         else {
3191                 vty_out(vty, "%% Create the peer-group or interface first\n");
3192                 return CMD_WARNING_CONFIG_FAILED;
3193         }
3194         return CMD_SUCCESS;
3195 }
3196
3197 DEFUN (neighbor_local_as,
3198        neighbor_local_as_cmd,
3199        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295)",
3200        NEIGHBOR_STR
3201        NEIGHBOR_ADDR_STR2
3202        "Specify a local-as number\n"
3203        "AS number used as local AS\n")
3204 {
3205         int idx_peer = 1;
3206         int idx_number = 3;
3207         struct peer *peer;
3208         int ret;
3209         as_t as;
3210
3211         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3212         if (!peer)
3213                 return CMD_WARNING_CONFIG_FAILED;
3214
3215         as = strtoul(argv[idx_number]->arg, NULL, 10);
3216         ret = peer_local_as_set(peer, as, 0, 0);
3217         return bgp_vty_return(vty, ret);
3218 }
3219
3220 DEFUN (neighbor_local_as_no_prepend,
3221        neighbor_local_as_no_prepend_cmd,
3222        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend",
3223        NEIGHBOR_STR
3224        NEIGHBOR_ADDR_STR2
3225        "Specify a local-as number\n"
3226        "AS number used as local AS\n"
3227        "Do not prepend local-as to updates from ebgp peers\n")
3228 {
3229         int idx_peer = 1;
3230         int idx_number = 3;
3231         struct peer *peer;
3232         int ret;
3233         as_t as;
3234
3235         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3236         if (!peer)
3237                 return CMD_WARNING_CONFIG_FAILED;
3238
3239         as = strtoul(argv[idx_number]->arg, NULL, 10);
3240         ret = peer_local_as_set(peer, as, 1, 0);
3241         return bgp_vty_return(vty, ret);
3242 }
3243
3244 DEFUN (neighbor_local_as_no_prepend_replace_as,
3245        neighbor_local_as_no_prepend_replace_as_cmd,
3246        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend replace-as",
3247        NEIGHBOR_STR
3248        NEIGHBOR_ADDR_STR2
3249        "Specify a local-as number\n"
3250        "AS number used as local AS\n"
3251        "Do not prepend local-as to updates from ebgp peers\n"
3252        "Do not prepend local-as to updates from ibgp peers\n")
3253 {
3254         int idx_peer = 1;
3255         int idx_number = 3;
3256         struct peer *peer;
3257         int ret;
3258         as_t as;
3259
3260         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3261         if (!peer)
3262                 return CMD_WARNING_CONFIG_FAILED;
3263
3264         as = strtoul(argv[idx_number]->arg, NULL, 10);
3265         ret = peer_local_as_set(peer, as, 1, 1);
3266         return bgp_vty_return(vty, ret);
3267 }
3268
3269 DEFUN (no_neighbor_local_as,
3270        no_neighbor_local_as_cmd,
3271        "no neighbor <A.B.C.D|X:X::X:X|WORD> local-as [(1-4294967295) [no-prepend [replace-as]]]",
3272        NO_STR
3273        NEIGHBOR_STR
3274        NEIGHBOR_ADDR_STR2
3275        "Specify a local-as number\n"
3276        "AS number used as local AS\n"
3277        "Do not prepend local-as to updates from ebgp peers\n"
3278        "Do not prepend local-as to updates from ibgp peers\n")
3279 {
3280         int idx_peer = 2;
3281         struct peer *peer;
3282         int ret;
3283
3284         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3285         if (!peer)
3286                 return CMD_WARNING_CONFIG_FAILED;
3287
3288         ret = peer_local_as_unset(peer);
3289         return bgp_vty_return(vty, ret);
3290 }
3291
3292
3293 DEFUN (neighbor_solo,
3294        neighbor_solo_cmd,
3295        "neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3296        NEIGHBOR_STR
3297        NEIGHBOR_ADDR_STR2
3298        "Solo peer - part of its own update group\n")
3299 {
3300         int idx_peer = 1;
3301         struct peer *peer;
3302         int ret;
3303
3304         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3305         if (!peer)
3306                 return CMD_WARNING_CONFIG_FAILED;
3307
3308         ret = update_group_adjust_soloness(peer, 1);
3309         return bgp_vty_return(vty, ret);
3310 }
3311
3312 DEFUN (no_neighbor_solo,
3313        no_neighbor_solo_cmd,
3314        "no neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3315        NO_STR
3316        NEIGHBOR_STR
3317        NEIGHBOR_ADDR_STR2
3318        "Solo peer - part of its own update group\n")
3319 {
3320         int idx_peer = 2;
3321         struct peer *peer;
3322         int ret;
3323
3324         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3325         if (!peer)
3326                 return CMD_WARNING_CONFIG_FAILED;
3327
3328         ret = update_group_adjust_soloness(peer, 0);
3329         return bgp_vty_return(vty, ret);
3330 }
3331
3332 DEFUN (neighbor_password,
3333        neighbor_password_cmd,
3334        "neighbor <A.B.C.D|X:X::X:X|WORD> password LINE",
3335        NEIGHBOR_STR
3336        NEIGHBOR_ADDR_STR2
3337        "Set a password\n"
3338        "The password\n")
3339 {
3340         int idx_peer = 1;
3341         int idx_line = 3;
3342         struct peer *peer;
3343         int ret;
3344
3345         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3346         if (!peer)
3347                 return CMD_WARNING_CONFIG_FAILED;
3348
3349         ret = peer_password_set(peer, argv[idx_line]->arg);
3350         return bgp_vty_return(vty, ret);
3351 }
3352
3353 DEFUN (no_neighbor_password,
3354        no_neighbor_password_cmd,
3355        "no neighbor <A.B.C.D|X:X::X:X|WORD> password [LINE]",
3356        NO_STR
3357        NEIGHBOR_STR
3358        NEIGHBOR_ADDR_STR2
3359        "Set a password\n"
3360        "The password\n")
3361 {
3362         int idx_peer = 2;
3363         struct peer *peer;
3364         int ret;
3365
3366         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3367         if (!peer)
3368                 return CMD_WARNING_CONFIG_FAILED;
3369
3370         ret = peer_password_unset(peer);
3371         return bgp_vty_return(vty, ret);
3372 }
3373
3374 DEFUN (neighbor_activate,
3375        neighbor_activate_cmd,
3376        "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3377        NEIGHBOR_STR
3378        NEIGHBOR_ADDR_STR2
3379        "Enable the Address Family for this Neighbor\n")
3380 {
3381         int idx_peer = 1;
3382         int ret;
3383         struct peer *peer;
3384
3385         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3386         if (!peer)
3387                 return CMD_WARNING_CONFIG_FAILED;
3388
3389         ret = peer_activate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
3390         return bgp_vty_return(vty, ret);
3391 }
3392
3393 ALIAS_HIDDEN(neighbor_activate, neighbor_activate_hidden_cmd,
3394              "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3395              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3396              "Enable the Address Family for this Neighbor\n")
3397
3398 DEFUN (no_neighbor_activate,
3399        no_neighbor_activate_cmd,
3400        "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3401        NO_STR
3402        NEIGHBOR_STR
3403        NEIGHBOR_ADDR_STR2
3404        "Enable the Address Family for this Neighbor\n")
3405 {
3406         int idx_peer = 2;
3407         int ret;
3408         struct peer *peer;
3409
3410         /* Lookup peer. */
3411         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3412         if (!peer)
3413                 return CMD_WARNING_CONFIG_FAILED;
3414
3415         ret = peer_deactivate(peer, bgp_node_afi(vty), bgp_node_safi(vty));
3416         return bgp_vty_return(vty, ret);
3417 }
3418
3419 ALIAS_HIDDEN(no_neighbor_activate, no_neighbor_activate_hidden_cmd,
3420              "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3421              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3422              "Enable the Address Family for this Neighbor\n")
3423
3424 DEFUN (neighbor_set_peer_group,
3425        neighbor_set_peer_group_cmd,
3426        "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
3427        NEIGHBOR_STR
3428        NEIGHBOR_ADDR_STR2
3429        "Member of the peer-group\n"
3430        "Peer-group name\n")
3431 {
3432         VTY_DECLVAR_CONTEXT(bgp, bgp);
3433         int idx_peer = 1;
3434         int idx_word = 3;
3435         int ret;
3436         as_t as;
3437         union sockunion su;
3438         struct peer *peer;
3439         struct peer_group *group;
3440
3441         ret = str2sockunion(argv[idx_peer]->arg, &su);
3442         if (ret < 0) {
3443                 peer = peer_lookup_by_conf_if(bgp, argv[idx_peer]->arg);
3444                 if (!peer) {
3445                         vty_out(vty, "%% Malformed address or name: %s\n",
3446                                 argv[idx_peer]->arg);
3447                         return CMD_WARNING_CONFIG_FAILED;
3448                 }
3449         } else {
3450                 if (peer_address_self_check(bgp, &su)) {
3451                         vty_out(vty,
3452                                 "%% Can not configure the local system as neighbor\n");
3453                         return CMD_WARNING_CONFIG_FAILED;
3454                 }
3455
3456                 /* Disallow for dynamic neighbor. */
3457                 peer = peer_lookup(bgp, &su);
3458                 if (peer && peer_dynamic_neighbor(peer)) {
3459                         vty_out(vty,
3460                                 "%% Operation not allowed on a dynamic neighbor\n");
3461                         return CMD_WARNING_CONFIG_FAILED;
3462                 }
3463         }
3464
3465         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3466         if (!group) {
3467                 vty_out(vty, "%% Configure the peer-group first\n");
3468                 return CMD_WARNING_CONFIG_FAILED;
3469         }
3470
3471         ret = peer_group_bind(bgp, &su, peer, group, &as);
3472
3473         if (ret == BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT) {
3474                 vty_out(vty,
3475                         "%% Peer with AS %u cannot be in this peer-group, members must be all internal or all external\n",
3476                         as);
3477                 return CMD_WARNING_CONFIG_FAILED;
3478         }
3479
3480         return bgp_vty_return(vty, ret);
3481 }
3482
3483 ALIAS_HIDDEN(neighbor_set_peer_group, neighbor_set_peer_group_hidden_cmd,
3484              "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
3485              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3486              "Member of the peer-group\n"
3487              "Peer-group name\n")
3488
3489 DEFUN (no_neighbor_set_peer_group,
3490        no_neighbor_set_peer_group_cmd,
3491        "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
3492        NO_STR
3493        NEIGHBOR_STR
3494        NEIGHBOR_ADDR_STR2
3495        "Member of the peer-group\n"
3496        "Peer-group name\n")
3497 {
3498         VTY_DECLVAR_CONTEXT(bgp, bgp);
3499         int idx_peer = 2;
3500         int idx_word = 4;
3501         int ret;
3502         struct peer *peer;
3503         struct peer_group *group;
3504
3505         peer = peer_lookup_vty(vty, argv[idx_peer]->arg);
3506         if (!peer)
3507                 return CMD_WARNING_CONFIG_FAILED;
3508
3509         group = peer_group_lookup(bgp, argv[idx_word]->arg);
3510         if (!group) {
3511                 vty_out(vty, "%% Configure the peer-group first\n");
3512                 return CMD_WARNING_CONFIG_FAILED;
3513         }
3514
3515         ret = peer_delete(peer);
3516
3517         return bgp_vty_return(vty, ret);
3518 }
3519
3520 ALIAS_HIDDEN(no_neighbor_set_peer_group, no_neighbor_set_peer_group_hidden_cmd,
3521              "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group PGNAME",
3522              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3523              "Member of the peer-group\n"
3524              "Peer-group name\n")
3525
3526 static int peer_flag_modify_vty(struct vty *vty, const char *ip_str,
3527                                 uint32_t flag, int set)
3528 {
3529         int ret;
3530         struct peer *peer;
3531
3532         peer = peer_and_group_lookup_vty(vty, ip_str);
3533         if (!peer)
3534                 return CMD_WARNING_CONFIG_FAILED;
3535
3536         /*
3537          * If 'neighbor <interface>', then this is for directly connected peers,
3538          * we should not accept disable-connected-check.
3539          */
3540         if (peer->conf_if && (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)) {
3541                 vty_out(vty,
3542                         "%s is directly connected peer, cannot accept disable-"
3543                         "connected-check\n",
3544                         ip_str);
3545                 return CMD_WARNING_CONFIG_FAILED;
3546         }
3547
3548         if (!set && flag == PEER_FLAG_SHUTDOWN)
3549                 peer_tx_shutdown_message_unset(peer);
3550
3551         if (set)
3552                 ret = peer_flag_set(peer, flag);
3553         else
3554                 ret = peer_flag_unset(peer, flag);
3555
3556         return bgp_vty_return(vty, ret);
3557 }
3558
3559 static int peer_flag_set_vty(struct vty *vty, const char *ip_str, uint32_t flag)
3560 {
3561         return peer_flag_modify_vty(vty, ip_str, flag, 1);
3562 }
3563
3564 static int peer_flag_unset_vty(struct vty *vty, const char *ip_str,
3565                                uint32_t flag)
3566 {
3567         return peer_flag_modify_vty(vty, ip_str, flag, 0);
3568 }
3569
3570 /* neighbor passive. */
3571 DEFUN (neighbor_passive,
3572        neighbor_passive_cmd,
3573        "neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3574        NEIGHBOR_STR
3575        NEIGHBOR_ADDR_STR2
3576        "Don't send open messages to this neighbor\n")
3577 {
3578         int idx_peer = 1;
3579         return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3580 }
3581
3582 DEFUN (no_neighbor_passive,
3583        no_neighbor_passive_cmd,
3584        "no neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3585        NO_STR
3586        NEIGHBOR_STR
3587        NEIGHBOR_ADDR_STR2
3588        "Don't send open messages to this neighbor\n")
3589 {
3590         int idx_peer = 2;
3591         return peer_flag_unset_vty(vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3592 }
3593
3594 /* neighbor shutdown. */
3595 DEFUN (neighbor_shutdown_msg,
3596        neighbor_shutdown_msg_cmd,
3597        "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3598        NEIGHBOR_STR
3599        NEIGHBOR_ADDR_STR2
3600        "Administratively shut down this neighbor\n"
3601        "Add a shutdown message (draft-ietf-idr-shutdown-06)\n"
3602        "Shutdown message\n")
3603 {
3604         int idx_peer = 1;
3605
3606         if (argc >= 5) {
3607                 struct peer *peer =
3608                         peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
3609                 char *message;
3610
3611                 if (!peer)
3612                         return CMD_WARNING_CONFIG_FAILED;
3613                 message = argv_concat(argv, argc, 4);
3614                 peer_tx_shutdown_message_set(peer, message);
3615                 XFREE(MTYPE_TMP, message);
3616         }
3617
3618         return peer_flag_set_vty(vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
3619 }
3620
3621 ALIAS(neighbor_shutdown_msg, neighbor_shutdown_cmd,
3622       "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3623       NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3624       "Administratively shut down this neighbor\n")
3625
3626 DEFUN (no_neighbor_shutdown_msg,
3627        no_neighbor_shutdown_msg_cmd,
3628        "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3629        NO_STR
3630        NEIGHBOR_STR
3631        NEIGHBOR_ADDR_STR2
3632        "Administratively shut down this neighbor\n"
3633        "Remove a shutdown message (draft-ietf-idr-shutdown-06)\n"
3634        "Shutdown message\n")
3635 {
3636         int idx_peer = 2;
3637
3638         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3639                                    PEER_FLAG_SHUTDOWN);
3640 }
3641
3642 ALIAS(no_neighbor_shutdown_msg, no_neighbor_shutdown_cmd,
3643       "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3644       NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3645       "Administratively shut down this neighbor\n")
3646
3647 /* neighbor capability dynamic. */
3648 DEFUN (neighbor_capability_dynamic,
3649        neighbor_capability_dynamic_cmd,
3650        "neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3651        NEIGHBOR_STR
3652        NEIGHBOR_ADDR_STR2
3653        "Advertise capability to the peer\n"
3654        "Advertise dynamic capability to this neighbor\n")
3655 {
3656         int idx_peer = 1;
3657         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3658                                  PEER_FLAG_DYNAMIC_CAPABILITY);
3659 }
3660
3661 DEFUN (no_neighbor_capability_dynamic,
3662        no_neighbor_capability_dynamic_cmd,
3663        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3664        NO_STR
3665        NEIGHBOR_STR
3666        NEIGHBOR_ADDR_STR2
3667        "Advertise capability to the peer\n"
3668        "Advertise dynamic capability to this neighbor\n")
3669 {
3670         int idx_peer = 2;
3671         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3672                                    PEER_FLAG_DYNAMIC_CAPABILITY);
3673 }
3674
3675 /* neighbor dont-capability-negotiate */
3676 DEFUN (neighbor_dont_capability_negotiate,
3677        neighbor_dont_capability_negotiate_cmd,
3678        "neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3679        NEIGHBOR_STR
3680        NEIGHBOR_ADDR_STR2
3681        "Do not perform capability negotiation\n")
3682 {
3683         int idx_peer = 1;
3684         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3685                                  PEER_FLAG_DONT_CAPABILITY);
3686 }
3687
3688 DEFUN (no_neighbor_dont_capability_negotiate,
3689        no_neighbor_dont_capability_negotiate_cmd,
3690        "no neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3691        NO_STR
3692        NEIGHBOR_STR
3693        NEIGHBOR_ADDR_STR2
3694        "Do not perform capability negotiation\n")
3695 {
3696         int idx_peer = 2;
3697         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3698                                    PEER_FLAG_DONT_CAPABILITY);
3699 }
3700
3701 /* neighbor capability extended next hop encoding */
3702 DEFUN (neighbor_capability_enhe,
3703        neighbor_capability_enhe_cmd,
3704        "neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3705        NEIGHBOR_STR
3706        NEIGHBOR_ADDR_STR2
3707        "Advertise capability to the peer\n"
3708        "Advertise extended next-hop capability to the peer\n")
3709 {
3710         int idx_peer = 1;
3711         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
3712                                  PEER_FLAG_CAPABILITY_ENHE);
3713 }
3714
3715 DEFUN (no_neighbor_capability_enhe,
3716        no_neighbor_capability_enhe_cmd,
3717        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3718        NO_STR
3719        NEIGHBOR_STR
3720        NEIGHBOR_ADDR_STR2
3721        "Advertise capability to the peer\n"
3722        "Advertise extended next-hop capability to the peer\n")
3723 {
3724         int idx_peer = 2;
3725         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
3726                                    PEER_FLAG_CAPABILITY_ENHE);
3727 }
3728
3729 static int peer_af_flag_modify_vty(struct vty *vty, const char *peer_str,
3730                                    afi_t afi, safi_t safi, uint32_t flag,
3731                                    int set)
3732 {
3733         int ret;
3734         struct peer *peer;
3735
3736         peer = peer_and_group_lookup_vty(vty, peer_str);
3737         if (!peer)
3738                 return CMD_WARNING_CONFIG_FAILED;
3739
3740         if (set)
3741                 ret = peer_af_flag_set(peer, afi, safi, flag);
3742         else
3743                 ret = peer_af_flag_unset(peer, afi, safi, flag);
3744
3745         return bgp_vty_return(vty, ret);
3746 }
3747
3748 static int peer_af_flag_set_vty(struct vty *vty, const char *peer_str,
3749                                 afi_t afi, safi_t safi, uint32_t flag)
3750 {
3751         return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 1);
3752 }
3753
3754 static int peer_af_flag_unset_vty(struct vty *vty, const char *peer_str,
3755                                   afi_t afi, safi_t safi, uint32_t flag)
3756 {
3757         return peer_af_flag_modify_vty(vty, peer_str, afi, safi, flag, 0);
3758 }
3759
3760 /* neighbor capability orf prefix-list. */
3761 DEFUN (neighbor_capability_orf_prefix,
3762        neighbor_capability_orf_prefix_cmd,
3763        "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3764        NEIGHBOR_STR
3765        NEIGHBOR_ADDR_STR2
3766        "Advertise capability to the peer\n"
3767        "Advertise ORF capability to the peer\n"
3768        "Advertise prefixlist ORF capability to this neighbor\n"
3769        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3770        "Capability to RECEIVE the ORF from this neighbor\n"
3771        "Capability to SEND the ORF to this neighbor\n")
3772 {
3773         int idx_peer = 1;
3774         int idx_send_recv = 5;
3775         uint16_t flag = 0;
3776
3777         if (strmatch(argv[idx_send_recv]->text, "send"))
3778                 flag = PEER_FLAG_ORF_PREFIX_SM;
3779         else if (strmatch(argv[idx_send_recv]->text, "receive"))
3780                 flag = PEER_FLAG_ORF_PREFIX_RM;
3781         else if (strmatch(argv[idx_send_recv]->text, "both"))
3782                 flag = PEER_FLAG_ORF_PREFIX_SM | PEER_FLAG_ORF_PREFIX_RM;
3783         else {
3784                 vty_out(vty, "%% BGP invalid orf prefix-list option\n");
3785                 return CMD_WARNING_CONFIG_FAILED;
3786         }
3787
3788         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3789                                     bgp_node_safi(vty), flag);
3790 }
3791
3792 ALIAS_HIDDEN(
3793         neighbor_capability_orf_prefix,
3794         neighbor_capability_orf_prefix_hidden_cmd,
3795         "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3796         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3797         "Advertise capability to the peer\n"
3798         "Advertise ORF capability to the peer\n"
3799         "Advertise prefixlist ORF capability to this neighbor\n"
3800         "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3801         "Capability to RECEIVE the ORF from this neighbor\n"
3802         "Capability to SEND the ORF to this neighbor\n")
3803
3804 DEFUN (no_neighbor_capability_orf_prefix,
3805        no_neighbor_capability_orf_prefix_cmd,
3806        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3807        NO_STR
3808        NEIGHBOR_STR
3809        NEIGHBOR_ADDR_STR2
3810        "Advertise capability to the peer\n"
3811        "Advertise ORF capability to the peer\n"
3812        "Advertise prefixlist ORF capability to this neighbor\n"
3813        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3814        "Capability to RECEIVE the ORF from this neighbor\n"
3815        "Capability to SEND the ORF to this neighbor\n")
3816 {
3817         int idx_peer = 2;
3818         int idx_send_recv = 6;
3819         uint16_t flag = 0;
3820
3821         if (strmatch(argv[idx_send_recv]->text, "send"))
3822                 flag = PEER_FLAG_ORF_PREFIX_SM;
3823         else if (strmatch(argv[idx_send_recv]->text, "receive"))
3824                 flag = PEER_FLAG_ORF_PREFIX_RM;
3825         else if (strmatch(argv[idx_send_recv]->text, "both"))
3826                 flag = PEER_FLAG_ORF_PREFIX_SM | PEER_FLAG_ORF_PREFIX_RM;
3827         else {
3828                 vty_out(vty, "%% BGP invalid orf prefix-list option\n");
3829                 return CMD_WARNING_CONFIG_FAILED;
3830         }
3831
3832         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3833                                       bgp_node_afi(vty), bgp_node_safi(vty),
3834                                       flag);
3835 }
3836
3837 ALIAS_HIDDEN(
3838         no_neighbor_capability_orf_prefix,
3839         no_neighbor_capability_orf_prefix_hidden_cmd,
3840         "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3841         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3842         "Advertise capability to the peer\n"
3843         "Advertise ORF capability to the peer\n"
3844         "Advertise prefixlist ORF capability to this neighbor\n"
3845         "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3846         "Capability to RECEIVE the ORF from this neighbor\n"
3847         "Capability to SEND the ORF to this neighbor\n")
3848
3849 /* neighbor next-hop-self. */
3850 DEFUN (neighbor_nexthop_self,
3851        neighbor_nexthop_self_cmd,
3852        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3853        NEIGHBOR_STR
3854        NEIGHBOR_ADDR_STR2
3855        "Disable the next hop calculation for this neighbor\n")
3856 {
3857         int idx_peer = 1;
3858         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3859                                     bgp_node_safi(vty), PEER_FLAG_NEXTHOP_SELF);
3860 }
3861
3862 ALIAS_HIDDEN(neighbor_nexthop_self, neighbor_nexthop_self_hidden_cmd,
3863              "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3864              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3865              "Disable the next hop calculation for this neighbor\n")
3866
3867 /* neighbor next-hop-self. */
3868 DEFUN (neighbor_nexthop_self_force,
3869        neighbor_nexthop_self_force_cmd,
3870        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3871        NEIGHBOR_STR
3872        NEIGHBOR_ADDR_STR2
3873        "Disable the next hop calculation for this neighbor\n"
3874        "Set the next hop to self for reflected routes\n")
3875 {
3876         int idx_peer = 1;
3877         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3878                                     bgp_node_safi(vty),
3879                                     PEER_FLAG_FORCE_NEXTHOP_SELF);
3880 }
3881
3882 ALIAS_HIDDEN(neighbor_nexthop_self_force,
3883              neighbor_nexthop_self_force_hidden_cmd,
3884              "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3885              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3886              "Disable the next hop calculation for this neighbor\n"
3887              "Set the next hop to self for reflected routes\n")
3888
3889 ALIAS_HIDDEN(neighbor_nexthop_self_force,
3890              neighbor_nexthop_self_all_hidden_cmd,
3891              "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
3892              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3893              "Disable the next hop calculation for this neighbor\n"
3894              "Set the next hop to self for reflected routes\n")
3895
3896 DEFUN (no_neighbor_nexthop_self,
3897        no_neighbor_nexthop_self_cmd,
3898        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3899        NO_STR
3900        NEIGHBOR_STR
3901        NEIGHBOR_ADDR_STR2
3902        "Disable the next hop calculation for this neighbor\n")
3903 {
3904         int idx_peer = 2;
3905         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3906                                       bgp_node_afi(vty), bgp_node_safi(vty),
3907                                       PEER_FLAG_NEXTHOP_SELF);
3908 }
3909
3910 ALIAS_HIDDEN(no_neighbor_nexthop_self, no_neighbor_nexthop_self_hidden_cmd,
3911              "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3912              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3913              "Disable the next hop calculation for this neighbor\n")
3914
3915 DEFUN (no_neighbor_nexthop_self_force,
3916        no_neighbor_nexthop_self_force_cmd,
3917        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3918        NO_STR
3919        NEIGHBOR_STR
3920        NEIGHBOR_ADDR_STR2
3921        "Disable the next hop calculation for this neighbor\n"
3922        "Set the next hop to self for reflected routes\n")
3923 {
3924         int idx_peer = 2;
3925         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3926                                       bgp_node_afi(vty), bgp_node_safi(vty),
3927                                       PEER_FLAG_FORCE_NEXTHOP_SELF);
3928 }
3929
3930 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
3931              no_neighbor_nexthop_self_force_hidden_cmd,
3932              "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3933              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3934              "Disable the next hop calculation for this neighbor\n"
3935              "Set the next hop to self for reflected routes\n")
3936
3937 ALIAS_HIDDEN(no_neighbor_nexthop_self_force,
3938              no_neighbor_nexthop_self_all_hidden_cmd,
3939              "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self all",
3940              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3941              "Disable the next hop calculation for this neighbor\n"
3942              "Set the next hop to self for reflected routes\n")
3943
3944 /* neighbor as-override */
3945 DEFUN (neighbor_as_override,
3946        neighbor_as_override_cmd,
3947        "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3948        NEIGHBOR_STR
3949        NEIGHBOR_ADDR_STR2
3950        "Override ASNs in outbound updates if aspath equals remote-as\n")
3951 {
3952         int idx_peer = 1;
3953         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3954                                     bgp_node_safi(vty), PEER_FLAG_AS_OVERRIDE);
3955 }
3956
3957 ALIAS_HIDDEN(neighbor_as_override, neighbor_as_override_hidden_cmd,
3958              "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3959              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3960              "Override ASNs in outbound updates if aspath equals remote-as\n")
3961
3962 DEFUN (no_neighbor_as_override,
3963        no_neighbor_as_override_cmd,
3964        "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3965        NO_STR
3966        NEIGHBOR_STR
3967        NEIGHBOR_ADDR_STR2
3968        "Override ASNs in outbound updates if aspath equals remote-as\n")
3969 {
3970         int idx_peer = 2;
3971         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
3972                                       bgp_node_afi(vty), bgp_node_safi(vty),
3973                                       PEER_FLAG_AS_OVERRIDE);
3974 }
3975
3976 ALIAS_HIDDEN(no_neighbor_as_override, no_neighbor_as_override_hidden_cmd,
3977              "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3978              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3979              "Override ASNs in outbound updates if aspath equals remote-as\n")
3980
3981 /* neighbor remove-private-AS. */
3982 DEFUN (neighbor_remove_private_as,
3983        neighbor_remove_private_as_cmd,
3984        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3985        NEIGHBOR_STR
3986        NEIGHBOR_ADDR_STR2
3987        "Remove private ASNs in outbound updates\n")
3988 {
3989         int idx_peer = 1;
3990         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
3991                                     bgp_node_safi(vty),
3992                                     PEER_FLAG_REMOVE_PRIVATE_AS);
3993 }
3994
3995 ALIAS_HIDDEN(neighbor_remove_private_as, neighbor_remove_private_as_hidden_cmd,
3996              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3997              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
3998              "Remove private ASNs in outbound updates\n")
3999
4000 DEFUN (neighbor_remove_private_as_all,
4001        neighbor_remove_private_as_all_cmd,
4002        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4003        NEIGHBOR_STR
4004        NEIGHBOR_ADDR_STR2
4005        "Remove private ASNs in outbound updates\n"
4006        "Apply to all AS numbers\n")
4007 {
4008         int idx_peer = 1;
4009         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4010                                     bgp_node_safi(vty),
4011                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
4012 }
4013
4014 ALIAS_HIDDEN(neighbor_remove_private_as_all,
4015              neighbor_remove_private_as_all_hidden_cmd,
4016              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4017              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4018              "Remove private ASNs in outbound updates\n"
4019              "Apply to all AS numbers")
4020
4021 DEFUN (neighbor_remove_private_as_replace_as,
4022        neighbor_remove_private_as_replace_as_cmd,
4023        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4024        NEIGHBOR_STR
4025        NEIGHBOR_ADDR_STR2
4026        "Remove private ASNs in outbound updates\n"
4027        "Replace private ASNs with our ASN in outbound updates\n")
4028 {
4029         int idx_peer = 1;
4030         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4031                                     bgp_node_safi(vty),
4032                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
4033 }
4034
4035 ALIAS_HIDDEN(neighbor_remove_private_as_replace_as,
4036              neighbor_remove_private_as_replace_as_hidden_cmd,
4037              "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4038              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4039              "Remove private ASNs in outbound updates\n"
4040              "Replace private ASNs with our ASN in outbound updates\n")
4041
4042 DEFUN (neighbor_remove_private_as_all_replace_as,
4043        neighbor_remove_private_as_all_replace_as_cmd,
4044        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4045        NEIGHBOR_STR
4046        NEIGHBOR_ADDR_STR2
4047        "Remove private ASNs in outbound updates\n"
4048        "Apply to all AS numbers\n"
4049        "Replace private ASNs with our ASN in outbound updates\n")
4050 {
4051         int idx_peer = 1;
4052         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4053                                     bgp_node_safi(vty),
4054                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
4055 }
4056
4057 ALIAS_HIDDEN(
4058         neighbor_remove_private_as_all_replace_as,
4059         neighbor_remove_private_as_all_replace_as_hidden_cmd,
4060         "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4061         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4062         "Remove private ASNs in outbound updates\n"
4063         "Apply to all AS numbers\n"
4064         "Replace private ASNs with our ASN in outbound updates\n")
4065
4066 DEFUN (no_neighbor_remove_private_as,
4067        no_neighbor_remove_private_as_cmd,
4068        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
4069        NO_STR
4070        NEIGHBOR_STR
4071        NEIGHBOR_ADDR_STR2
4072        "Remove private ASNs in outbound updates\n")
4073 {
4074         int idx_peer = 2;
4075         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4076                                       bgp_node_afi(vty), bgp_node_safi(vty),
4077                                       PEER_FLAG_REMOVE_PRIVATE_AS);
4078 }
4079
4080 ALIAS_HIDDEN(no_neighbor_remove_private_as,
4081              no_neighbor_remove_private_as_hidden_cmd,
4082              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
4083              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4084              "Remove private ASNs in outbound updates\n")
4085
4086 DEFUN (no_neighbor_remove_private_as_all,
4087        no_neighbor_remove_private_as_all_cmd,
4088        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4089        NO_STR
4090        NEIGHBOR_STR
4091        NEIGHBOR_ADDR_STR2
4092        "Remove private ASNs in outbound updates\n"
4093        "Apply to all AS numbers\n")
4094 {
4095         int idx_peer = 2;
4096         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4097                                       bgp_node_afi(vty), bgp_node_safi(vty),
4098                                       PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
4099 }
4100
4101 ALIAS_HIDDEN(no_neighbor_remove_private_as_all,
4102              no_neighbor_remove_private_as_all_hidden_cmd,
4103              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
4104              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4105              "Remove private ASNs in outbound updates\n"
4106              "Apply to all AS numbers\n")
4107
4108 DEFUN (no_neighbor_remove_private_as_replace_as,
4109        no_neighbor_remove_private_as_replace_as_cmd,
4110        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4111        NO_STR
4112        NEIGHBOR_STR
4113        NEIGHBOR_ADDR_STR2
4114        "Remove private ASNs in outbound updates\n"
4115        "Replace private ASNs with our ASN in outbound updates\n")
4116 {
4117         int idx_peer = 2;
4118         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4119                                       bgp_node_afi(vty), bgp_node_safi(vty),
4120                                       PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
4121 }
4122
4123 ALIAS_HIDDEN(no_neighbor_remove_private_as_replace_as,
4124              no_neighbor_remove_private_as_replace_as_hidden_cmd,
4125              "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
4126              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4127              "Remove private ASNs in outbound updates\n"
4128              "Replace private ASNs with our ASN in outbound updates\n")
4129
4130 DEFUN (no_neighbor_remove_private_as_all_replace_as,
4131        no_neighbor_remove_private_as_all_replace_as_cmd,
4132        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4133        NO_STR
4134        NEIGHBOR_STR
4135        NEIGHBOR_ADDR_STR2
4136        "Remove private ASNs in outbound updates\n"
4137        "Apply to all AS numbers\n"
4138        "Replace private ASNs with our ASN in outbound updates\n")
4139 {
4140         int idx_peer = 2;
4141         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4142                                       bgp_node_afi(vty), bgp_node_safi(vty),
4143                                       PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
4144 }
4145
4146 ALIAS_HIDDEN(
4147         no_neighbor_remove_private_as_all_replace_as,
4148         no_neighbor_remove_private_as_all_replace_as_hidden_cmd,
4149         "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
4150         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4151         "Remove private ASNs in outbound updates\n"
4152         "Apply to all AS numbers\n"
4153         "Replace private ASNs with our ASN in outbound updates\n")
4154
4155
4156 /* neighbor send-community. */
4157 DEFUN (neighbor_send_community,
4158        neighbor_send_community_cmd,
4159        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4160        NEIGHBOR_STR
4161        NEIGHBOR_ADDR_STR2
4162        "Send Community attribute to this neighbor\n")
4163 {
4164         int idx_peer = 1;
4165
4166         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4167                                     bgp_node_safi(vty),
4168                                     PEER_FLAG_SEND_COMMUNITY);
4169 }
4170
4171 ALIAS_HIDDEN(neighbor_send_community, neighbor_send_community_hidden_cmd,
4172              "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4173              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4174              "Send Community attribute to this neighbor\n")
4175
4176 DEFUN (no_neighbor_send_community,
4177        no_neighbor_send_community_cmd,
4178        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4179        NO_STR
4180        NEIGHBOR_STR
4181        NEIGHBOR_ADDR_STR2
4182        "Send Community attribute to this neighbor\n")
4183 {
4184         int idx_peer = 2;
4185
4186         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4187                                       bgp_node_afi(vty), bgp_node_safi(vty),
4188                                       PEER_FLAG_SEND_COMMUNITY);
4189 }
4190
4191 ALIAS_HIDDEN(no_neighbor_send_community, no_neighbor_send_community_hidden_cmd,
4192              "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
4193              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4194              "Send Community attribute to this neighbor\n")
4195
4196 /* neighbor send-community extended. */
4197 DEFUN (neighbor_send_community_type,
4198        neighbor_send_community_type_cmd,
4199        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4200        NEIGHBOR_STR
4201        NEIGHBOR_ADDR_STR2
4202        "Send Community attribute to this neighbor\n"
4203        "Send Standard and Extended Community attributes\n"
4204        "Send Standard, Large and Extended Community attributes\n"
4205        "Send Extended Community attributes\n"
4206        "Send Standard Community attributes\n"
4207        "Send Large Community attributes\n")
4208 {
4209         int idx_peer = 1;
4210         uint32_t flag = 0;
4211         const char *type = argv[argc - 1]->text;
4212
4213         if (strmatch(type, "standard")) {
4214                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4215         } else if (strmatch(type, "extended")) {
4216                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4217         } else if (strmatch(type, "large")) {
4218                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4219         } else if (strmatch(type, "both")) {
4220                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4221                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4222         } else { /* if (strmatch(type, "all")) */
4223                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4224                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4225                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4226         }
4227
4228         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4229                                     bgp_node_safi(vty), flag);
4230 }
4231
4232 ALIAS_HIDDEN(
4233         neighbor_send_community_type, neighbor_send_community_type_hidden_cmd,
4234         "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4235         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4236         "Send Community attribute to this neighbor\n"
4237         "Send Standard and Extended Community attributes\n"
4238         "Send Standard, Large and Extended Community attributes\n"
4239         "Send Extended Community attributes\n"
4240         "Send Standard Community attributes\n"
4241         "Send Large Community attributes\n")
4242
4243 DEFUN (no_neighbor_send_community_type,
4244        no_neighbor_send_community_type_cmd,
4245        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4246        NO_STR
4247        NEIGHBOR_STR
4248        NEIGHBOR_ADDR_STR2
4249        "Send Community attribute to this neighbor\n"
4250        "Send Standard and Extended Community attributes\n"
4251        "Send Standard, Large and Extended Community attributes\n"
4252        "Send Extended Community attributes\n"
4253        "Send Standard Community attributes\n"
4254        "Send Large Community attributes\n")
4255 {
4256         int idx_peer = 2;
4257         uint32_t flag = 0;
4258         const char *type = argv[argc - 1]->text;
4259
4260         if (strmatch(type, "standard")) {
4261                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4262         } else if (strmatch(type, "extended")) {
4263                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4264         } else if (strmatch(type, "large")) {
4265                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4266         } else if (strmatch(type, "both")) {
4267                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4268                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4269         } else { /* if (strmatch(type, "all")) */
4270                 SET_FLAG(flag, PEER_FLAG_SEND_COMMUNITY);
4271                 SET_FLAG(flag, PEER_FLAG_SEND_EXT_COMMUNITY);
4272                 SET_FLAG(flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
4273         }
4274
4275         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4276                                       bgp_node_afi(vty), bgp_node_safi(vty),
4277                                       flag);
4278 }
4279
4280 ALIAS_HIDDEN(
4281         no_neighbor_send_community_type,
4282         no_neighbor_send_community_type_hidden_cmd,
4283         "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
4284         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4285         "Send Community attribute to this neighbor\n"
4286         "Send Standard and Extended Community attributes\n"
4287         "Send Standard, Large and Extended Community attributes\n"
4288         "Send Extended Community attributes\n"
4289         "Send Standard Community attributes\n"
4290         "Send Large Community attributes\n")
4291
4292 /* neighbor soft-reconfig. */
4293 DEFUN (neighbor_soft_reconfiguration,
4294        neighbor_soft_reconfiguration_cmd,
4295        "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4296        NEIGHBOR_STR
4297        NEIGHBOR_ADDR_STR2
4298        "Per neighbor soft reconfiguration\n"
4299        "Allow inbound soft reconfiguration for this neighbor\n")
4300 {
4301         int idx_peer = 1;
4302         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4303                                     bgp_node_safi(vty),
4304                                     PEER_FLAG_SOFT_RECONFIG);
4305 }
4306
4307 ALIAS_HIDDEN(neighbor_soft_reconfiguration,
4308              neighbor_soft_reconfiguration_hidden_cmd,
4309              "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4310              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4311              "Per neighbor soft reconfiguration\n"
4312              "Allow inbound soft reconfiguration for this neighbor\n")
4313
4314 DEFUN (no_neighbor_soft_reconfiguration,
4315        no_neighbor_soft_reconfiguration_cmd,
4316        "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4317        NO_STR
4318        NEIGHBOR_STR
4319        NEIGHBOR_ADDR_STR2
4320        "Per neighbor soft reconfiguration\n"
4321        "Allow inbound soft reconfiguration for this neighbor\n")
4322 {
4323         int idx_peer = 2;
4324         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4325                                       bgp_node_afi(vty), bgp_node_safi(vty),
4326                                       PEER_FLAG_SOFT_RECONFIG);
4327 }
4328
4329 ALIAS_HIDDEN(no_neighbor_soft_reconfiguration,
4330              no_neighbor_soft_reconfiguration_hidden_cmd,
4331              "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
4332              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4333              "Per neighbor soft reconfiguration\n"
4334              "Allow inbound soft reconfiguration for this neighbor\n")
4335
4336 DEFUN (neighbor_route_reflector_client,
4337        neighbor_route_reflector_client_cmd,
4338        "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4339        NEIGHBOR_STR
4340        NEIGHBOR_ADDR_STR2
4341        "Configure a neighbor as Route Reflector client\n")
4342 {
4343         int idx_peer = 1;
4344         struct peer *peer;
4345
4346
4347         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4348         if (!peer)
4349                 return CMD_WARNING_CONFIG_FAILED;
4350
4351         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4352                                     bgp_node_safi(vty),
4353                                     PEER_FLAG_REFLECTOR_CLIENT);
4354 }
4355
4356 ALIAS_HIDDEN(neighbor_route_reflector_client,
4357              neighbor_route_reflector_client_hidden_cmd,
4358              "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4359              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4360              "Configure a neighbor as Route Reflector client\n")
4361
4362 DEFUN (no_neighbor_route_reflector_client,
4363        no_neighbor_route_reflector_client_cmd,
4364        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4365        NO_STR
4366        NEIGHBOR_STR
4367        NEIGHBOR_ADDR_STR2
4368        "Configure a neighbor as Route Reflector client\n")
4369 {
4370         int idx_peer = 2;
4371         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4372                                       bgp_node_afi(vty), bgp_node_safi(vty),
4373                                       PEER_FLAG_REFLECTOR_CLIENT);
4374 }
4375
4376 ALIAS_HIDDEN(no_neighbor_route_reflector_client,
4377              no_neighbor_route_reflector_client_hidden_cmd,
4378              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4379              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4380              "Configure a neighbor as Route Reflector client\n")
4381
4382 /* neighbor route-server-client. */
4383 DEFUN (neighbor_route_server_client,
4384        neighbor_route_server_client_cmd,
4385        "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4386        NEIGHBOR_STR
4387        NEIGHBOR_ADDR_STR2
4388        "Configure a neighbor as Route Server client\n")
4389 {
4390         int idx_peer = 1;
4391         struct peer *peer;
4392
4393         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4394         if (!peer)
4395                 return CMD_WARNING_CONFIG_FAILED;
4396         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4397                                     bgp_node_safi(vty),
4398                                     PEER_FLAG_RSERVER_CLIENT);
4399 }
4400
4401 ALIAS_HIDDEN(neighbor_route_server_client,
4402              neighbor_route_server_client_hidden_cmd,
4403              "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4404              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4405              "Configure a neighbor as Route Server client\n")
4406
4407 DEFUN (no_neighbor_route_server_client,
4408        no_neighbor_route_server_client_cmd,
4409        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4410        NO_STR
4411        NEIGHBOR_STR
4412        NEIGHBOR_ADDR_STR2
4413        "Configure a neighbor as Route Server client\n")
4414 {
4415         int idx_peer = 2;
4416         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4417                                       bgp_node_afi(vty), bgp_node_safi(vty),
4418                                       PEER_FLAG_RSERVER_CLIENT);
4419 }
4420
4421 ALIAS_HIDDEN(no_neighbor_route_server_client,
4422              no_neighbor_route_server_client_hidden_cmd,
4423              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4424              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4425              "Configure a neighbor as Route Server client\n")
4426
4427 DEFUN (neighbor_nexthop_local_unchanged,
4428        neighbor_nexthop_local_unchanged_cmd,
4429        "neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4430        NEIGHBOR_STR
4431        NEIGHBOR_ADDR_STR2
4432        "Configure treatment of outgoing link-local nexthop attribute\n"
4433        "Leave link-local nexthop unchanged for this peer\n")
4434 {
4435         int idx_peer = 1;
4436         return peer_af_flag_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
4437                                     bgp_node_safi(vty),
4438                                     PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
4439 }
4440
4441 DEFUN (no_neighbor_nexthop_local_unchanged,
4442        no_neighbor_nexthop_local_unchanged_cmd,
4443        "no neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4444        NO_STR
4445        NEIGHBOR_STR
4446        NEIGHBOR_ADDR_STR2
4447        "Configure treatment of outgoing link-local-nexthop attribute\n"
4448        "Leave link-local nexthop unchanged for this peer\n")
4449 {
4450         int idx_peer = 2;
4451         return peer_af_flag_unset_vty(vty, argv[idx_peer]->arg,
4452                                       bgp_node_afi(vty), bgp_node_safi(vty),
4453                                       PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
4454 }
4455
4456 DEFUN (neighbor_attr_unchanged,
4457        neighbor_attr_unchanged_cmd,
4458        "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4459        NEIGHBOR_STR
4460        NEIGHBOR_ADDR_STR2
4461        "BGP attribute is propagated unchanged to this neighbor\n"
4462        "As-path attribute\n"
4463        "Nexthop attribute\n"
4464        "Med attribute\n")
4465 {
4466         int idx = 0;
4467         char *peer_str = argv[1]->arg;
4468         struct peer *peer;
4469         uint16_t flags = 0;
4470         afi_t afi = bgp_node_afi(vty);
4471         safi_t safi = bgp_node_safi(vty);
4472
4473         peer = peer_and_group_lookup_vty(vty, peer_str);
4474         if (!peer)
4475                 return CMD_WARNING_CONFIG_FAILED;
4476
4477         if (argv_find(argv, argc, "as-path", &idx))
4478                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4479         idx = 0;
4480         if (argv_find(argv, argc, "next-hop", &idx))
4481                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4482         idx = 0;
4483         if (argv_find(argv, argc, "med", &idx))
4484                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4485
4486         /* no flags means all of them! */
4487         if (!flags) {
4488                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4489                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4490                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4491         } else {
4492                 if (!CHECK_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED)
4493                     && peer_af_flag_check(peer, afi, safi,
4494                                           PEER_FLAG_AS_PATH_UNCHANGED)) {
4495                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4496                                                PEER_FLAG_AS_PATH_UNCHANGED);
4497                 }
4498
4499                 if (!CHECK_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED)
4500                     && peer_af_flag_check(peer, afi, safi,
4501                                           PEER_FLAG_NEXTHOP_UNCHANGED)) {
4502                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4503                                                PEER_FLAG_NEXTHOP_UNCHANGED);
4504                 }
4505
4506                 if (!CHECK_FLAG(flags, PEER_FLAG_MED_UNCHANGED)
4507                     && peer_af_flag_check(peer, afi, safi,
4508                                           PEER_FLAG_MED_UNCHANGED)) {
4509                         peer_af_flag_unset_vty(vty, peer_str, afi, safi,
4510                                                PEER_FLAG_MED_UNCHANGED);
4511                 }
4512         }
4513
4514         return peer_af_flag_set_vty(vty, peer_str, afi, safi, flags);
4515 }
4516
4517 ALIAS_HIDDEN(
4518         neighbor_attr_unchanged, neighbor_attr_unchanged_hidden_cmd,
4519         "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4520         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4521         "BGP attribute is propagated unchanged to this neighbor\n"
4522         "As-path attribute\n"
4523         "Nexthop attribute\n"
4524         "Med attribute\n")
4525
4526 DEFUN (no_neighbor_attr_unchanged,
4527        no_neighbor_attr_unchanged_cmd,
4528        "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4529        NO_STR
4530        NEIGHBOR_STR
4531        NEIGHBOR_ADDR_STR2
4532        "BGP attribute is propagated unchanged to this neighbor\n"
4533        "As-path attribute\n"
4534        "Nexthop attribute\n"
4535        "Med attribute\n")
4536 {
4537         int idx = 0;
4538         char *peer = argv[2]->arg;
4539         uint16_t flags = 0;
4540
4541         if (argv_find(argv, argc, "as-path", &idx))
4542                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4543         idx = 0;
4544         if (argv_find(argv, argc, "next-hop", &idx))
4545                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4546         idx = 0;
4547         if (argv_find(argv, argc, "med", &idx))
4548                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4549
4550         if (!flags) // no flags means all of them!
4551         {
4552                 SET_FLAG(flags, PEER_FLAG_AS_PATH_UNCHANGED);
4553                 SET_FLAG(flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4554                 SET_FLAG(flags, PEER_FLAG_MED_UNCHANGED);
4555         }
4556
4557         return peer_af_flag_unset_vty(vty, peer, bgp_node_afi(vty),
4558                                       bgp_node_safi(vty), flags);
4559 }
4560
4561 ALIAS_HIDDEN(
4562         no_neighbor_attr_unchanged, no_neighbor_attr_unchanged_hidden_cmd,
4563         "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged [{as-path|next-hop|med}]",
4564         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4565         "BGP attribute is propagated unchanged to this neighbor\n"
4566         "As-path attribute\n"
4567         "Nexthop attribute\n"
4568         "Med attribute\n")
4569
4570 /* EBGP multihop configuration. */
4571 static int peer_ebgp_multihop_set_vty(struct vty *vty, const char *ip_str,
4572                                       const char *ttl_str)
4573 {
4574         struct peer *peer;
4575         unsigned int ttl;
4576
4577         peer = peer_and_group_lookup_vty(vty, ip_str);
4578         if (!peer)
4579                 return CMD_WARNING_CONFIG_FAILED;
4580
4581         if (peer->conf_if)
4582                 return bgp_vty_return(vty, BGP_ERR_INVALID_FOR_DIRECT_PEER);
4583
4584         if (!ttl_str)
4585                 ttl = MAXTTL;
4586         else
4587                 ttl = strtoul(ttl_str, NULL, 10);
4588
4589         return bgp_vty_return(vty, peer_ebgp_multihop_set(peer, ttl));
4590 }
4591
4592 static int peer_ebgp_multihop_unset_vty(struct vty *vty, const char *ip_str)
4593 {
4594         struct peer *peer;
4595
4596         peer = peer_and_group_lookup_vty(vty, ip_str);
4597         if (!peer)
4598                 return CMD_WARNING_CONFIG_FAILED;
4599
4600         return bgp_vty_return(vty, peer_ebgp_multihop_unset(peer));
4601 }
4602
4603 /* neighbor ebgp-multihop. */
4604 DEFUN (neighbor_ebgp_multihop,
4605        neighbor_ebgp_multihop_cmd,
4606        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop",
4607        NEIGHBOR_STR
4608        NEIGHBOR_ADDR_STR2
4609        "Allow EBGP neighbors not on directly connected networks\n")
4610 {
4611         int idx_peer = 1;
4612         return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg, NULL);
4613 }
4614
4615 DEFUN (neighbor_ebgp_multihop_ttl,
4616        neighbor_ebgp_multihop_ttl_cmd,
4617        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop (1-255)",
4618        NEIGHBOR_STR
4619        NEIGHBOR_ADDR_STR2
4620        "Allow EBGP neighbors not on directly connected networks\n"
4621        "maximum hop count\n")
4622 {
4623         int idx_peer = 1;
4624         int idx_number = 3;
4625         return peer_ebgp_multihop_set_vty(vty, argv[idx_peer]->arg,
4626                                           argv[idx_number]->arg);
4627 }
4628
4629 DEFUN (no_neighbor_ebgp_multihop,
4630        no_neighbor_ebgp_multihop_cmd,
4631        "no neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop [(1-255)]",
4632        NO_STR
4633        NEIGHBOR_STR
4634        NEIGHBOR_ADDR_STR2
4635        "Allow EBGP neighbors not on directly connected networks\n"
4636        "maximum hop count\n")
4637 {
4638         int idx_peer = 2;
4639         return peer_ebgp_multihop_unset_vty(vty, argv[idx_peer]->arg);
4640 }
4641
4642
4643 /* disable-connected-check */
4644 DEFUN (neighbor_disable_connected_check,
4645        neighbor_disable_connected_check_cmd,
4646        "neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4647        NEIGHBOR_STR
4648        NEIGHBOR_ADDR_STR2
4649        "one-hop away EBGP peer using loopback address\n"
4650        "Enforce EBGP neighbors perform multihop\n")
4651 {
4652         int idx_peer = 1;
4653         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
4654                                  PEER_FLAG_DISABLE_CONNECTED_CHECK);
4655 }
4656
4657 DEFUN (no_neighbor_disable_connected_check,
4658        no_neighbor_disable_connected_check_cmd,
4659        "no neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4660        NO_STR
4661        NEIGHBOR_STR
4662        NEIGHBOR_ADDR_STR2
4663        "one-hop away EBGP peer using loopback address\n"
4664        "Enforce EBGP neighbors perform multihop\n")
4665 {
4666         int idx_peer = 2;
4667         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
4668                                    PEER_FLAG_DISABLE_CONNECTED_CHECK);
4669 }
4670
4671
4672 /* enforce-first-as */
4673 DEFUN (neighbor_enforce_first_as,
4674        neighbor_enforce_first_as_cmd,
4675        "neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
4676        NEIGHBOR_STR
4677        NEIGHBOR_ADDR_STR2
4678        "Enforce the first AS for EBGP routes\n")
4679 {
4680         int idx_peer = 1;
4681
4682         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
4683                                  PEER_FLAG_ENFORCE_FIRST_AS);
4684 }
4685
4686 DEFUN (no_neighbor_enforce_first_as,
4687        no_neighbor_enforce_first_as_cmd,
4688        "no neighbor <A.B.C.D|X:X::X:X|WORD> enforce-first-as",
4689        NO_STR
4690        NEIGHBOR_STR
4691        NEIGHBOR_ADDR_STR2
4692        "Enforce the first AS for EBGP routes\n")
4693 {
4694         int idx_peer = 2;
4695
4696         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
4697                                    PEER_FLAG_ENFORCE_FIRST_AS);
4698 }
4699
4700
4701 DEFUN (neighbor_description,
4702        neighbor_description_cmd,
4703        "neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
4704        NEIGHBOR_STR
4705        NEIGHBOR_ADDR_STR2
4706        "Neighbor specific description\n"
4707        "Up to 80 characters describing this neighbor\n")
4708 {
4709         int idx_peer = 1;
4710         int idx_line = 3;
4711         struct peer *peer;
4712         char *str;
4713
4714         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4715         if (!peer)
4716                 return CMD_WARNING_CONFIG_FAILED;
4717
4718         str = argv_concat(argv, argc, idx_line);
4719
4720         peer_description_set(peer, str);
4721
4722         XFREE(MTYPE_TMP, str);
4723
4724         return CMD_SUCCESS;
4725 }
4726
4727 DEFUN (no_neighbor_description,
4728        no_neighbor_description_cmd,
4729        "no neighbor <A.B.C.D|X:X::X:X|WORD> description",
4730        NO_STR
4731        NEIGHBOR_STR
4732        NEIGHBOR_ADDR_STR2
4733        "Neighbor specific description\n")
4734 {
4735         int idx_peer = 2;
4736         struct peer *peer;
4737
4738         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
4739         if (!peer)
4740                 return CMD_WARNING_CONFIG_FAILED;
4741
4742         peer_description_unset(peer);
4743
4744         return CMD_SUCCESS;
4745 }
4746
4747 ALIAS(no_neighbor_description, no_neighbor_description_comment_cmd,
4748       "no neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
4749       NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4750       "Neighbor specific description\n"
4751       "Up to 80 characters describing this neighbor\n")
4752
4753 /* Neighbor update-source. */
4754 static int peer_update_source_vty(struct vty *vty, const char *peer_str,
4755                                   const char *source_str)
4756 {
4757         struct peer *peer;
4758         struct prefix p;
4759         union sockunion su;
4760
4761         peer = peer_and_group_lookup_vty(vty, peer_str);
4762         if (!peer)
4763                 return CMD_WARNING_CONFIG_FAILED;
4764
4765         if (peer->conf_if)
4766                 return CMD_WARNING;
4767
4768         if (source_str) {
4769                 if (str2sockunion(source_str, &su) == 0)
4770                         peer_update_source_addr_set(peer, &su);
4771                 else {
4772                         if (str2prefix(source_str, &p)) {
4773                                 vty_out(vty,
4774                                         "%% Invalid update-source, remove prefix length \n");
4775                                 return CMD_WARNING_CONFIG_FAILED;
4776                         } else
4777                                 peer_update_source_if_set(peer, source_str);
4778                 }
4779         } else
4780                 peer_update_source_unset(peer);
4781
4782         return CMD_SUCCESS;
4783 }
4784
4785 #define BGP_UPDATE_SOURCE_HELP_STR                                             \
4786         "IPv4 address\n"                                                       \
4787         "IPv6 address\n"                                                       \
4788         "Interface name (requires zebra to be running)\n"
4789
4790 DEFUN (neighbor_update_source,
4791        neighbor_update_source_cmd,
4792        "neighbor <A.B.C.D|X:X::X:X|WORD> update-source <A.B.C.D|X:X::X:X|WORD>",
4793        NEIGHBOR_STR
4794        NEIGHBOR_ADDR_STR2
4795        "Source of routing updates\n"
4796        BGP_UPDATE_SOURCE_HELP_STR)
4797 {
4798         int idx_peer = 1;
4799         int idx_peer_2 = 3;
4800         return peer_update_source_vty(vty, argv[idx_peer]->arg,
4801                                       argv[idx_peer_2]->arg);
4802 }
4803
4804 DEFUN (no_neighbor_update_source,
4805        no_neighbor_update_source_cmd,
4806        "no neighbor <A.B.C.D|X:X::X:X|WORD> update-source [<A.B.C.D|X:X::X:X|WORD>]",
4807        NO_STR
4808        NEIGHBOR_STR
4809        NEIGHBOR_ADDR_STR2
4810        "Source of routing updates\n"
4811        BGP_UPDATE_SOURCE_HELP_STR)
4812 {
4813         int idx_peer = 2;
4814         return peer_update_source_vty(vty, argv[idx_peer]->arg, NULL);
4815 }
4816
4817 static int peer_default_originate_set_vty(struct vty *vty, const char *peer_str,
4818                                           afi_t afi, safi_t safi,
4819                                           const char *rmap, int set)
4820 {
4821         int ret;
4822         struct peer *peer;
4823         struct route_map *route_map = NULL;
4824
4825         peer = peer_and_group_lookup_vty(vty, peer_str);
4826         if (!peer)
4827                 return CMD_WARNING_CONFIG_FAILED;
4828
4829         if (set) {
4830                 if (rmap)
4831                         route_map = route_map_lookup_warn_noexist(vty, rmap);
4832                 ret = peer_default_originate_set(peer, afi, safi,
4833                                                  rmap, route_map);
4834         } else
4835                 ret = peer_default_originate_unset(peer, afi, safi);
4836
4837         return bgp_vty_return(vty, ret);
4838 }
4839
4840 /* neighbor default-originate. */
4841 DEFUN (neighbor_default_originate,
4842        neighbor_default_originate_cmd,
4843        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
4844        NEIGHBOR_STR
4845        NEIGHBOR_ADDR_STR2
4846        "Originate default route to this neighbor\n")
4847 {
4848         int idx_peer = 1;
4849         return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
4850                                               bgp_node_afi(vty),
4851                                               bgp_node_safi(vty), NULL, 1);
4852 }
4853
4854 ALIAS_HIDDEN(neighbor_default_originate, neighbor_default_originate_hidden_cmd,
4855              "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
4856              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4857              "Originate default route to this neighbor\n")
4858
4859 DEFUN (neighbor_default_originate_rmap,
4860        neighbor_default_originate_rmap_cmd,
4861        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map WORD",
4862        NEIGHBOR_STR
4863        NEIGHBOR_ADDR_STR2
4864        "Originate default route to this neighbor\n"
4865        "Route-map to specify criteria to originate default\n"
4866        "route-map name\n")
4867 {
4868         int idx_peer = 1;
4869         int idx_word = 4;
4870         return peer_default_originate_set_vty(
4871                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
4872                 argv[idx_word]->arg, 1);
4873 }
4874
4875 ALIAS_HIDDEN(
4876         neighbor_default_originate_rmap,
4877         neighbor_default_originate_rmap_hidden_cmd,
4878         "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map WORD",
4879         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4880         "Originate default route to this neighbor\n"
4881         "Route-map to specify criteria to originate default\n"
4882         "route-map name\n")
4883
4884 DEFUN (no_neighbor_default_originate,
4885        no_neighbor_default_originate_cmd,
4886        "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map WORD]",
4887        NO_STR
4888        NEIGHBOR_STR
4889        NEIGHBOR_ADDR_STR2
4890        "Originate default route to this neighbor\n"
4891        "Route-map to specify criteria to originate default\n"
4892        "route-map name\n")
4893 {
4894         int idx_peer = 2;
4895         return peer_default_originate_set_vty(vty, argv[idx_peer]->arg,
4896                                               bgp_node_afi(vty),
4897                                               bgp_node_safi(vty), NULL, 0);
4898 }
4899
4900 ALIAS_HIDDEN(
4901         no_neighbor_default_originate, no_neighbor_default_originate_hidden_cmd,
4902         "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map WORD]",
4903         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
4904         "Originate default route to this neighbor\n"
4905         "Route-map to specify criteria to originate default\n"
4906         "route-map name\n")
4907
4908
4909 /* Set neighbor's BGP port.  */
4910 static int peer_port_vty(struct vty *vty, const char *ip_str, int afi,
4911                          const char *port_str)
4912 {
4913         struct peer *peer;
4914         uint16_t port;
4915         struct servent *sp;
4916
4917         peer = peer_lookup_vty(vty, ip_str);
4918         if (!peer)
4919                 return CMD_WARNING_CONFIG_FAILED;
4920
4921         if (!port_str) {
4922                 sp = getservbyname("bgp", "tcp");
4923                 port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs(sp->s_port);
4924         } else {
4925                 port = strtoul(port_str, NULL, 10);
4926         }
4927
4928         peer_port_set(peer, port);
4929
4930         return CMD_SUCCESS;
4931 }
4932
4933 /* Set specified peer's BGP port.  */
4934 DEFUN (neighbor_port,
4935        neighbor_port_cmd,
4936        "neighbor <A.B.C.D|X:X::X:X> port (0-65535)",
4937        NEIGHBOR_STR
4938        NEIGHBOR_ADDR_STR
4939        "Neighbor's BGP port\n"
4940        "TCP port number\n")
4941 {
4942         int idx_ip = 1;
4943         int idx_number = 3;
4944         return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP,
4945                              argv[idx_number]->arg);
4946 }
4947
4948 DEFUN (no_neighbor_port,
4949        no_neighbor_port_cmd,
4950        "no neighbor <A.B.C.D|X:X::X:X> port [(0-65535)]",
4951        NO_STR
4952        NEIGHBOR_STR
4953        NEIGHBOR_ADDR_STR
4954        "Neighbor's BGP port\n"
4955        "TCP port number\n")
4956 {
4957         int idx_ip = 2;
4958         return peer_port_vty(vty, argv[idx_ip]->arg, AFI_IP, NULL);
4959 }
4960
4961
4962 /* neighbor weight. */
4963 static int peer_weight_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
4964                                safi_t safi, const char *weight_str)
4965 {
4966         int ret;
4967         struct peer *peer;
4968         unsigned long weight;
4969
4970         peer = peer_and_group_lookup_vty(vty, ip_str);
4971         if (!peer)
4972                 return CMD_WARNING_CONFIG_FAILED;
4973
4974         weight = strtoul(weight_str, NULL, 10);
4975
4976         ret = peer_weight_set(peer, afi, safi, weight);
4977         return bgp_vty_return(vty, ret);
4978 }
4979
4980 static int peer_weight_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
4981                                  safi_t safi)
4982 {
4983         int ret;
4984         struct peer *peer;
4985
4986         peer = peer_and_group_lookup_vty(vty, ip_str);
4987         if (!peer)
4988                 return CMD_WARNING_CONFIG_FAILED;
4989
4990         ret = peer_weight_unset(peer, afi, safi);
4991         return bgp_vty_return(vty, ret);
4992 }
4993
4994 DEFUN (neighbor_weight,
4995        neighbor_weight_cmd,
4996        "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
4997        NEIGHBOR_STR
4998        NEIGHBOR_ADDR_STR2
4999        "Set default weight for routes from this neighbor\n"
5000        "default weight\n")
5001 {
5002         int idx_peer = 1;
5003         int idx_number = 3;
5004         return peer_weight_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5005                                    bgp_node_safi(vty), argv[idx_number]->arg);
5006 }
5007
5008 ALIAS_HIDDEN(neighbor_weight, neighbor_weight_hidden_cmd,
5009              "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
5010              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5011              "Set default weight for routes from this neighbor\n"
5012              "default weight\n")
5013
5014 DEFUN (no_neighbor_weight,
5015        no_neighbor_weight_cmd,
5016        "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
5017        NO_STR
5018        NEIGHBOR_STR
5019        NEIGHBOR_ADDR_STR2
5020        "Set default weight for routes from this neighbor\n"
5021        "default weight\n")
5022 {
5023         int idx_peer = 2;
5024         return peer_weight_unset_vty(vty, argv[idx_peer]->arg,
5025                                      bgp_node_afi(vty), bgp_node_safi(vty));
5026 }
5027
5028 ALIAS_HIDDEN(no_neighbor_weight, no_neighbor_weight_hidden_cmd,
5029              "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
5030              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5031              "Set default weight for routes from this neighbor\n"
5032              "default weight\n")
5033
5034
5035 /* Override capability negotiation. */
5036 DEFUN (neighbor_override_capability,
5037        neighbor_override_capability_cmd,
5038        "neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
5039        NEIGHBOR_STR
5040        NEIGHBOR_ADDR_STR2
5041        "Override capability negotiation result\n")
5042 {
5043         int idx_peer = 1;
5044         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5045                                  PEER_FLAG_OVERRIDE_CAPABILITY);
5046 }
5047
5048 DEFUN (no_neighbor_override_capability,
5049        no_neighbor_override_capability_cmd,
5050        "no neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
5051        NO_STR
5052        NEIGHBOR_STR
5053        NEIGHBOR_ADDR_STR2
5054        "Override capability negotiation result\n")
5055 {
5056         int idx_peer = 2;
5057         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5058                                    PEER_FLAG_OVERRIDE_CAPABILITY);
5059 }
5060
5061 DEFUN (neighbor_strict_capability,
5062        neighbor_strict_capability_cmd,
5063        "neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
5064        NEIGHBOR_STR
5065        NEIGHBOR_ADDR_STR2
5066        "Strict capability negotiation match\n")
5067 {
5068         int idx_peer = 1;
5069
5070         return peer_flag_set_vty(vty, argv[idx_peer]->arg,
5071                                  PEER_FLAG_STRICT_CAP_MATCH);
5072 }
5073
5074 DEFUN (no_neighbor_strict_capability,
5075        no_neighbor_strict_capability_cmd,
5076        "no neighbor <A.B.C.D|X:X::X:X|WORD> strict-capability-match",
5077        NO_STR
5078        NEIGHBOR_STR
5079        NEIGHBOR_ADDR_STR2
5080        "Strict capability negotiation match\n")
5081 {
5082         int idx_peer = 2;
5083
5084         return peer_flag_unset_vty(vty, argv[idx_peer]->arg,
5085                                    PEER_FLAG_STRICT_CAP_MATCH);
5086 }
5087
5088 static int peer_timers_set_vty(struct vty *vty, const char *ip_str,
5089                                const char *keep_str, const char *hold_str)
5090 {
5091         int ret;
5092         struct peer *peer;
5093         uint32_t keepalive;
5094         uint32_t holdtime;
5095
5096         peer = peer_and_group_lookup_vty(vty, ip_str);
5097         if (!peer)
5098                 return CMD_WARNING_CONFIG_FAILED;
5099
5100         keepalive = strtoul(keep_str, NULL, 10);
5101         holdtime = strtoul(hold_str, NULL, 10);
5102
5103         ret = peer_timers_set(peer, keepalive, holdtime);
5104
5105         return bgp_vty_return(vty, ret);
5106 }
5107
5108 static int peer_timers_unset_vty(struct vty *vty, const char *ip_str)
5109 {
5110         int ret;
5111         struct peer *peer;
5112
5113         peer = peer_and_group_lookup_vty(vty, ip_str);
5114         if (!peer)
5115                 return CMD_WARNING_CONFIG_FAILED;
5116
5117         ret = peer_timers_unset(peer);
5118
5119         return bgp_vty_return(vty, ret);
5120 }
5121
5122 DEFUN (neighbor_timers,
5123        neighbor_timers_cmd,
5124        "neighbor <A.B.C.D|X:X::X:X|WORD> timers (0-65535) (0-65535)",
5125        NEIGHBOR_STR
5126        NEIGHBOR_ADDR_STR2
5127        "BGP per neighbor timers\n"
5128        "Keepalive interval\n"
5129        "Holdtime\n")
5130 {
5131         int idx_peer = 1;
5132         int idx_number = 3;
5133         int idx_number_2 = 4;
5134         return peer_timers_set_vty(vty, argv[idx_peer]->arg,
5135                                    argv[idx_number]->arg,
5136                                    argv[idx_number_2]->arg);
5137 }
5138
5139 DEFUN (no_neighbor_timers,
5140        no_neighbor_timers_cmd,
5141        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers [(0-65535) (0-65535)]",
5142        NO_STR
5143        NEIGHBOR_STR
5144        NEIGHBOR_ADDR_STR2
5145        "BGP per neighbor timers\n"
5146        "Keepalive interval\n"
5147        "Holdtime\n")
5148 {
5149         int idx_peer = 2;
5150         return peer_timers_unset_vty(vty, argv[idx_peer]->arg);
5151 }
5152
5153
5154 static int peer_timers_connect_set_vty(struct vty *vty, const char *ip_str,
5155                                        const char *time_str)
5156 {
5157         int ret;
5158         struct peer *peer;
5159         uint32_t connect;
5160
5161         peer = peer_and_group_lookup_vty(vty, ip_str);
5162         if (!peer)
5163                 return CMD_WARNING_CONFIG_FAILED;
5164
5165         connect = strtoul(time_str, NULL, 10);
5166
5167         ret = peer_timers_connect_set(peer, connect);
5168
5169         return bgp_vty_return(vty, ret);
5170 }
5171
5172 static int peer_timers_connect_unset_vty(struct vty *vty, const char *ip_str)
5173 {
5174         int ret;
5175         struct peer *peer;
5176
5177         peer = peer_and_group_lookup_vty(vty, ip_str);
5178         if (!peer)
5179                 return CMD_WARNING_CONFIG_FAILED;
5180
5181         ret = peer_timers_connect_unset(peer);
5182
5183         return bgp_vty_return(vty, ret);
5184 }
5185
5186 DEFUN (neighbor_timers_connect,
5187        neighbor_timers_connect_cmd,
5188        "neighbor <A.B.C.D|X:X::X:X|WORD> timers connect (1-65535)",
5189        NEIGHBOR_STR
5190        NEIGHBOR_ADDR_STR2
5191        "BGP per neighbor timers\n"
5192        "BGP connect timer\n"
5193        "Connect timer\n")
5194 {
5195         int idx_peer = 1;
5196         int idx_number = 4;
5197         return peer_timers_connect_set_vty(vty, argv[idx_peer]->arg,
5198                                            argv[idx_number]->arg);
5199 }
5200
5201 DEFUN (no_neighbor_timers_connect,
5202        no_neighbor_timers_connect_cmd,
5203        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers connect [(1-65535)]",
5204        NO_STR
5205        NEIGHBOR_STR
5206        NEIGHBOR_ADDR_STR2
5207        "BGP per neighbor timers\n"
5208        "BGP connect timer\n"
5209        "Connect timer\n")
5210 {
5211         int idx_peer = 2;
5212         return peer_timers_connect_unset_vty(vty, argv[idx_peer]->arg);
5213 }
5214
5215
5216 static int peer_advertise_interval_vty(struct vty *vty, const char *ip_str,
5217                                        const char *time_str, int set)
5218 {
5219         int ret;
5220         struct peer *peer;
5221         uint32_t routeadv = 0;
5222
5223         peer = peer_and_group_lookup_vty(vty, ip_str);
5224         if (!peer)
5225                 return CMD_WARNING_CONFIG_FAILED;
5226
5227         if (time_str)
5228                 routeadv = strtoul(time_str, NULL, 10);
5229
5230         if (set)
5231                 ret = peer_advertise_interval_set(peer, routeadv);
5232         else
5233                 ret = peer_advertise_interval_unset(peer);
5234
5235         return bgp_vty_return(vty, ret);
5236 }
5237
5238 DEFUN (neighbor_advertise_interval,
5239        neighbor_advertise_interval_cmd,
5240        "neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval (0-600)",
5241        NEIGHBOR_STR
5242        NEIGHBOR_ADDR_STR2
5243        "Minimum interval between sending BGP routing updates\n"
5244        "time in seconds\n")
5245 {
5246         int idx_peer = 1;
5247         int idx_number = 3;
5248         return peer_advertise_interval_vty(vty, argv[idx_peer]->arg,
5249                                            argv[idx_number]->arg, 1);
5250 }
5251
5252 DEFUN (no_neighbor_advertise_interval,
5253        no_neighbor_advertise_interval_cmd,
5254        "no neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval [(0-600)]",
5255        NO_STR
5256        NEIGHBOR_STR
5257        NEIGHBOR_ADDR_STR2
5258        "Minimum interval between sending BGP routing updates\n"
5259        "time in seconds\n")
5260 {
5261         int idx_peer = 2;
5262         return peer_advertise_interval_vty(vty, argv[idx_peer]->arg, NULL, 0);
5263 }
5264
5265
5266 /* Time to wait before processing route-map updates */
5267 DEFUN (bgp_set_route_map_delay_timer,
5268        bgp_set_route_map_delay_timer_cmd,
5269        "bgp route-map delay-timer (0-600)",
5270        SET_STR
5271        "BGP route-map delay timer\n"
5272        "Time in secs to wait before processing route-map changes\n"
5273        "0 disables the timer, no route updates happen when route-maps change\n")
5274 {
5275         int idx_number = 3;
5276         uint32_t rmap_delay_timer;
5277
5278         if (argv[idx_number]->arg) {
5279                 rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
5280                 bm->rmap_update_timer = rmap_delay_timer;
5281
5282                 /* if the dynamic update handling is being disabled, and a timer
5283                  * is
5284                  * running, stop the timer and act as if the timer has already
5285                  * fired.
5286                  */
5287                 if (!rmap_delay_timer && bm->t_rmap_update) {
5288                         BGP_TIMER_OFF(bm->t_rmap_update);
5289                         thread_execute(bm->master, bgp_route_map_update_timer,
5290                                        NULL, 0);
5291                 }
5292                 return CMD_SUCCESS;
5293         } else {
5294                 vty_out(vty, "%% BGP invalid route-map delay-timer\n");
5295                 return CMD_WARNING_CONFIG_FAILED;
5296         }
5297 }
5298
5299 DEFUN (no_bgp_set_route_map_delay_timer,
5300        no_bgp_set_route_map_delay_timer_cmd,
5301        "no bgp route-map delay-timer [(0-600)]",
5302        NO_STR
5303        BGP_STR
5304        "Default BGP route-map delay timer\n"
5305        "Reset to default time to wait for processing route-map changes\n"
5306        "0 disables the timer, no route updates happen when route-maps change\n")
5307 {
5308
5309         bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
5310
5311         return CMD_SUCCESS;
5312 }
5313
5314
5315 /* neighbor interface */
5316 static int peer_interface_vty(struct vty *vty, const char *ip_str,
5317                               const char *str)
5318 {
5319         struct peer *peer;
5320
5321         peer = peer_lookup_vty(vty, ip_str);
5322         if (!peer || peer->conf_if) {
5323                 vty_out(vty, "%% BGP invalid peer %s\n", ip_str);
5324                 return CMD_WARNING_CONFIG_FAILED;
5325         }
5326
5327         if (str)
5328                 peer_interface_set(peer, str);
5329         else
5330                 peer_interface_unset(peer);
5331
5332         return CMD_SUCCESS;
5333 }
5334
5335 DEFUN (neighbor_interface,
5336        neighbor_interface_cmd,
5337        "neighbor <A.B.C.D|X:X::X:X> interface WORD",
5338        NEIGHBOR_STR
5339        NEIGHBOR_ADDR_STR
5340        "Interface\n"
5341        "Interface name\n")
5342 {
5343         int idx_ip = 1;
5344         int idx_word = 3;
5345         return peer_interface_vty(vty, argv[idx_ip]->arg, argv[idx_word]->arg);
5346 }
5347
5348 DEFUN (no_neighbor_interface,
5349        no_neighbor_interface_cmd,
5350        "no neighbor <A.B.C.D|X:X::X:X|WORD> interface WORD",
5351        NO_STR
5352        NEIGHBOR_STR
5353        NEIGHBOR_ADDR_STR2
5354        "Interface\n"
5355        "Interface name\n")
5356 {
5357         int idx_peer = 2;
5358         return peer_interface_vty(vty, argv[idx_peer]->arg, NULL);
5359 }
5360
5361 DEFUN (neighbor_distribute_list,
5362        neighbor_distribute_list_cmd,
5363        "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5364        NEIGHBOR_STR
5365        NEIGHBOR_ADDR_STR2
5366        "Filter updates to/from this neighbor\n"
5367        "IP access-list number\n"
5368        "IP access-list number (expanded range)\n"
5369        "IP Access-list name\n"
5370        "Filter incoming updates\n"
5371        "Filter outgoing updates\n")
5372 {
5373         int idx_peer = 1;
5374         int idx_acl = 3;
5375         int direct, ret;
5376         struct peer *peer;
5377
5378         const char *pstr = argv[idx_peer]->arg;
5379         const char *acl = argv[idx_acl]->arg;
5380         const char *inout = argv[argc - 1]->text;
5381
5382         peer = peer_and_group_lookup_vty(vty, pstr);
5383         if (!peer)
5384                 return CMD_WARNING_CONFIG_FAILED;
5385
5386         /* Check filter direction. */
5387         direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
5388         ret = peer_distribute_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
5389                                   direct, acl);
5390
5391         return bgp_vty_return(vty, ret);
5392 }
5393
5394 ALIAS_HIDDEN(
5395         neighbor_distribute_list, neighbor_distribute_list_hidden_cmd,
5396         "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5397         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5398         "Filter updates to/from this neighbor\n"
5399         "IP access-list number\n"
5400         "IP access-list number (expanded range)\n"
5401         "IP Access-list name\n"
5402         "Filter incoming updates\n"
5403         "Filter outgoing updates\n")
5404
5405 DEFUN (no_neighbor_distribute_list,
5406        no_neighbor_distribute_list_cmd,
5407        "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5408        NO_STR
5409        NEIGHBOR_STR
5410        NEIGHBOR_ADDR_STR2
5411        "Filter updates to/from this neighbor\n"
5412        "IP access-list number\n"
5413        "IP access-list number (expanded range)\n"
5414        "IP Access-list name\n"
5415        "Filter incoming updates\n"
5416        "Filter outgoing updates\n")
5417 {
5418         int idx_peer = 2;
5419         int direct, ret;
5420         struct peer *peer;
5421
5422         const char *pstr = argv[idx_peer]->arg;
5423         const char *inout = argv[argc - 1]->text;
5424
5425         peer = peer_and_group_lookup_vty(vty, pstr);
5426         if (!peer)
5427                 return CMD_WARNING_CONFIG_FAILED;
5428
5429         /* Check filter direction. */
5430         direct = strmatch(inout, "in") ? FILTER_IN : FILTER_OUT;
5431         ret = peer_distribute_unset(peer, bgp_node_afi(vty), bgp_node_safi(vty),
5432                                     direct);
5433
5434         return bgp_vty_return(vty, ret);
5435 }
5436
5437 ALIAS_HIDDEN(
5438         no_neighbor_distribute_list, no_neighbor_distribute_list_hidden_cmd,
5439         "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
5440         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5441         "Filter updates to/from this neighbor\n"
5442         "IP access-list number\n"
5443         "IP access-list number (expanded range)\n"
5444         "IP Access-list name\n"
5445         "Filter incoming updates\n"
5446         "Filter outgoing updates\n")
5447
5448 /* Set prefix list to the peer. */
5449 static int peer_prefix_list_set_vty(struct vty *vty, const char *ip_str,
5450                                     afi_t afi, safi_t safi,
5451                                     const char *name_str,
5452                                     const char *direct_str)
5453 {
5454         int ret;
5455         int direct = FILTER_IN;
5456         struct peer *peer;
5457
5458         peer = peer_and_group_lookup_vty(vty, ip_str);
5459         if (!peer)
5460                 return CMD_WARNING_CONFIG_FAILED;
5461
5462         /* Check filter direction. */
5463         if (strncmp(direct_str, "i", 1) == 0)
5464                 direct = FILTER_IN;
5465         else if (strncmp(direct_str, "o", 1) == 0)
5466                 direct = FILTER_OUT;
5467
5468         ret = peer_prefix_list_set(peer, afi, safi, direct, name_str);
5469
5470         return bgp_vty_return(vty, ret);
5471 }
5472
5473 static int peer_prefix_list_unset_vty(struct vty *vty, const char *ip_str,
5474                                       afi_t afi, safi_t safi,
5475                                       const char *direct_str)
5476 {
5477         int ret;
5478         struct peer *peer;
5479         int direct = FILTER_IN;
5480
5481         peer = peer_and_group_lookup_vty(vty, ip_str);
5482         if (!peer)
5483                 return CMD_WARNING_CONFIG_FAILED;
5484
5485         /* Check filter direction. */
5486         if (strncmp(direct_str, "i", 1) == 0)
5487                 direct = FILTER_IN;
5488         else if (strncmp(direct_str, "o", 1) == 0)
5489                 direct = FILTER_OUT;
5490
5491         ret = peer_prefix_list_unset(peer, afi, safi, direct);
5492
5493         return bgp_vty_return(vty, ret);
5494 }
5495
5496 DEFUN (neighbor_prefix_list,
5497        neighbor_prefix_list_cmd,
5498        "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5499        NEIGHBOR_STR
5500        NEIGHBOR_ADDR_STR2
5501        "Filter updates to/from this neighbor\n"
5502        "Name of a prefix list\n"
5503        "Filter incoming updates\n"
5504        "Filter outgoing updates\n")
5505 {
5506         int idx_peer = 1;
5507         int idx_word = 3;
5508         int idx_in_out = 4;
5509         return peer_prefix_list_set_vty(
5510                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5511                 argv[idx_word]->arg, argv[idx_in_out]->arg);
5512 }
5513
5514 ALIAS_HIDDEN(neighbor_prefix_list, neighbor_prefix_list_hidden_cmd,
5515              "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5516              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5517              "Filter updates to/from this neighbor\n"
5518              "Name of a prefix list\n"
5519              "Filter incoming updates\n"
5520              "Filter outgoing updates\n")
5521
5522 DEFUN (no_neighbor_prefix_list,
5523        no_neighbor_prefix_list_cmd,
5524        "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5525        NO_STR
5526        NEIGHBOR_STR
5527        NEIGHBOR_ADDR_STR2
5528        "Filter updates to/from this neighbor\n"
5529        "Name of a prefix list\n"
5530        "Filter incoming updates\n"
5531        "Filter outgoing updates\n")
5532 {
5533         int idx_peer = 2;
5534         int idx_in_out = 5;
5535         return peer_prefix_list_unset_vty(vty, argv[idx_peer]->arg,
5536                                           bgp_node_afi(vty), bgp_node_safi(vty),
5537                                           argv[idx_in_out]->arg);
5538 }
5539
5540 ALIAS_HIDDEN(no_neighbor_prefix_list, no_neighbor_prefix_list_hidden_cmd,
5541              "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5542              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5543              "Filter updates to/from this neighbor\n"
5544              "Name of a prefix list\n"
5545              "Filter incoming updates\n"
5546              "Filter outgoing updates\n")
5547
5548 static int peer_aslist_set_vty(struct vty *vty, const char *ip_str, afi_t afi,
5549                                safi_t safi, const char *name_str,
5550                                const char *direct_str)
5551 {
5552         int ret;
5553         struct peer *peer;
5554         int direct = FILTER_IN;
5555
5556         peer = peer_and_group_lookup_vty(vty, ip_str);
5557         if (!peer)
5558                 return CMD_WARNING_CONFIG_FAILED;
5559
5560         /* Check filter direction. */
5561         if (strncmp(direct_str, "i", 1) == 0)
5562                 direct = FILTER_IN;
5563         else if (strncmp(direct_str, "o", 1) == 0)
5564                 direct = FILTER_OUT;
5565
5566         ret = peer_aslist_set(peer, afi, safi, direct, name_str);
5567
5568         return bgp_vty_return(vty, ret);
5569 }
5570
5571 static int peer_aslist_unset_vty(struct vty *vty, const char *ip_str, afi_t afi,
5572                                  safi_t safi, const char *direct_str)
5573 {
5574         int ret;
5575         struct peer *peer;
5576         int direct = FILTER_IN;
5577
5578         peer = peer_and_group_lookup_vty(vty, ip_str);
5579         if (!peer)
5580                 return CMD_WARNING_CONFIG_FAILED;
5581
5582         /* Check filter direction. */
5583         if (strncmp(direct_str, "i", 1) == 0)
5584                 direct = FILTER_IN;
5585         else if (strncmp(direct_str, "o", 1) == 0)
5586                 direct = FILTER_OUT;
5587
5588         ret = peer_aslist_unset(peer, afi, safi, direct);
5589
5590         return bgp_vty_return(vty, ret);
5591 }
5592
5593 DEFUN (neighbor_filter_list,
5594        neighbor_filter_list_cmd,
5595        "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5596        NEIGHBOR_STR
5597        NEIGHBOR_ADDR_STR2
5598        "Establish BGP filters\n"
5599        "AS path access-list name\n"
5600        "Filter incoming routes\n"
5601        "Filter outgoing routes\n")
5602 {
5603         int idx_peer = 1;
5604         int idx_word = 3;
5605         int idx_in_out = 4;
5606         return peer_aslist_set_vty(vty, argv[idx_peer]->arg, bgp_node_afi(vty),
5607                                    bgp_node_safi(vty), argv[idx_word]->arg,
5608                                    argv[idx_in_out]->arg);
5609 }
5610
5611 ALIAS_HIDDEN(neighbor_filter_list, neighbor_filter_list_hidden_cmd,
5612              "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5613              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5614              "Establish BGP filters\n"
5615              "AS path access-list name\n"
5616              "Filter incoming routes\n"
5617              "Filter outgoing routes\n")
5618
5619 DEFUN (no_neighbor_filter_list,
5620        no_neighbor_filter_list_cmd,
5621        "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5622        NO_STR
5623        NEIGHBOR_STR
5624        NEIGHBOR_ADDR_STR2
5625        "Establish BGP filters\n"
5626        "AS path access-list name\n"
5627        "Filter incoming routes\n"
5628        "Filter outgoing routes\n")
5629 {
5630         int idx_peer = 2;
5631         int idx_in_out = 5;
5632         return peer_aslist_unset_vty(vty, argv[idx_peer]->arg,
5633                                      bgp_node_afi(vty), bgp_node_safi(vty),
5634                                      argv[idx_in_out]->arg);
5635 }
5636
5637 ALIAS_HIDDEN(no_neighbor_filter_list, no_neighbor_filter_list_hidden_cmd,
5638              "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5639              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5640              "Establish BGP filters\n"
5641              "AS path access-list name\n"
5642              "Filter incoming routes\n"
5643              "Filter outgoing routes\n")
5644
5645 /* Set route-map to the peer. */
5646 static int peer_route_map_set_vty(struct vty *vty, const char *ip_str,
5647                                   afi_t afi, safi_t safi, const char *name_str,
5648                                   const char *direct_str)
5649 {
5650         int ret;
5651         struct peer *peer;
5652         int direct = RMAP_IN;
5653         struct route_map *route_map;
5654
5655         peer = peer_and_group_lookup_vty(vty, ip_str);
5656         if (!peer)
5657                 return CMD_WARNING_CONFIG_FAILED;
5658
5659         /* Check filter direction. */
5660         if (strncmp(direct_str, "in", 2) == 0)
5661                 direct = RMAP_IN;
5662         else if (strncmp(direct_str, "o", 1) == 0)
5663                 direct = RMAP_OUT;
5664
5665         route_map = route_map_lookup_warn_noexist(vty, name_str);
5666         ret = peer_route_map_set(peer, afi, safi, direct, name_str, route_map);
5667
5668         return bgp_vty_return(vty, ret);
5669 }
5670
5671 static int peer_route_map_unset_vty(struct vty *vty, const char *ip_str,
5672                                     afi_t afi, safi_t safi,
5673                                     const char *direct_str)
5674 {
5675         int ret;
5676         struct peer *peer;
5677         int direct = RMAP_IN;
5678
5679         peer = peer_and_group_lookup_vty(vty, ip_str);
5680         if (!peer)
5681                 return CMD_WARNING_CONFIG_FAILED;
5682
5683         /* Check filter direction. */
5684         if (strncmp(direct_str, "in", 2) == 0)
5685                 direct = RMAP_IN;
5686         else if (strncmp(direct_str, "o", 1) == 0)
5687                 direct = RMAP_OUT;
5688
5689         ret = peer_route_map_unset(peer, afi, safi, direct);
5690
5691         return bgp_vty_return(vty, ret);
5692 }
5693
5694 DEFUN (neighbor_route_map,
5695        neighbor_route_map_cmd,
5696        "neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5697        NEIGHBOR_STR
5698        NEIGHBOR_ADDR_STR2
5699        "Apply route map to neighbor\n"
5700        "Name of route map\n"
5701        "Apply map to incoming routes\n"
5702        "Apply map to outbound routes\n")
5703 {
5704         int idx_peer = 1;
5705         int idx_word = 3;
5706         int idx_in_out = 4;
5707         return peer_route_map_set_vty(
5708                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5709                 argv[idx_word]->arg, argv[idx_in_out]->arg);
5710 }
5711
5712 ALIAS_HIDDEN(neighbor_route_map, neighbor_route_map_hidden_cmd,
5713              "neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5714              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5715              "Apply route map to neighbor\n"
5716              "Name of route map\n"
5717              "Apply map to incoming routes\n"
5718              "Apply map to outbound routes\n")
5719
5720 DEFUN (no_neighbor_route_map,
5721        no_neighbor_route_map_cmd,
5722        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5723        NO_STR
5724        NEIGHBOR_STR
5725        NEIGHBOR_ADDR_STR2
5726        "Apply route map to neighbor\n"
5727        "Name of route map\n"
5728        "Apply map to incoming routes\n"
5729        "Apply map to outbound routes\n")
5730 {
5731         int idx_peer = 2;
5732         int idx_in_out = 5;
5733         return peer_route_map_unset_vty(vty, argv[idx_peer]->arg,
5734                                         bgp_node_afi(vty), bgp_node_safi(vty),
5735                                         argv[idx_in_out]->arg);
5736 }
5737
5738 ALIAS_HIDDEN(no_neighbor_route_map, no_neighbor_route_map_hidden_cmd,
5739              "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5740              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5741              "Apply route map to neighbor\n"
5742              "Name of route map\n"
5743              "Apply map to incoming routes\n"
5744              "Apply map to outbound routes\n")
5745
5746 /* Set unsuppress-map to the peer. */
5747 static int peer_unsuppress_map_set_vty(struct vty *vty, const char *ip_str,
5748                                        afi_t afi, safi_t safi,
5749                                        const char *name_str)
5750 {
5751         int ret;
5752         struct peer *peer;
5753         struct route_map *route_map;
5754
5755         peer = peer_and_group_lookup_vty(vty, ip_str);
5756         if (!peer)
5757                 return CMD_WARNING_CONFIG_FAILED;
5758
5759         route_map = route_map_lookup_warn_noexist(vty, name_str);
5760         ret = peer_unsuppress_map_set(peer, afi, safi, name_str, route_map);
5761
5762         return bgp_vty_return(vty, ret);
5763 }
5764
5765 /* Unset route-map from the peer. */
5766 static int peer_unsuppress_map_unset_vty(struct vty *vty, const char *ip_str,
5767                                          afi_t afi, safi_t safi)
5768 {
5769         int ret;
5770         struct peer *peer;
5771
5772         peer = peer_and_group_lookup_vty(vty, ip_str);
5773         if (!peer)
5774                 return CMD_WARNING_CONFIG_FAILED;
5775
5776         ret = peer_unsuppress_map_unset(peer, afi, safi);
5777
5778         return bgp_vty_return(vty, ret);
5779 }
5780
5781 DEFUN (neighbor_unsuppress_map,
5782        neighbor_unsuppress_map_cmd,
5783        "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5784        NEIGHBOR_STR
5785        NEIGHBOR_ADDR_STR2
5786        "Route-map to selectively unsuppress suppressed routes\n"
5787        "Name of route map\n")
5788 {
5789         int idx_peer = 1;
5790         int idx_word = 3;
5791         return peer_unsuppress_map_set_vty(
5792                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5793                 argv[idx_word]->arg);
5794 }
5795
5796 ALIAS_HIDDEN(neighbor_unsuppress_map, neighbor_unsuppress_map_hidden_cmd,
5797              "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5798              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5799              "Route-map to selectively unsuppress suppressed routes\n"
5800              "Name of route map\n")
5801
5802 DEFUN (no_neighbor_unsuppress_map,
5803        no_neighbor_unsuppress_map_cmd,
5804        "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5805        NO_STR
5806        NEIGHBOR_STR
5807        NEIGHBOR_ADDR_STR2
5808        "Route-map to selectively unsuppress suppressed routes\n"
5809        "Name of route map\n")
5810 {
5811         int idx_peer = 2;
5812         return peer_unsuppress_map_unset_vty(vty, argv[idx_peer]->arg,
5813                                              bgp_node_afi(vty),
5814                                              bgp_node_safi(vty));
5815 }
5816
5817 ALIAS_HIDDEN(no_neighbor_unsuppress_map, no_neighbor_unsuppress_map_hidden_cmd,
5818              "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5819              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5820              "Route-map to selectively unsuppress suppressed routes\n"
5821              "Name of route map\n")
5822
5823 static int peer_maximum_prefix_set_vty(struct vty *vty, const char *ip_str,
5824                                        afi_t afi, safi_t safi,
5825                                        const char *num_str,
5826                                        const char *threshold_str, int warning,
5827                                        const char *restart_str)
5828 {
5829         int ret;
5830         struct peer *peer;
5831         uint32_t max;
5832         uint8_t threshold;
5833         uint16_t restart;
5834
5835         peer = peer_and_group_lookup_vty(vty, ip_str);
5836         if (!peer)
5837                 return CMD_WARNING_CONFIG_FAILED;
5838
5839         max = strtoul(num_str, NULL, 10);
5840         if (threshold_str)
5841                 threshold = atoi(threshold_str);
5842         else
5843                 threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
5844
5845         if (restart_str)
5846                 restart = atoi(restart_str);
5847         else
5848                 restart = 0;
5849
5850         ret = peer_maximum_prefix_set(peer, afi, safi, max, threshold, warning,
5851                                       restart);
5852
5853         return bgp_vty_return(vty, ret);
5854 }
5855
5856 static int peer_maximum_prefix_unset_vty(struct vty *vty, const char *ip_str,
5857                                          afi_t afi, safi_t safi)
5858 {
5859         int ret;
5860         struct peer *peer;
5861
5862         peer = peer_and_group_lookup_vty(vty, ip_str);
5863         if (!peer)
5864                 return CMD_WARNING_CONFIG_FAILED;
5865
5866         ret = peer_maximum_prefix_unset(peer, afi, safi);
5867
5868         return bgp_vty_return(vty, ret);
5869 }
5870
5871 /* Maximum number of prefix configuration.  prefix count is different
5872    for each peer configuration.  So this configuration can be set for
5873    each peer configuration. */
5874 DEFUN (neighbor_maximum_prefix,
5875        neighbor_maximum_prefix_cmd,
5876        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295)",
5877        NEIGHBOR_STR
5878        NEIGHBOR_ADDR_STR2
5879        "Maximum number of prefix accept from this peer\n"
5880        "maximum no. of prefix limit\n")
5881 {
5882         int idx_peer = 1;
5883         int idx_number = 3;
5884         return peer_maximum_prefix_set_vty(
5885                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5886                 argv[idx_number]->arg, NULL, 0, NULL);
5887 }
5888
5889 ALIAS_HIDDEN(neighbor_maximum_prefix, neighbor_maximum_prefix_hidden_cmd,
5890              "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295)",
5891              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5892              "Maximum number of prefix accept from this peer\n"
5893              "maximum no. of prefix limit\n")
5894
5895 DEFUN (neighbor_maximum_prefix_threshold,
5896        neighbor_maximum_prefix_threshold_cmd,
5897        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100)",
5898        NEIGHBOR_STR
5899        NEIGHBOR_ADDR_STR2
5900        "Maximum number of prefix accept from this peer\n"
5901        "maximum no. of prefix limit\n"
5902        "Threshold value (%) at which to generate a warning msg\n")
5903 {
5904         int idx_peer = 1;
5905         int idx_number = 3;
5906         int idx_number_2 = 4;
5907         return peer_maximum_prefix_set_vty(
5908                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5909                 argv[idx_number]->arg, argv[idx_number_2]->arg, 0, NULL);
5910 }
5911
5912 ALIAS_HIDDEN(
5913         neighbor_maximum_prefix_threshold,
5914         neighbor_maximum_prefix_threshold_hidden_cmd,
5915         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100)",
5916         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5917         "Maximum number of prefix accept from this peer\n"
5918         "maximum no. of prefix limit\n"
5919         "Threshold value (%) at which to generate a warning msg\n")
5920
5921 DEFUN (neighbor_maximum_prefix_warning,
5922        neighbor_maximum_prefix_warning_cmd,
5923        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only",
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        "Only give warning message when limit is exceeded\n")
5929 {
5930         int idx_peer = 1;
5931         int idx_number = 3;
5932         return peer_maximum_prefix_set_vty(
5933                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5934                 argv[idx_number]->arg, NULL, 1, NULL);
5935 }
5936
5937 ALIAS_HIDDEN(
5938         neighbor_maximum_prefix_warning,
5939         neighbor_maximum_prefix_warning_hidden_cmd,
5940         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only",
5941         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5942         "Maximum number of prefix accept from this peer\n"
5943         "maximum no. of prefix limit\n"
5944         "Only give warning message when limit is exceeded\n")
5945
5946 DEFUN (neighbor_maximum_prefix_threshold_warning,
5947        neighbor_maximum_prefix_threshold_warning_cmd,
5948        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only",
5949        NEIGHBOR_STR
5950        NEIGHBOR_ADDR_STR2
5951        "Maximum number of prefix accept from this peer\n"
5952        "maximum no. of prefix limit\n"
5953        "Threshold value (%) at which to generate a warning msg\n"
5954        "Only give warning message when limit is exceeded\n")
5955 {
5956         int idx_peer = 1;
5957         int idx_number = 3;
5958         int idx_number_2 = 4;
5959         return peer_maximum_prefix_set_vty(
5960                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5961                 argv[idx_number]->arg, argv[idx_number_2]->arg, 1, NULL);
5962 }
5963
5964 ALIAS_HIDDEN(
5965         neighbor_maximum_prefix_threshold_warning,
5966         neighbor_maximum_prefix_threshold_warning_hidden_cmd,
5967         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only",
5968         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5969         "Maximum number of prefix accept from this peer\n"
5970         "maximum no. of prefix limit\n"
5971         "Threshold value (%) at which to generate a warning msg\n"
5972         "Only give warning message when limit is exceeded\n")
5973
5974 DEFUN (neighbor_maximum_prefix_restart,
5975        neighbor_maximum_prefix_restart_cmd,
5976        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535)",
5977        NEIGHBOR_STR
5978        NEIGHBOR_ADDR_STR2
5979        "Maximum number of prefix accept from this peer\n"
5980        "maximum no. of prefix limit\n"
5981        "Restart bgp connection after limit is exceeded\n"
5982        "Restart interval in minutes\n")
5983 {
5984         int idx_peer = 1;
5985         int idx_number = 3;
5986         int idx_number_2 = 5;
5987         return peer_maximum_prefix_set_vty(
5988                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
5989                 argv[idx_number]->arg, NULL, 0, argv[idx_number_2]->arg);
5990 }
5991
5992 ALIAS_HIDDEN(
5993         neighbor_maximum_prefix_restart,
5994         neighbor_maximum_prefix_restart_hidden_cmd,
5995         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535)",
5996         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
5997         "Maximum number of prefix accept from this peer\n"
5998         "maximum no. of prefix limit\n"
5999         "Restart bgp connection after limit is exceeded\n"
6000         "Restart interval in minutes\n")
6001
6002 DEFUN (neighbor_maximum_prefix_threshold_restart,
6003        neighbor_maximum_prefix_threshold_restart_cmd,
6004        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535)",
6005        NEIGHBOR_STR
6006        NEIGHBOR_ADDR_STR2
6007        "Maximum number of prefixes to accept from this peer\n"
6008        "maximum no. of prefix limit\n"
6009        "Threshold value (%) at which to generate a warning msg\n"
6010        "Restart bgp connection after limit is exceeded\n"
6011        "Restart interval in minutes\n")
6012 {
6013         int idx_peer = 1;
6014         int idx_number = 3;
6015         int idx_number_2 = 4;
6016         int idx_number_3 = 6;
6017         return peer_maximum_prefix_set_vty(
6018                 vty, argv[idx_peer]->arg, bgp_node_afi(vty), bgp_node_safi(vty),
6019                 argv[idx_number]->arg, argv[idx_number_2]->arg, 0,
6020                 argv[idx_number_3]->arg);
6021 }
6022
6023 ALIAS_HIDDEN(
6024         neighbor_maximum_prefix_threshold_restart,
6025         neighbor_maximum_prefix_threshold_restart_hidden_cmd,
6026         "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535)",
6027         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6028         "Maximum number of prefixes to accept from this peer\n"
6029         "maximum no. of prefix limit\n"
6030         "Threshold value (%) at which to generate a warning msg\n"
6031         "Restart bgp connection after limit is exceeded\n"
6032         "Restart interval in minutes\n")
6033
6034 DEFUN (no_neighbor_maximum_prefix,
6035        no_neighbor_maximum_prefix_cmd,
6036        "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only]]",
6037        NO_STR
6038        NEIGHBOR_STR
6039        NEIGHBOR_ADDR_STR2
6040        "Maximum number of prefixes to accept from this peer\n"
6041        "maximum no. of prefix limit\n"
6042        "Threshold value (%) at which to generate a warning msg\n"
6043        "Restart bgp connection after limit is exceeded\n"
6044        "Restart interval in minutes\n"
6045        "Only give warning message when limit is exceeded\n")
6046 {
6047         int idx_peer = 2;
6048         return peer_maximum_prefix_unset_vty(vty, argv[idx_peer]->arg,
6049                                              bgp_node_afi(vty),
6050                                              bgp_node_safi(vty));
6051 }
6052
6053 ALIAS_HIDDEN(
6054         no_neighbor_maximum_prefix, no_neighbor_maximum_prefix_hidden_cmd,
6055         "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only]]",
6056         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6057         "Maximum number of prefixes to accept from this peer\n"
6058         "maximum no. of prefix limit\n"
6059         "Threshold value (%) at which to generate a warning msg\n"
6060         "Restart bgp connection after limit is exceeded\n"
6061         "Restart interval in minutes\n"
6062         "Only give warning message when limit is exceeded\n")
6063
6064
6065 /* "neighbor allowas-in" */
6066 DEFUN (neighbor_allowas_in,
6067        neighbor_allowas_in_cmd,
6068        "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6069        NEIGHBOR_STR
6070        NEIGHBOR_ADDR_STR2
6071        "Accept as-path with my AS present in it\n"
6072        "Number of occurrences of AS number\n"
6073        "Only accept my AS in the as-path if the route was originated in my AS\n")
6074 {
6075         int idx_peer = 1;
6076         int idx_number_origin = 3;
6077         int ret;
6078         int origin = 0;
6079         struct peer *peer;
6080         int allow_num = 0;
6081
6082         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6083         if (!peer)
6084                 return CMD_WARNING_CONFIG_FAILED;
6085
6086         if (argc <= idx_number_origin)
6087                 allow_num = 3;
6088         else {
6089                 if (argv[idx_number_origin]->type == WORD_TKN)
6090                         origin = 1;
6091                 else
6092                         allow_num = atoi(argv[idx_number_origin]->arg);
6093         }
6094
6095         ret = peer_allowas_in_set(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6096                                   allow_num, origin);
6097
6098         return bgp_vty_return(vty, ret);
6099 }
6100
6101 ALIAS_HIDDEN(
6102         neighbor_allowas_in, neighbor_allowas_in_hidden_cmd,
6103         "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6104         NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6105         "Accept as-path with my AS present in it\n"
6106         "Number of occurrences of AS number\n"
6107         "Only accept my AS in the as-path if the route was originated in my AS\n")
6108
6109 DEFUN (no_neighbor_allowas_in,
6110        no_neighbor_allowas_in_cmd,
6111        "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6112        NO_STR
6113        NEIGHBOR_STR
6114        NEIGHBOR_ADDR_STR2
6115        "allow local ASN appears in aspath attribute\n"
6116        "Number of occurrences of AS number\n"
6117        "Only accept my AS in the as-path if the route was originated in my AS\n")
6118 {
6119         int idx_peer = 2;
6120         int ret;
6121         struct peer *peer;
6122
6123         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6124         if (!peer)
6125                 return CMD_WARNING_CONFIG_FAILED;
6126
6127         ret = peer_allowas_in_unset(peer, bgp_node_afi(vty),
6128                                     bgp_node_safi(vty));
6129
6130         return bgp_vty_return(vty, ret);
6131 }
6132
6133 ALIAS_HIDDEN(
6134         no_neighbor_allowas_in, no_neighbor_allowas_in_hidden_cmd,
6135         "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
6136         NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6137         "allow local ASN appears in aspath attribute\n"
6138         "Number of occurrences of AS number\n"
6139         "Only accept my AS in the as-path if the route was originated in my AS\n")
6140
6141 DEFUN (neighbor_ttl_security,
6142        neighbor_ttl_security_cmd,
6143        "neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
6144        NEIGHBOR_STR
6145        NEIGHBOR_ADDR_STR2
6146        "BGP ttl-security parameters\n"
6147        "Specify the maximum number of hops to the BGP peer\n"
6148        "Number of hops to BGP peer\n")
6149 {
6150         int idx_peer = 1;
6151         int idx_number = 4;
6152         struct peer *peer;
6153         int gtsm_hops;
6154
6155         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6156         if (!peer)
6157                 return CMD_WARNING_CONFIG_FAILED;
6158
6159         gtsm_hops = strtoul(argv[idx_number]->arg, NULL, 10);
6160
6161         /*
6162          * If 'neighbor swpX', then this is for directly connected peers,
6163          * we should not accept a ttl-security hops value greater than 1.
6164          */
6165         if (peer->conf_if && (gtsm_hops > 1)) {
6166                 vty_out(vty,
6167                         "%s is directly connected peer, hops cannot exceed 1\n",
6168                         argv[idx_peer]->arg);
6169                 return CMD_WARNING_CONFIG_FAILED;
6170         }
6171
6172         return bgp_vty_return(vty, peer_ttl_security_hops_set(peer, gtsm_hops));
6173 }
6174
6175 DEFUN (no_neighbor_ttl_security,
6176        no_neighbor_ttl_security_cmd,
6177        "no neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
6178        NO_STR
6179        NEIGHBOR_STR
6180        NEIGHBOR_ADDR_STR2
6181        "BGP ttl-security parameters\n"
6182        "Specify the maximum number of hops to the BGP peer\n"
6183        "Number of hops to BGP peer\n")
6184 {
6185         int idx_peer = 2;
6186         struct peer *peer;
6187
6188         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6189         if (!peer)
6190                 return CMD_WARNING_CONFIG_FAILED;
6191
6192         return bgp_vty_return(vty, peer_ttl_security_hops_unset(peer));
6193 }
6194
6195 DEFUN (neighbor_addpath_tx_all_paths,
6196        neighbor_addpath_tx_all_paths_cmd,
6197        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6198        NEIGHBOR_STR
6199        NEIGHBOR_ADDR_STR2
6200        "Use addpath to advertise all paths to a neighbor\n")
6201 {
6202         int idx_peer = 1;
6203         struct peer *peer;
6204
6205         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6206         if (!peer)
6207                 return CMD_WARNING_CONFIG_FAILED;
6208
6209         bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6210                                  BGP_ADDPATH_ALL);
6211         return CMD_SUCCESS;
6212 }
6213
6214 ALIAS_HIDDEN(neighbor_addpath_tx_all_paths,
6215              neighbor_addpath_tx_all_paths_hidden_cmd,
6216              "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6217              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6218              "Use addpath to advertise all paths to a neighbor\n")
6219
6220 DEFUN (no_neighbor_addpath_tx_all_paths,
6221        no_neighbor_addpath_tx_all_paths_cmd,
6222        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6223        NO_STR
6224        NEIGHBOR_STR
6225        NEIGHBOR_ADDR_STR2
6226        "Use addpath to advertise all paths to a neighbor\n")
6227 {
6228         int idx_peer = 2;
6229         struct peer *peer;
6230
6231         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6232         if (!peer)
6233                 return CMD_WARNING_CONFIG_FAILED;
6234
6235         if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
6236             != BGP_ADDPATH_ALL) {
6237                 vty_out(vty,
6238                         "%% Peer not currently configured to transmit all paths.");
6239                 return CMD_WARNING_CONFIG_FAILED;
6240         }
6241
6242         bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6243                                  BGP_ADDPATH_NONE);
6244
6245         return CMD_SUCCESS;
6246 }
6247
6248 ALIAS_HIDDEN(no_neighbor_addpath_tx_all_paths,
6249              no_neighbor_addpath_tx_all_paths_hidden_cmd,
6250              "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
6251              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6252              "Use addpath to advertise all paths to a neighbor\n")
6253
6254 DEFUN (neighbor_addpath_tx_bestpath_per_as,
6255        neighbor_addpath_tx_bestpath_per_as_cmd,
6256        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6257        NEIGHBOR_STR
6258        NEIGHBOR_ADDR_STR2
6259        "Use addpath to advertise the bestpath per each neighboring AS\n")
6260 {
6261         int idx_peer = 1;
6262         struct peer *peer;
6263
6264         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6265         if (!peer)
6266                 return CMD_WARNING_CONFIG_FAILED;
6267
6268         bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6269                                  BGP_ADDPATH_BEST_PER_AS);
6270
6271         return CMD_SUCCESS;
6272 }
6273
6274 ALIAS_HIDDEN(neighbor_addpath_tx_bestpath_per_as,
6275              neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
6276              "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6277              NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6278              "Use addpath to advertise the bestpath per each neighboring AS\n")
6279
6280 DEFUN (no_neighbor_addpath_tx_bestpath_per_as,
6281        no_neighbor_addpath_tx_bestpath_per_as_cmd,
6282        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6283        NO_STR
6284        NEIGHBOR_STR
6285        NEIGHBOR_ADDR_STR2
6286        "Use addpath to advertise the bestpath per each neighboring AS\n")
6287 {
6288         int idx_peer = 2;
6289         struct peer *peer;
6290
6291         peer = peer_and_group_lookup_vty(vty, argv[idx_peer]->arg);
6292         if (!peer)
6293                 return CMD_WARNING_CONFIG_FAILED;
6294
6295         if (peer->addpath_type[bgp_node_afi(vty)][bgp_node_safi(vty)]
6296             != BGP_ADDPATH_BEST_PER_AS) {
6297                 vty_out(vty,
6298                         "%% Peer not currently configured to transmit all best path per as.");
6299                 return CMD_WARNING_CONFIG_FAILED;
6300         }
6301
6302         bgp_addpath_set_peer_type(peer, bgp_node_afi(vty), bgp_node_safi(vty),
6303                                  BGP_ADDPATH_NONE);
6304
6305         return CMD_SUCCESS;
6306 }
6307
6308 ALIAS_HIDDEN(no_neighbor_addpath_tx_bestpath_per_as,
6309              no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd,
6310              "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
6311              NO_STR NEIGHBOR_STR NEIGHBOR_ADDR_STR2
6312              "Use addpath to advertise the bestpath per each neighboring AS\n")
6313
6314 static int set_ecom_list(struct vty *vty, int argc, struct cmd_token **argv,
6315                          struct ecommunity **list)
6316 {
6317         struct ecommunity *ecom = NULL;
6318         struct ecommunity *ecomadd;
6319
6320         for (; argc; --argc, ++argv) {
6321
6322                 ecomadd = ecommunity_str2com(argv[0]->arg,
6323                                              ECOMMUNITY_ROUTE_TARGET, 0);
6324                 if (!ecomadd) {
6325                         vty_out(vty, "Malformed community-list value\n");
6326                         if (ecom)
6327                                 ecommunity_free(&ecom);
6328                         return CMD_WARNING_CONFIG_FAILED;
6329                 }
6330
6331                 if (ecom) {
6332                         ecommunity_merge(ecom, ecomadd);
6333                         ecommunity_free(&ecomadd);
6334                 } else {
6335                         ecom = ecomadd;
6336                 }
6337         }
6338
6339         if (*list) {
6340                 ecommunity_free(&*list);
6341         }
6342         *list = ecom;
6343
6344         return CMD_SUCCESS;
6345 }
6346
6347 /*
6348  * v2vimport is true if we are handling a `import vrf ...` command
6349  */
6350 static afi_t vpn_policy_getafi(struct vty *vty, struct bgp *bgp, bool v2vimport)
6351 {
6352         afi_t afi;
6353
6354         switch (vty->node) {
6355         case BGP_IPV4_NODE:
6356                 afi = AFI_IP;
6357                 break;
6358         case BGP_IPV6_NODE:
6359                 afi = AFI_IP6;
6360                 break;
6361         default:
6362                 vty_out(vty,
6363                         "%% context error: valid only in address-family <ipv4|ipv6> unicast block\n");
6364                 return AFI_MAX;
6365         }
6366
6367         if (!v2vimport) {
6368                 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6369                                BGP_CONFIG_VRF_TO_VRF_IMPORT)
6370                     || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6371                                   BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
6372                         vty_out(vty,
6373                                 "%% error: Please unconfigure import vrf commands before using vpn commands\n");
6374                         return AFI_MAX;
6375                 }
6376         } else {
6377                 if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6378                                BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT)
6379                     || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
6380                                   BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT)) {
6381                         vty_out(vty,
6382                                 "%% error: Please unconfigure vpn to vrf commands before using import vrf commands\n");
6383                         return AFI_MAX;
6384                 }
6385         }
6386         return afi;
6387 }
6388
6389 DEFPY (af_rd_vpn_export,
6390        af_rd_vpn_export_cmd,
6391        "[no] rd vpn export ASN:NN_OR_IP-ADDRESS:NN$rd_str",
6392        NO_STR
6393        "Specify route distinguisher\n"
6394        "Between current address-family and vpn\n"
6395        "For routes leaked from current address-family to vpn\n"
6396        "Route Distinguisher (<as-number>:<number> | <ip-address>:<number>)\n")
6397 {
6398         VTY_DECLVAR_CONTEXT(bgp, bgp);
6399         struct prefix_rd prd;
6400         int ret;
6401         afi_t afi;
6402         int idx = 0;
6403         int yes = 1;
6404
6405         if (argv_find(argv, argc, "no", &idx))
6406                 yes = 0;
6407
6408         if (yes) {
6409                 ret = str2prefix_rd(rd_str, &prd);
6410                 if (!ret) {
6411                         vty_out(vty, "%% Malformed rd\n");
6412                         return CMD_WARNING_CONFIG_FAILED;
6413                 }
6414         }
6415
6416         afi = vpn_policy_getafi(vty, bgp, false);
6417         if (afi == AFI_MAX)
6418                 return CMD_WARNING_CONFIG_FAILED;
6419
6420         /*
6421          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6422          */
6423         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6424                            bgp_get_default(), bgp);
6425
6426         if (yes) {
6427                 bgp->vpn_policy[afi].tovpn_rd = prd;
6428                 SET_FLAG(bgp->vpn_policy[afi].flags,
6429                          BGP_VPN_POLICY_TOVPN_RD_SET);
6430         } else {
6431                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6432                            BGP_VPN_POLICY_TOVPN_RD_SET);
6433         }
6434
6435         /* post-change: re-export vpn routes */
6436         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6437                             bgp_get_default(), bgp);
6438
6439         return CMD_SUCCESS;
6440 }
6441
6442 ALIAS (af_rd_vpn_export,
6443        af_no_rd_vpn_export_cmd,
6444        "no rd vpn export",
6445        NO_STR
6446        "Specify route distinguisher\n"
6447        "Between current address-family and vpn\n"
6448        "For routes leaked from current address-family to vpn\n")
6449
6450 DEFPY (af_label_vpn_export,
6451        af_label_vpn_export_cmd,
6452        "[no] label vpn export <(0-1048575)$label_val|auto$label_auto>",
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        "Label Value <0-1048575>\n"
6458        "Automatically assign a label\n")
6459 {
6460         VTY_DECLVAR_CONTEXT(bgp, bgp);
6461         mpls_label_t label = MPLS_LABEL_NONE;
6462         afi_t afi;
6463         int idx = 0;
6464         int yes = 1;
6465
6466         if (argv_find(argv, argc, "no", &idx))
6467                 yes = 0;
6468
6469         /* If "no ...", squash trailing parameter */
6470         if (!yes)
6471                 label_auto = NULL;
6472
6473         if (yes) {
6474                 if (!label_auto)
6475                         label = label_val; /* parser should force unsigned */
6476         }
6477
6478         afi = vpn_policy_getafi(vty, bgp, false);
6479         if (afi == AFI_MAX)
6480                 return CMD_WARNING_CONFIG_FAILED;
6481
6482
6483         if (label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
6484                                      BGP_VPN_POLICY_TOVPN_LABEL_AUTO))
6485                 /* no change */
6486                 return CMD_SUCCESS;
6487
6488         /*
6489          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6490          */
6491         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6492                            bgp_get_default(), bgp);
6493
6494         if (!label_auto && CHECK_FLAG(bgp->vpn_policy[afi].flags,
6495                                       BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
6496
6497                 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
6498
6499                         /*
6500                          * label has previously been automatically
6501                          * assigned by labelpool: release it
6502                          *
6503                          * NB if tovpn_label == MPLS_LABEL_NONE it
6504                          * means the automatic assignment is in flight
6505                          * and therefore the labelpool callback must
6506                          * detect that the auto label is not needed.
6507                          */
6508
6509                         bgp_lp_release(LP_TYPE_VRF,
6510                                        &bgp->vpn_policy[afi],
6511                                        bgp->vpn_policy[afi].tovpn_label);
6512                 }
6513                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6514                            BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
6515         }
6516
6517         bgp->vpn_policy[afi].tovpn_label = label;
6518         if (label_auto) {
6519                 SET_FLAG(bgp->vpn_policy[afi].flags,
6520                          BGP_VPN_POLICY_TOVPN_LABEL_AUTO);
6521                 bgp_lp_get(LP_TYPE_VRF, &bgp->vpn_policy[afi],
6522                            vpn_leak_label_callback);
6523         }
6524
6525         /* post-change: re-export vpn routes */
6526         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6527                             bgp_get_default(), bgp);
6528
6529         return CMD_SUCCESS;
6530 }
6531
6532 ALIAS (af_label_vpn_export,
6533        af_no_label_vpn_export_cmd,
6534        "no label vpn export",
6535        NO_STR
6536        "label value for VRF\n"
6537        "Between current address-family and vpn\n"
6538        "For routes leaked from current address-family to vpn\n")
6539
6540 DEFPY (af_nexthop_vpn_export,
6541        af_nexthop_vpn_export_cmd,
6542        "[no] nexthop vpn export <A.B.C.D|X:X::X:X>$nexthop_str",
6543        NO_STR
6544        "Specify next hop to use for VRF advertised prefixes\n"
6545        "Between current address-family and vpn\n"
6546        "For routes leaked from current address-family to vpn\n"
6547        "IPv4 prefix\n"
6548        "IPv6 prefix\n")
6549 {
6550         VTY_DECLVAR_CONTEXT(bgp, bgp);
6551         afi_t afi;
6552         struct prefix p;
6553         int idx = 0;
6554         int yes = 1;
6555
6556         if (argv_find(argv, argc, "no", &idx))
6557                 yes = 0;
6558
6559         if (yes) {
6560                 if (!sockunion2hostprefix(nexthop_str, &p))
6561                         return CMD_WARNING_CONFIG_FAILED;
6562         }
6563
6564         afi = vpn_policy_getafi(vty, bgp, false);
6565         if (afi == AFI_MAX)
6566                 return CMD_WARNING_CONFIG_FAILED;
6567
6568         /*
6569          * pre-change: un-export vpn routes (vpn->vrf routes unaffected)
6570          */
6571         vpn_leak_prechange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6572                            bgp_get_default(), bgp);
6573
6574         if (yes) {
6575                 bgp->vpn_policy[afi].tovpn_nexthop = p;
6576                 SET_FLAG(bgp->vpn_policy[afi].flags,
6577                          BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
6578         } else {
6579                 UNSET_FLAG(bgp->vpn_policy[afi].flags,
6580                            BGP_VPN_POLICY_TOVPN_NEXTHOP_SET);
6581         }
6582
6583         /* post-change: re-export vpn routes */
6584         vpn_leak_postchange(BGP_VPN_POLICY_DIR_TOVPN, afi,
6585                             bgp_get_default(), bgp);
6586
6587         return CMD_SUCCESS;
6588 }
6589
6590 ALIAS (af_nexthop_vpn_export,
6591        af_no_nexthop_vpn_export_cmd,
6592        "no nexthop vpn export",
6593        NO_STR
6594        "Specify next hop to use for VRF advertised prefixes\n"
6595        "Between current address-family and vpn\n"
6596        "For routes leaked from current address-family to vpn\n")
6597
6598 static int vpn_policy_getdirs(struct vty *vty, const char *dstr, int *dodir)
6599 {
6600         if (!strcmp(dstr, "import")) {
6601                 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
6602         } else if (!strcmp(dstr, "export")) {
6603                 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
6604         } else if (!strcmp(dstr, "both")) {
6605                 dodir[BGP_VPN_POLICY_DIR_FROMVPN] = 1;
6606                 dodir[BGP_VPN_POLICY_DIR_TOVPN] = 1;
6607         } else {
6608                 vty_out(vty, "%% direction parse error\n");
6609                 return CMD_WARNING_CONFIG_FAILED;
6610         }
6611         return CMD_SUCCESS;
6612 }
6613
6614 DEFPY (af_rt_vpn_imexport,
6615        af_rt_vpn_imexport_cmd,
6616        "[no] <rt|route-target> vpn <import|export|both>$direction_str RTLIST...",
6617        NO_STR
6618        "Specify route target list\n"
6619        "Specify route target list\n"
6620        "Between current address-family and vpn\n"
6621        "For routes leaked from vpn to current address-family: match any\n"
6622        "For routes leaked from current address-family to vpn: set\n"
6623        "both import: match any and export: set\n"
6624        "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6625 {
6626         VTY_DECLVAR_CONTEXT(bgp, bgp);
6627         int ret;
6628         struct ecommunity *ecom = NULL;
6629         int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
6630         vpn_policy_direction_t dir;
6631         afi_t afi;
6632         int idx = 0;
6633         int yes = 1;
6634
6635         if (argv_find(argv, argc, "no", &idx))
6636                 yes = 0;
6637
6638         afi = vpn_policy_getafi(vty, bgp, false);
6639         if (afi == AFI_MAX)
6640                 return CMD_WARNING_CONFIG_FAILED;
6641
6642         ret = vpn_policy_getdirs(vty, direction_str, dodir);
6643         if (ret != CMD_SUCCESS)
6644                 return ret;
6645
6646         if (yes) {
6647                 if (!argv_find(argv, argc, "RTLIST", &idx)) {
6648                         vty_out(vty, "%% Missing RTLIST\n");
6649                         return CMD_WARNING_CONFIG_FAILED;
6650                 }
6651                 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom);
6652                 if (ret != CMD_SUCCESS) {
6653                         return ret;
6654                 }
6655         }
6656
6657         for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
6658                 if (!dodir[dir])
6659                         continue;
6660
6661                 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6662
6663                 if (yes) {
6664                         if (bgp->vpn_policy[afi].rtlist[dir])
6665                                 ecommunity_free(
6666                                                 &bgp->vpn_policy[afi].rtlist[dir]);
6667                         bgp->vpn_policy[afi].rtlist[dir] =
6668                                 ecommunity_dup(ecom);
6669                 } else {
6670                         if (bgp->vpn_policy[afi].rtlist[dir])
6671                                 ecommunity_free(
6672                                                 &bgp->vpn_policy[afi].rtlist[dir]);
6673                         bgp->vpn_policy[afi].rtlist[dir] = NULL;
6674                 }
6675
6676                 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6677         }
6678
6679         if (ecom)
6680                 ecommunity_free(&ecom);
6681
6682         return CMD_SUCCESS;
6683 }
6684
6685 ALIAS (af_rt_vpn_imexport,
6686        af_no_rt_vpn_imexport_cmd,
6687        "no <rt|route-target> vpn <import|export|both>$direction_str",
6688        NO_STR
6689        "Specify route target list\n"
6690        "Specify route target list\n"
6691        "Between current address-family and vpn\n"
6692        "For routes leaked from vpn to current address-family\n"
6693        "For routes leaked from current address-family to vpn\n"
6694        "both import and export\n")
6695
6696 DEFPY (af_route_map_vpn_imexport,
6697        af_route_map_vpn_imexport_cmd,
6698 /* future: "route-map <vpn|evpn|vrf NAME> <import|export> RMAP" */
6699        "[no] route-map vpn <import|export>$direction_str RMAP$rmap_str",
6700        NO_STR
6701        "Specify route map\n"
6702        "Between current address-family and vpn\n"
6703        "For routes leaked from vpn to current address-family\n"
6704        "For routes leaked from current address-family to vpn\n"
6705        "name of route-map\n")
6706 {
6707         VTY_DECLVAR_CONTEXT(bgp, bgp);
6708         int ret;
6709         int dodir[BGP_VPN_POLICY_DIR_MAX] = {0};
6710         vpn_policy_direction_t dir;
6711         afi_t afi;
6712         int idx = 0;
6713         int yes = 1;
6714
6715         if (argv_find(argv, argc, "no", &idx))
6716                 yes = 0;
6717
6718         afi = vpn_policy_getafi(vty, bgp, false);
6719         if (afi == AFI_MAX)
6720                 return CMD_WARNING_CONFIG_FAILED;
6721
6722         ret = vpn_policy_getdirs(vty, direction_str, dodir);
6723         if (ret != CMD_SUCCESS)
6724                 return ret;
6725
6726         for (dir = 0; dir < BGP_VPN_POLICY_DIR_MAX; ++dir) {
6727                 if (!dodir[dir])
6728                         continue;
6729
6730                 vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6731
6732                 if (yes) {
6733                         if (bgp->vpn_policy[afi].rmap_name[dir])
6734                                 XFREE(MTYPE_ROUTE_MAP_NAME,
6735                                       bgp->vpn_policy[afi].rmap_name[dir]);
6736                         bgp->vpn_policy[afi].rmap_name[dir] = XSTRDUP(
6737                                                                       MTYPE_ROUTE_MAP_NAME, rmap_str);
6738                         bgp->vpn_policy[afi].rmap[dir] =
6739                                 route_map_lookup_warn_noexist(vty, rmap_str);
6740                         if (!bgp->vpn_policy[afi].rmap[dir])
6741                                 return CMD_SUCCESS;
6742                 } else {
6743                         if (bgp->vpn_policy[afi].rmap_name[dir])
6744                                 XFREE(MTYPE_ROUTE_MAP_NAME,
6745                                       bgp->vpn_policy[afi].rmap_name[dir]);
6746                         bgp->vpn_policy[afi].rmap_name[dir] = NULL;
6747                         bgp->vpn_policy[afi].rmap[dir] = NULL;
6748                 }
6749
6750                 vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6751         }
6752
6753         return CMD_SUCCESS;
6754 }
6755
6756 ALIAS (af_route_map_vpn_imexport,
6757        af_no_route_map_vpn_imexport_cmd,
6758        "no route-map vpn <import|export>$direction_str",
6759        NO_STR
6760        "Specify route map\n"
6761        "Between current address-family and vpn\n"
6762        "For routes leaked from vpn to current address-family\n"
6763        "For routes leaked from current address-family to vpn\n")
6764
6765 DEFPY(af_import_vrf_route_map, af_import_vrf_route_map_cmd,
6766       "[no] import vrf route-map RMAP$rmap_str",
6767       NO_STR
6768       "Import routes from another VRF\n"
6769       "Vrf routes being filtered\n"
6770       "Specify route map\n"
6771       "name of route-map\n")
6772 {
6773         VTY_DECLVAR_CONTEXT(bgp, bgp);
6774         vpn_policy_direction_t dir = BGP_VPN_POLICY_DIR_FROMVPN;
6775         afi_t afi;
6776         int idx = 0;
6777         int yes = 1;
6778         struct bgp *bgp_default;
6779
6780         if (argv_find(argv, argc, "no", &idx))
6781                 yes = 0;
6782
6783         afi = vpn_policy_getafi(vty, bgp, true);
6784         if (afi == AFI_MAX)
6785                 return CMD_WARNING_CONFIG_FAILED;
6786
6787         bgp_default = bgp_get_default();
6788         if (!bgp_default) {
6789                 int32_t ret;
6790                 as_t as = bgp->as;
6791
6792                 /* Auto-create assuming the same AS */
6793                 ret = bgp_get(&bgp_default, &as, NULL,
6794                               BGP_INSTANCE_TYPE_DEFAULT);
6795
6796                 if (ret) {
6797                         vty_out(vty,
6798                                 "VRF default is not configured as a bgp instance\n");
6799                         return CMD_WARNING;
6800                 }
6801         }
6802
6803         vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6804
6805         if (yes) {
6806                 if (bgp->vpn_policy[afi].rmap_name[dir])
6807                         XFREE(MTYPE_ROUTE_MAP_NAME,
6808                               bgp->vpn_policy[afi].rmap_name[dir]);
6809                 bgp->vpn_policy[afi].rmap_name[dir] =
6810                         XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_str);
6811                 bgp->vpn_policy[afi].rmap[dir] =
6812                         route_map_lookup_warn_noexist(vty, rmap_str);
6813                 if (!bgp->vpn_policy[afi].rmap[dir])
6814                         return CMD_SUCCESS;
6815         } else {
6816                 if (bgp->vpn_policy[afi].rmap_name[dir])
6817                         XFREE(MTYPE_ROUTE_MAP_NAME,
6818                               bgp->vpn_policy[afi].rmap_name[dir]);
6819                 bgp->vpn_policy[afi].rmap_name[dir] = NULL;
6820                 bgp->vpn_policy[afi].rmap[dir] = NULL;
6821         }
6822
6823         vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6824
6825         return CMD_SUCCESS;
6826 }
6827
6828 ALIAS(af_import_vrf_route_map, af_no_import_vrf_route_map_cmd,
6829       "no import vrf route-map",
6830       NO_STR
6831       "Import routes from another VRF\n"
6832       "Vrf routes being filtered\n"
6833       "Specify route map\n")
6834
6835 DEFPY(bgp_imexport_vrf, bgp_imexport_vrf_cmd,
6836       "[no] import vrf VIEWVRFNAME$import_name",
6837       NO_STR
6838       "Import routes from another VRF\n"
6839       "VRF to import from\n"
6840       "The name of the VRF\n")
6841 {
6842         VTY_DECLVAR_CONTEXT(bgp, bgp);
6843         struct listnode *node;
6844         struct bgp *vrf_bgp, *bgp_default;
6845         int32_t ret = 0;
6846         as_t as = bgp->as;
6847         bool remove = false;
6848         int32_t idx = 0;
6849         char *vname;
6850         enum bgp_instance_type bgp_type = BGP_INSTANCE_TYPE_VRF;
6851         safi_t safi;
6852         afi_t afi;
6853
6854         if (import_name == NULL) {
6855                 vty_out(vty, "%% Missing import name\n");
6856                 return CMD_WARNING;
6857         }
6858
6859         if (argv_find(argv, argc, "no", &idx))
6860                 remove = true;
6861
6862         afi = vpn_policy_getafi(vty, bgp, true);
6863         if (afi == AFI_MAX)
6864                 return CMD_WARNING_CONFIG_FAILED;
6865
6866         safi = bgp_node_safi(vty);
6867
6868         if (((BGP_INSTANCE_TYPE_DEFAULT == bgp->inst_type)
6869              && (strcmp(import_name, VRF_DEFAULT_NAME) == 0))
6870             || (bgp->name && (strcmp(import_name, bgp->name) == 0))) {
6871                 vty_out(vty, "%% Cannot %s vrf %s into itself\n",
6872                         remove ? "unimport" : "import", import_name);
6873                 return CMD_WARNING;
6874         }
6875
6876         bgp_default = bgp_get_default();
6877         if (!bgp_default) {
6878                 /* Auto-create assuming the same AS */
6879                 ret = bgp_get(&bgp_default, &as, NULL,
6880                               BGP_INSTANCE_TYPE_DEFAULT);
6881
6882                 if (ret) {
6883                         vty_out(vty,
6884                                 "VRF default is not configured as a bgp instance\n");
6885                         return CMD_WARNING;
6886                 }
6887         }
6888
6889         vrf_bgp = bgp_lookup_by_name(import_name);
6890         if (!vrf_bgp) {
6891                 if (strcmp(import_name, VRF_DEFAULT_NAME) == 0)
6892                         vrf_bgp = bgp_default;
6893                 else
6894                         /* Auto-create assuming the same AS */
6895                         ret = bgp_get(&vrf_bgp, &as, import_name, bgp_type);
6896
6897                 if (ret) {
6898                         vty_out(vty,
6899                                 "VRF %s is not configured as a bgp instance\n",
6900                                 import_name);
6901                         return CMD_WARNING;
6902                 }
6903         }
6904
6905         if (remove) {
6906                 vrf_unimport_from_vrf(bgp, vrf_bgp, afi, safi);
6907         } else {
6908                 /* Already importing from "import_vrf"? */
6909                 for (ALL_LIST_ELEMENTS_RO(bgp->vpn_policy[afi].import_vrf, node,
6910                                           vname)) {
6911                         if (strcmp(vname, import_name) == 0)
6912                                 return CMD_WARNING;
6913                 }
6914
6915                 vrf_import_from_vrf(bgp, vrf_bgp, afi, safi);
6916         }
6917
6918         return CMD_SUCCESS;
6919 }
6920
6921 /* This command is valid only in a bgp vrf instance or the default instance */
6922 DEFPY (bgp_imexport_vpn,
6923        bgp_imexport_vpn_cmd,
6924        "[no] <import|export>$direction_str vpn",
6925        NO_STR
6926        "Import routes to this address-family\n"
6927        "Export routes from this address-family\n"
6928        "to/from default instance VPN RIB\n")
6929 {
6930         VTY_DECLVAR_CONTEXT(bgp, bgp);
6931         int previous_state;
6932         afi_t afi;
6933         safi_t safi;
6934         int idx = 0;
6935         int yes = 1;
6936         int flag;
6937         vpn_policy_direction_t dir;
6938
6939         if (argv_find(argv, argc, "no", &idx))
6940                 yes = 0;
6941
6942         if (BGP_INSTANCE_TYPE_VRF != bgp->inst_type &&
6943                 BGP_INSTANCE_TYPE_DEFAULT != bgp->inst_type) {
6944
6945                 vty_out(vty, "%% import|export vpn valid only for bgp vrf or default instance\n");
6946                 return CMD_WARNING_CONFIG_FAILED;
6947         }
6948
6949         afi = bgp_node_afi(vty);
6950         safi = bgp_node_safi(vty);
6951         if ((SAFI_UNICAST != safi) || ((AFI_IP != afi) && (AFI_IP6 != afi))) {
6952                 vty_out(vty, "%% import|export vpn valid only for unicast ipv4|ipv6\n");
6953                 return CMD_WARNING_CONFIG_FAILED;
6954         }
6955
6956         if (!strcmp(direction_str, "import")) {
6957                 flag = BGP_CONFIG_MPLSVPN_TO_VRF_IMPORT;
6958                 dir = BGP_VPN_POLICY_DIR_FROMVPN;
6959         } else if (!strcmp(direction_str, "export")) {
6960                 flag = BGP_CONFIG_VRF_TO_MPLSVPN_EXPORT;
6961                 dir = BGP_VPN_POLICY_DIR_TOVPN;
6962         } else {
6963                 vty_out(vty, "%% unknown direction %s\n", direction_str);
6964                 return CMD_WARNING_CONFIG_FAILED;
6965         }
6966
6967         previous_state = CHECK_FLAG(bgp->af_flags[afi][safi], flag);
6968
6969         if (yes) {
6970                 SET_FLAG(bgp->af_flags[afi][safi], flag);
6971                 if (!previous_state) {
6972                         /* trigger export current vrf */
6973                         vpn_leak_postchange(dir, afi, bgp_get_default(), bgp);
6974                 }
6975         } else {
6976                 if (previous_state) {
6977                         /* trigger un-export current vrf */
6978                         vpn_leak_prechange(dir, afi, bgp_get_default(), bgp);
6979                 }
6980                 UNSET_FLAG(bgp->af_flags[afi][safi], flag);
6981         }
6982
6983         return CMD_SUCCESS;
6984 }
6985
6986 DEFPY (af_routetarget_import,
6987        af_routetarget_import_cmd,
6988        "[no] <rt|route-target> redirect import RTLIST...",
6989        NO_STR
6990        "Specify route target list\n"
6991        "Specify route target list\n"
6992        "Flow-spec redirect type route target\n"
6993        "Import routes to this address-family\n"
6994        "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6995 {
6996         VTY_DECLVAR_CONTEXT(bgp, bgp);
6997         int ret;
6998         struct ecommunity *ecom = NULL;
6999         afi_t afi;
7000         int idx = 0;
7001         int yes = 1;
7002
7003         if (argv_find(argv, argc, "no", &idx))
7004                 yes = 0;
7005
7006         afi = vpn_policy_getafi(vty, bgp, false);
7007         if (afi == AFI_MAX)
7008                 return CMD_WARNING_CONFIG_FAILED;
7009
7010         if (yes) {
7011                 if (!argv_find(argv, argc, "RTLIST", &idx)) {
7012                         vty_out(vty, "%% Missing RTLIST\n");
7013                         return CMD_WARNING_CONFIG_FAILED;
7014                 }
7015                 ret = set_ecom_list(vty, argc - idx, argv + idx, &ecom);
7016                 if (ret != CMD_SUCCESS)
7017                         return ret;
7018         }
7019
7020         if (yes) {
7021                 if (bgp->vpn_policy[afi].import_redirect_rtlist)
7022                         ecommunity_free(&bgp->vpn_policy[afi]
7023                                         .import_redirect_rtlist);
7024                 bgp->vpn_policy[afi].import_redirect_rtlist =
7025                         ecommunity_dup(ecom);
7026         } else {
7027                 if (bgp->vpn_policy[afi].import_redirect_rtlist)
7028                         ecommunity_free(&bgp->vpn_policy[afi]
7029                                         .import_redirect_rtlist);
7030                 bgp->vpn_policy[afi].import_redirect_rtlist = NULL;
7031         }
7032
7033         if (ecom)
7034                 ecommunity_free(&ecom);
7035
7036         return CMD_SUCCESS;
7037 }
7038
7039 DEFUN_NOSH (address_family_ipv4_safi,
7040         address_family_ipv4_safi_cmd,
7041         "address-family ipv4 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
7042         "Enter Address Family command mode\n"
7043         "Address Family\n"
7044         BGP_SAFI_WITH_LABEL_HELP_STR)
7045 {
7046
7047         if (argc == 3) {
7048                 VTY_DECLVAR_CONTEXT(bgp, bgp);
7049                 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
7050                 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
7051                     && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
7052                     && safi != SAFI_EVPN) {
7053                         vty_out(vty,
7054                                 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
7055                         return CMD_WARNING_CONFIG_FAILED;
7056                 }
7057                 vty->node = bgp_node_type(AFI_IP, safi);
7058         } else
7059                 vty->node = BGP_IPV4_NODE;
7060
7061         return CMD_SUCCESS;
7062 }
7063
7064 DEFUN_NOSH (address_family_ipv6_safi,
7065         address_family_ipv6_safi_cmd,
7066         "address-family ipv6 [<unicast|multicast|vpn|labeled-unicast|flowspec>]",
7067         "Enter Address Family command mode\n"
7068         "Address Family\n"
7069         BGP_SAFI_WITH_LABEL_HELP_STR)
7070 {
7071         if (argc == 3) {
7072                 VTY_DECLVAR_CONTEXT(bgp, bgp);
7073                 safi_t safi = bgp_vty_safi_from_str(argv[2]->text);
7074                 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT
7075                     && safi != SAFI_UNICAST && safi != SAFI_MULTICAST
7076                     && safi != SAFI_EVPN) {
7077                         vty_out(vty,
7078                                 "Only Unicast/Multicast/EVPN SAFIs supported in non-core instances.\n");
7079                         return CMD_WARNING_CONFIG_FAILED;
7080                 }
7081                 vty->node = bgp_node_type(AFI_IP6, safi);
7082         } else
7083                 vty->node = BGP_IPV6_NODE;
7084
7085         return CMD_SUCCESS;
7086 }
7087
7088 #ifdef KEEP_OLD_VPN_COMMANDS
7089 DEFUN_NOSH (address_family_vpnv4,
7090        address_family_vpnv4_cmd,
7091        "address-family vpnv4 [unicast]",
7092        "Enter Address Family command mode\n"
7093        "Address Family\n"
7094        "Address Family modifier\n")
7095 {
7096         vty->node = BGP_VPNV4_NODE;
7097         return CMD_SUCCESS;
7098 }
7099
7100 DEFUN_NOSH (address_family_vpnv6,
7101        address_family_vpnv6_cmd,
7102        "address-family vpnv6 [unicast]",
7103        "Enter Address Family command mode\n"
7104        "Address Family\n"
7105        "Address Family modifier\n")
7106 {
7107         vty->node = BGP_VPNV6_NODE;
7108         return CMD_SUCCESS;
7109 }
7110 #endif /* KEEP_OLD_VPN_COMMANDS */
7111
7112 DEFUN_NOSH (address_family_evpn,
7113        address_family_evpn_cmd,
7114        "address-family l2vpn evpn",
7115        "Enter Address Family command mode\n"
7116        "Address Family\n"
7117        "Address Family modifier\n")
7118 {
7119         VTY_DECLVAR_CONTEXT(bgp, bgp);
7120         vty->node = BGP_EVPN_NODE;
7121         return CMD_SUCCESS;
7122 }
7123
7124 DEFUN_NOSH (exit_address_family,
7125        exit_address_family_cmd,
7126        "exit-address-family",
7127        "Exit from Address Family configuration mode\n")
7128 {
7129         if (vty->node == BGP_IPV4_NODE || vty->node == BGP_IPV4M_NODE
7130             || vty->node == BGP_IPV4L_NODE || vty->node == BGP_VPNV4_NODE
7131             || vty->node == BGP_IPV6_NODE || vty->node == BGP_IPV6M_NODE
7132             || vty->node == BGP_IPV6L_NODE || vty->node == BGP_VPNV6_NODE
7133             || vty->node == BGP_EVPN_NODE
7134             || vty->node == BGP_FLOWSPECV4_NODE
7135             || vty->node == BGP_FLOWSPECV6_NODE)
7136                 vty->node = BGP_NODE;
7137         return CMD_SUCCESS;
7138 }
7139
7140 /* Recalculate bestpath and re-advertise a prefix */
7141 static int bgp_clear_prefix(struct vty *vty, const char *view_name,
7142                             const char *ip_str, afi_t afi, safi_t safi,
7143                             struct prefix_rd *prd)
7144 {
7145         int ret;
7146         struct prefix match;
7147         struct bgp_node *rn;
7148         struct bgp_node *rm;
7149         struct bgp *bgp;
7150         struct bgp_table *table;
7151         struct bgp_table *rib;
7152
7153         /* BGP structure lookup. */
7154         if (view_name) {
7155                 bgp = bgp_lookup_by_name(view_name);
7156                 if (bgp == NULL) {
7157                         vty_out(vty, "%% Can't find BGP instance %s\n",
7158                                 view_name);
7159                         return CMD_WARNING;
7160                 }
7161         } else {
7162                 bgp = bgp_get_default();
7163                 if (bgp == NULL) {
7164                         vty_out(vty, "%% No BGP process is configured\n");
7165                         return CMD_WARNING;
7166                 }
7167         }
7168
7169         /* Check IP address argument. */
7170         ret = str2prefix(ip_str, &match);
7171         if (!ret) {
7172                 vty_out(vty, "%% address is malformed\n");
7173                 return CMD_WARNING;
7174         }
7175
7176         match.family = afi2family(afi);
7177         rib = bgp->rib[afi][safi];
7178
7179         if (safi == SAFI_MPLS_VPN) {
7180                 for (rn = bgp_table_top(rib); rn; rn = bgp_route_next(rn)) {
7181                         if (prd && memcmp(rn->p.u.val, prd->val, 8) != 0)
7182                                 continue;
7183
7184                         table = bgp_node_get_bgp_table_info(rn);
7185                         if (table != NULL) {
7186
7187                                 if ((rm = bgp_node_match(table, &match))
7188                                     != NULL) {
7189                                         if (rm->p.prefixlen
7190                                             == match.prefixlen) {
7191                                                 SET_FLAG(rm->flags,
7192                                                          BGP_NODE_USER_CLEAR);
7193                                                 bgp_process(bgp, rm, afi, safi);
7194                                         }
7195                                         bgp_unlock_node(rm);
7196                                 }
7197                         }
7198                 }
7199         } else {
7200                 if ((rn = bgp_node_match(rib, &match)) != NULL) {
7201                         if (rn->p.prefixlen == match.prefixlen) {
7202                                 SET_FLAG(rn->flags, BGP_NODE_USER_CLEAR);
7203                                 bgp_process(bgp, rn, afi, safi);
7204                         }
7205                         bgp_unlock_node(rn);
7206                 }
7207         }
7208
7209         return CMD_SUCCESS;
7210 }
7211
7212 /* one clear bgp command to rule them all */
7213 DEFUN (clear_ip_bgp_all,
7214        clear_ip_bgp_all_cmd,
7215        "clear [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6|l2vpn> [<unicast|multicast|vpn|labeled-unicast|flowspec|evpn>]] <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group PGNAME> [<soft [<in|out>]|in [prefix-filter]|out>]",
7216        CLEAR_STR
7217        IP_STR
7218        BGP_STR
7219        BGP_INSTANCE_HELP_STR
7220        BGP_AFI_HELP_STR
7221        "Address Family\n"
7222        BGP_SAFI_WITH_LABEL_HELP_STR
7223        "Address Family modifier\n"
7224        "Clear all peers\n"
7225        "BGP neighbor address to clear\n"
7226        "BGP IPv6 neighbor to clear\n"
7227        "BGP neighbor on interface to clear\n"
7228        "Clear peers with the AS number\n"
7229        "Clear all external peers\n"
7230        "Clear all members of peer-group\n"
7231        "BGP peer-group name\n"
7232        BGP_SOFT_STR
7233        BGP_SOFT_IN_STR
7234        BGP_SOFT_OUT_STR
7235        BGP_SOFT_IN_STR
7236        "Push out prefix-list ORF and do inbound soft reconfig\n"
7237        BGP_SOFT_OUT_STR)
7238 {
7239         char *vrf = NULL;
7240
7241         afi_t afi = AFI_IP6;
7242         safi_t safi = SAFI_UNICAST;
7243         enum clear_sort clr_sort = clear_peer;
7244         enum bgp_clear_type clr_type;
7245         char *clr_arg = NULL;
7246
7247         int idx = 0;
7248
7249         /* clear [ip] bgp */
7250         if (argv_find(argv, argc, "ip", &idx))
7251                 afi = AFI_IP;
7252
7253         /* [<vrf> VIEWVRFNAME] */
7254         if (argv_find(argv, argc, "vrf", &idx)) {
7255                 vrf = argv[idx + 1]->arg;
7256                 idx += 2;
7257                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
7258                         vrf = NULL;
7259         } else if (argv_find(argv, argc, "view", &idx)) {
7260                 /* [<view> VIEWVRFNAME] */
7261                 vrf = argv[idx + 1]->arg;
7262                 idx += 2;
7263         }
7264         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
7265         if (argv_find_and_parse_afi(argv, argc, &idx, &afi))
7266                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
7267
7268         /* <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group PGNAME> */
7269         if (argv_find(argv, argc, "*", &idx)) {
7270                 clr_sort = clear_all;
7271         } else if (argv_find(argv, argc, "A.B.C.D", &idx)) {
7272                 clr_sort = clear_peer;
7273                 clr_arg = argv[idx]->arg;
7274         } else if (argv_find(argv, argc, "X:X::X:X", &idx)) {
7275                 clr_sort = clear_peer;
7276                 clr_arg = argv[idx]->arg;
7277         } else if (argv_find(argv, argc, "peer-group", &idx)) {
7278                 clr_sort = clear_group;
7279                 idx++;
7280                 clr_arg = argv[idx]->arg;
7281         } else if (argv_find(argv, argc, "PGNAME", &idx)) {
7282                 clr_sort = clear_peer;
7283                 clr_arg = argv[idx]->arg;
7284         } else if (argv_find(argv, argc, "WORD", &idx)) {
7285                 clr_sort = clear_peer;
7286                 clr_arg = argv[idx]->arg;
7287         } else if (argv_find(argv, argc, "(1-4294967295)", &idx)) {
7288                 clr_sort = clear_as;
7289                 clr_arg = argv[idx]->arg;
7290         } else if (argv_find(argv, argc, "external", &idx)) {
7291                 clr_sort = clear_external;
7292         }
7293
7294         /* [<soft [<in|out>]|in [prefix-filter]|out>] */
7295         if (argv_find(argv, argc, "soft", &idx)) {
7296                 if (argv_find(argv, argc, "in", &idx)
7297                     || argv_find(argv, argc, "out", &idx))
7298                         clr_type = strmatch(argv[idx]->text, "in")
7299                                            ? BGP_CLEAR_SOFT_IN
7300                                            : BGP_CLEAR_SOFT_OUT;
7301                 else
7302                         clr_type = BGP_CLEAR_SOFT_BOTH;
7303         } else if (argv_find(argv, argc, "in", &idx)) {
7304                 clr_type = argv_find(argv, argc, "prefix-filter", &idx)
7305                                    ? BGP_CLEAR_SOFT_IN_ORF_PREFIX
7306                                    : BGP_CLEAR_SOFT_IN;
7307         } else if (argv_find(argv, argc, "out", &idx)) {
7308                 clr_type = BGP_CLEAR_SOFT_OUT;
7309         } else
7310                 clr_type = BGP_CLEAR_SOFT_NONE;
7311
7312         return bgp_clear_vty(vty, vrf, afi, safi, clr_sort, clr_type, clr_arg);
7313 }
7314
7315 DEFUN (clear_ip_bgp_prefix,
7316        clear_ip_bgp_prefix_cmd,
7317        "clear [ip] bgp [<view|vrf> VIEWVRFNAME] prefix A.B.C.D/M",
7318        CLEAR_STR
7319        IP_STR
7320        BGP_STR
7321        BGP_INSTANCE_HELP_STR
7322        "Clear bestpath and re-advertise\n"
7323        "IPv4 prefix\n")
7324 {
7325         char *vrf = NULL;
7326         char *prefix = NULL;
7327
7328         int idx = 0;
7329
7330         /* [<view|vrf> VIEWVRFNAME] */
7331         if (argv_find(argv, argc, "vrf", &idx)) {
7332                 vrf = argv[idx + 1]->arg;
7333                 idx += 2;
7334                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
7335                         vrf = NULL;
7336         } else if (argv_find(argv, argc, "view", &idx)) {
7337                 /* [<view> VIEWVRFNAME] */
7338                 vrf = argv[idx + 1]->arg;
7339                 idx += 2;
7340         }
7341
7342         prefix = argv[argc - 1]->arg;
7343
7344         return bgp_clear_prefix(vty, vrf, prefix, AFI_IP, SAFI_UNICAST, NULL);
7345 }
7346
7347 DEFUN (clear_bgp_ipv6_safi_prefix,
7348        clear_bgp_ipv6_safi_prefix_cmd,
7349        "clear [ip] bgp ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
7350        CLEAR_STR
7351        IP_STR
7352        BGP_STR
7353        "Address Family\n"
7354        BGP_SAFI_HELP_STR
7355        "Clear bestpath and re-advertise\n"
7356        "IPv6 prefix\n")
7357 {
7358         int idx_safi = 0;
7359         int idx_ipv6_prefix = 0;
7360         safi_t safi = SAFI_UNICAST;
7361         char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
7362                 argv[idx_ipv6_prefix]->arg : NULL;
7363
7364         argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
7365         return bgp_clear_prefix(
7366                 vty, NULL, prefix, AFI_IP6,
7367                 safi, NULL);
7368 }
7369
7370 DEFUN (clear_bgp_instance_ipv6_safi_prefix,
7371        clear_bgp_instance_ipv6_safi_prefix_cmd,
7372        "clear [ip] bgp <view|vrf> VIEWVRFNAME ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
7373        CLEAR_STR
7374        IP_STR
7375        BGP_STR
7376        BGP_INSTANCE_HELP_STR
7377        "Address Family\n"
7378        BGP_SAFI_HELP_STR
7379        "Clear bestpath and re-advertise\n"
7380        "IPv6 prefix\n")
7381 {
7382         int idx_safi = 0;
7383         int idx_vrfview = 0;
7384         int idx_ipv6_prefix = 0;
7385         safi_t safi = SAFI_UNICAST;
7386         char *prefix = argv_find(argv, argc, "X:X::X:X/M", &idx_ipv6_prefix) ?
7387                 argv[idx_ipv6_prefix]->arg : NULL;
7388         char *vrfview = NULL;
7389
7390         /* [<view|vrf> VIEWVRFNAME] */
7391         if (argv_find(argv, argc, "vrf", &idx_vrfview)) {
7392                 vrfview = argv[idx_vrfview + 1]->arg;
7393                 if (vrfview && strmatch(vrfview, VRF_DEFAULT_NAME))
7394                         vrfview = NULL;
7395         } else if (argv_find(argv, argc, "view", &idx_vrfview)) {
7396                 /* [<view> VIEWVRFNAME] */
7397                 vrfview = argv[idx_vrfview + 1]->arg;
7398         }
7399         argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
7400
7401         return bgp_clear_prefix(
7402                 vty, vrfview, prefix,
7403                 AFI_IP6, safi, NULL);
7404 }
7405
7406 DEFUN (show_bgp_views,
7407        show_bgp_views_cmd,
7408        "show [ip] bgp views",
7409        SHOW_STR
7410        IP_STR
7411        BGP_STR
7412        "Show the defined BGP views\n")
7413 {
7414         struct list *inst = bm->bgp;
7415         struct listnode *node;
7416         struct bgp *bgp;
7417
7418         vty_out(vty, "Defined BGP views:\n");
7419         for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
7420                 /* Skip VRFs. */
7421                 if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
7422                         continue;
7423                 vty_out(vty, "\t%s (AS%u)\n", bgp->name ? bgp->name : "(null)",
7424                         bgp->as);
7425         }
7426
7427         return CMD_SUCCESS;
7428 }
7429
7430 DEFUN (show_bgp_vrfs,
7431        show_bgp_vrfs_cmd,
7432        "show [ip] bgp vrfs [json]",
7433        SHOW_STR
7434        IP_STR
7435        BGP_STR
7436        "Show BGP VRFs\n"
7437        JSON_STR)
7438 {
7439         char buf[ETHER_ADDR_STRLEN];
7440         struct list *inst = bm->bgp;
7441         struct listnode *node;
7442         struct bgp *bgp;
7443         bool uj = use_json(argc, argv);
7444         json_object *json = NULL;
7445         json_object *json_vrfs = NULL;
7446         int count = 0;
7447
7448         if (uj) {
7449                 json = json_object_new_object();
7450                 json_vrfs = json_object_new_object();
7451         }
7452
7453         for (ALL_LIST_ELEMENTS_RO(inst, node, bgp)) {
7454                 const char *name, *type;
7455                 struct peer *peer;
7456                 struct listnode *node2, *nnode2;
7457                 int peers_cfg, peers_estb;
7458                 json_object *json_vrf = NULL;
7459
7460                 /* Skip Views. */
7461                 if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
7462                         continue;
7463
7464                 count++;
7465                 if (!uj && count == 1) {
7466                         vty_out(vty,
7467                                 "%4s  %-5s  %-16s  %9s  %10s  %-37s\n",
7468                                 "Type", "Id", "routerId", "#PeersVfg",
7469                                 "#PeersEstb", "Name");
7470                         vty_out(vty, "%11s  %-16s  %-21s  %-6s\n", " ",
7471                                 "L3-VNI", "RouterMAC", "Interface");
7472                 }
7473
7474                 peers_cfg = peers_estb = 0;
7475                 if (uj)
7476                         json_vrf = json_object_new_object();
7477
7478
7479                 for (ALL_LIST_ELEMENTS(bgp->peer, node2, nnode2, peer)) {
7480                         if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7481                                 continue;
7482                         peers_cfg++;
7483                         if (peer->status == Established)
7484                                 peers_estb++;
7485                 }
7486
7487                 if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
7488                         name = VRF_DEFAULT_NAME;
7489                         type = "DFLT";
7490                 } else {
7491                         name = bgp->name;
7492                         type = "VRF";
7493                 }
7494
7495
7496                 if (uj) {
7497                         int64_t vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
7498                                                     ? -1
7499                                                     : (int64_t)bgp->vrf_id;
7500                         json_object_string_add(json_vrf, "type", type);
7501                         json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
7502                         json_object_string_add(json_vrf, "routerId",
7503                                                inet_ntoa(bgp->router_id));
7504                         json_object_int_add(json_vrf, "numConfiguredPeers",
7505                                             peers_cfg);
7506                         json_object_int_add(json_vrf, "numEstablishedPeers",
7507                                             peers_estb);
7508
7509                         json_object_int_add(json_vrf, "l3vni", bgp->l3vni);
7510                         json_object_string_add(
7511                                 json_vrf, "rmac",
7512                                 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
7513                         json_object_string_add(json_vrf, "interface",
7514                                 ifindex2ifname(bgp->l3vni_svi_ifindex,
7515                                                bgp->vrf_id));
7516                         json_object_object_add(json_vrfs, name, json_vrf);
7517                 } else {
7518                         vty_out(vty,
7519                                 "%4s  %-5d  %-16s  %-9u  %-10u  %-37s\n",
7520                                 type,
7521                                 bgp->vrf_id == VRF_UNKNOWN ? -1
7522                                                            : (int)bgp->vrf_id,
7523                                 inet_ntoa(bgp->router_id), peers_cfg,
7524                                 peers_estb, name);
7525                         vty_out(vty,"%11s  %-16u  %-21s  %-20s\n", " ",
7526                                 bgp->l3vni,
7527                                 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)),
7528                                 ifindex2ifname(bgp->l3vni_svi_ifindex,
7529                                                bgp->vrf_id));
7530                 }
7531         }
7532
7533         if (uj) {
7534                 json_object_object_add(json, "vrfs", json_vrfs);
7535
7536                 json_object_int_add(json, "totalVrfs", count);
7537
7538                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
7539                                              json, JSON_C_TO_STRING_PRETTY));
7540                 json_object_free(json);
7541         } else {
7542                 if (count)
7543                         vty_out(vty,
7544                                 "\nTotal number of VRFs (including default): %d\n",
7545                                 count);
7546         }
7547
7548         return CMD_SUCCESS;
7549 }
7550
7551 DEFUN (show_bgp_mac_hash,
7552        show_bgp_mac_hash_cmd,
7553        "show bgp mac hash",
7554        SHOW_STR
7555        BGP_STR
7556        "Mac Address\n"
7557        "Mac Address database\n")
7558 {
7559         bgp_mac_dump_table(vty);
7560
7561         return CMD_SUCCESS;
7562 }
7563
7564 static void show_tip_entry(struct hash_bucket *bucket, void *args)
7565 {
7566         struct vty *vty = (struct vty *)args;
7567         struct tip_addr *tip = (struct tip_addr *)bucket->data;
7568
7569         vty_out(vty, "addr: %s, count: %d\n", inet_ntoa(tip->addr),
7570                 tip->refcnt);
7571 }
7572
7573 static void bgp_show_martian_nexthops(struct vty *vty, struct bgp *bgp)
7574 {
7575         vty_out(vty, "self nexthop database:\n");
7576         bgp_nexthop_show_address_hash(vty, bgp);
7577
7578         vty_out(vty, "Tunnel-ip database:\n");
7579         hash_iterate(bgp->tip_hash,
7580                      (void (*)(struct hash_bucket *, void *))show_tip_entry,
7581                      vty);
7582 }
7583
7584 DEFUN(show_bgp_martian_nexthop_db, show_bgp_martian_nexthop_db_cmd,
7585       "show bgp [<view|vrf> VIEWVRFNAME] martian next-hop",
7586       SHOW_STR BGP_STR BGP_INSTANCE_HELP_STR
7587       "martian next-hops\n"
7588       "martian next-hop database\n")
7589 {
7590         struct bgp *bgp = NULL;
7591         int idx = 0;
7592         char *name = NULL;
7593
7594         /* [<vrf> VIEWVRFNAME] */
7595         if (argv_find(argv, argc, "vrf", &idx)) {
7596                 name = argv[idx + 1]->arg;
7597                 if (name && strmatch(name, VRF_DEFAULT_NAME))
7598                         name = NULL;
7599         } else if (argv_find(argv, argc, "view", &idx))
7600                 /* [<view> VIEWVRFNAME] */
7601                 name = argv[idx + 1]->arg;
7602         if (name)
7603                 bgp = bgp_lookup_by_name(name);
7604         else
7605                 bgp = bgp_get_default();
7606
7607         if (!bgp) {
7608                 vty_out(vty, "%% No BGP process is configured\n");
7609                 return CMD_WARNING;
7610         }
7611         bgp_show_martian_nexthops(vty, bgp);
7612
7613         return CMD_SUCCESS;
7614 }
7615
7616 DEFUN (show_bgp_memory,
7617        show_bgp_memory_cmd,
7618        "show [ip] bgp memory",
7619        SHOW_STR
7620        IP_STR
7621        BGP_STR
7622        "Global BGP memory statistics\n")
7623 {
7624         char memstrbuf[MTYPE_MEMSTR_LEN];
7625         unsigned long count;
7626
7627         /* RIB related usage stats */
7628         count = mtype_stats_alloc(MTYPE_BGP_NODE);
7629         vty_out(vty, "%ld RIB nodes, using %s of memory\n", count,
7630                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7631                              count * sizeof(struct bgp_node)));
7632
7633         count = mtype_stats_alloc(MTYPE_BGP_ROUTE);
7634         vty_out(vty, "%ld BGP routes, using %s of memory\n", count,
7635                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7636                              count * sizeof(struct bgp_path_info)));
7637         if ((count = mtype_stats_alloc(MTYPE_BGP_ROUTE_EXTRA)))
7638                 vty_out(vty, "%ld BGP route ancillaries, using %s of memory\n",
7639                         count,
7640                         mtype_memstr(
7641                                 memstrbuf, sizeof(memstrbuf),
7642                                 count * sizeof(struct bgp_path_info_extra)));
7643
7644         if ((count = mtype_stats_alloc(MTYPE_BGP_STATIC)))
7645                 vty_out(vty, "%ld Static routes, using %s of memory\n", count,
7646                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7647                                      count * sizeof(struct bgp_static)));
7648
7649         if ((count = mtype_stats_alloc(MTYPE_BGP_PACKET)))
7650                 vty_out(vty, "%ld Packets, using %s of memory\n", count,
7651                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7652                                      count * sizeof(struct bpacket)));
7653
7654         /* Adj-In/Out */
7655         if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_IN)))
7656                 vty_out(vty, "%ld Adj-In entries, using %s of memory\n", count,
7657                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7658                                      count * sizeof(struct bgp_adj_in)));
7659         if ((count = mtype_stats_alloc(MTYPE_BGP_ADJ_OUT)))
7660                 vty_out(vty, "%ld Adj-Out entries, using %s of memory\n", count,
7661                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7662                                      count * sizeof(struct bgp_adj_out)));
7663
7664         if ((count = mtype_stats_alloc(MTYPE_BGP_NEXTHOP_CACHE)))
7665                 vty_out(vty, "%ld Nexthop cache entries, using %s of memory\n",
7666                         count,
7667                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7668                                      count * sizeof(struct bgp_nexthop_cache)));
7669
7670         if ((count = mtype_stats_alloc(MTYPE_BGP_DAMP_INFO)))
7671                 vty_out(vty, "%ld Dampening entries, using %s of memory\n",
7672                         count,
7673                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7674                                      count * sizeof(struct bgp_damp_info)));
7675
7676         /* Attributes */
7677         count = attr_count();
7678         vty_out(vty, "%ld BGP attributes, using %s of memory\n", count,
7679                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7680                              count * sizeof(struct attr)));
7681
7682         if ((count = attr_unknown_count()))
7683                 vty_out(vty, "%ld unknown attributes\n", count);
7684
7685         /* AS_PATH attributes */
7686         count = aspath_count();
7687         vty_out(vty, "%ld BGP AS-PATH entries, using %s of memory\n", count,
7688                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7689                              count * sizeof(struct aspath)));
7690
7691         count = mtype_stats_alloc(MTYPE_AS_SEG);
7692         vty_out(vty, "%ld BGP AS-PATH segments, using %s of memory\n", count,
7693                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7694                              count * sizeof(struct assegment)));
7695
7696         /* Other attributes */
7697         if ((count = community_count()))
7698                 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
7699                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7700                                             count * sizeof(struct community)));
7701         if ((count = mtype_stats_alloc(MTYPE_ECOMMUNITY)))
7702                 vty_out(vty, "%ld BGP community entries, using %s of memory\n",
7703                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7704                                             count * sizeof(struct ecommunity)));
7705         if ((count = mtype_stats_alloc(MTYPE_LCOMMUNITY)))
7706                 vty_out(vty,
7707                         "%ld BGP large-community entries, using %s of memory\n",
7708                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7709                                             count * sizeof(struct lcommunity)));
7710
7711         if ((count = mtype_stats_alloc(MTYPE_CLUSTER)))
7712                 vty_out(vty, "%ld Cluster lists, using %s of memory\n", count,
7713                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7714                                      count * sizeof(struct cluster_list)));
7715
7716         /* Peer related usage */
7717         count = mtype_stats_alloc(MTYPE_BGP_PEER);
7718         vty_out(vty, "%ld peers, using %s of memory\n", count,
7719                 mtype_memstr(memstrbuf, sizeof(memstrbuf),
7720                              count * sizeof(struct peer)));
7721
7722         if ((count = mtype_stats_alloc(MTYPE_PEER_GROUP)))
7723                 vty_out(vty, "%ld peer groups, using %s of memory\n", count,
7724                         mtype_memstr(memstrbuf, sizeof(memstrbuf),
7725                                      count * sizeof(struct peer_group)));
7726
7727         /* Other */
7728         if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
7729                 vty_out(vty, "%ld compiled regexes, using %s of memory\n",
7730                         count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
7731                                             count * sizeof(regex_t)));
7732         return CMD_SUCCESS;
7733 }
7734
7735 static void bgp_show_bestpath_json(struct bgp *bgp, json_object *json)
7736 {
7737         json_object *bestpath = json_object_new_object();
7738
7739         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_IGNORE))
7740                 json_object_string_add(bestpath, "asPath", "ignore");
7741
7742         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_CONFED))
7743                 json_object_string_add(bestpath, "asPath", "confed");
7744
7745         if (bgp_flag_check(bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
7746                 if (bgp_flag_check(bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET))
7747                         json_object_string_add(bestpath, "multiPathRelax",
7748                                                "as-set");
7749                 else
7750                         json_object_string_add(bestpath, "multiPathRelax",
7751                                                "true");
7752         } else
7753                 json_object_string_add(bestpath, "multiPathRelax", "false");
7754
7755         if (bgp_flag_check(bgp, BGP_FLAG_COMPARE_ROUTER_ID))
7756                 json_object_string_add(bestpath, "compareRouterId", "true");
7757         if (bgp_flag_check(bgp, BGP_FLAG_MED_CONFED)
7758             || bgp_flag_check(bgp, BGP_FLAG_MED_MISSING_AS_WORST)) {
7759                 if (bgp_flag_check(bgp, BGP_FLAG_MED_CONFED))
7760                         json_object_string_add(bestpath, "med", "confed");
7761                 if (bgp_flag_check(bgp, BGP_FLAG_MED_MISSING_AS_WORST))
7762                         json_object_string_add(bestpath, "med",
7763                                                "missing-as-worst");
7764                 else
7765                         json_object_string_add(bestpath, "med", "true");
7766         }
7767
7768         json_object_object_add(json, "bestPath", bestpath);
7769 }
7770
7771 /* Show BGP peer's summary information. */
7772 static int bgp_show_summary(struct vty *vty, struct bgp *bgp, int afi, int safi,
7773                             bool use_json)
7774 {
7775         struct peer *peer;
7776         struct listnode *node, *nnode;
7777         unsigned int count = 0, dn_count = 0;
7778         char timebuf[BGP_UPTIME_LEN], dn_flag[2];
7779         char neighbor_buf[VTY_BUFSIZ];
7780         int neighbor_col_default_width = 16;
7781         int len;
7782         int max_neighbor_width = 0;
7783         int pfx_rcd_safi;
7784         json_object *json = NULL;
7785         json_object *json_peer = NULL;
7786         json_object *json_peers = NULL;
7787         struct peer_af *paf;
7788
7789         /* labeled-unicast routes are installed in the unicast table so in order
7790          * to
7791          * display the correct PfxRcd value we must look at SAFI_UNICAST
7792          */
7793         if (safi == SAFI_LABELED_UNICAST)
7794                 pfx_rcd_safi = SAFI_UNICAST;
7795         else
7796                 pfx_rcd_safi = safi;
7797
7798         if (use_json) {
7799                 json = json_object_new_object();
7800                 json_peers = json_object_new_object();
7801         } else {
7802                 /* Loop over all neighbors that will be displayed to determine
7803                  * how many
7804                  * characters are needed for the Neighbor column
7805                  */
7806                 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
7807                         if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7808                                 continue;
7809
7810                         if (peer->afc[afi][safi]) {
7811                                 memset(dn_flag, '\0', sizeof(dn_flag));
7812                                 if (peer_dynamic_neighbor(peer))
7813                                         dn_flag[0] = '*';
7814
7815                                 if (peer->hostname
7816                                     && bgp_flag_check(bgp,
7817                                                       BGP_FLAG_SHOW_HOSTNAME))
7818                                         sprintf(neighbor_buf, "%s%s(%s) ",
7819                                                 dn_flag, peer->hostname,
7820                                                 peer->host);
7821                                 else
7822                                         sprintf(neighbor_buf, "%s%s ", dn_flag,
7823                                                 peer->host);
7824
7825                                 len = strlen(neighbor_buf);
7826
7827                                 if (len > max_neighbor_width)
7828                                         max_neighbor_width = len;
7829                         }
7830                 }
7831
7832                 /* Originally we displayed the Neighbor column as 16
7833                  * characters wide so make that the default
7834                  */
7835                 if (max_neighbor_width < neighbor_col_default_width)
7836                         max_neighbor_width = neighbor_col_default_width;
7837         }
7838
7839         for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
7840                 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
7841                         continue;
7842
7843                 if (!peer->afc[afi][safi])
7844                         continue;
7845
7846                 if (!count) {
7847                         unsigned long ents;
7848                         char memstrbuf[MTYPE_MEMSTR_LEN];
7849                         int64_t vrf_id_ui;
7850
7851                         vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN)
7852                                             ? -1
7853                                             : (int64_t)bgp->vrf_id;
7854
7855                         /* Usage summary and header */
7856                         if (use_json) {
7857                                 json_object_string_add(
7858                                         json, "routerId",
7859                                         inet_ntoa(bgp->router_id));
7860                                 json_object_int_add(json, "as", bgp->as);
7861                                 json_object_int_add(json, "vrfId", vrf_id_ui);
7862                                 json_object_string_add(
7863                                         json, "vrfName",
7864                                         (bgp->inst_type
7865                                          == BGP_INSTANCE_TYPE_DEFAULT)
7866                                                 ? VRF_DEFAULT_NAME
7867                                                 : bgp->name);
7868                         } else {
7869                                 vty_out(vty,
7870                                         "BGP router identifier %s, local AS number %u vrf-id %d",
7871                                         inet_ntoa(bgp->router_id), bgp->as,
7872                                         bgp->vrf_id == VRF_UNKNOWN
7873                                                 ? -1
7874                                                 : (int)bgp->vrf_id);
7875                                 vty_out(vty, "\n");
7876                         }
7877
7878                         if (bgp_update_delay_configured(bgp)) {
7879                                 if (use_json) {
7880                                         json_object_int_add(
7881                                                 json, "updateDelayLimit",
7882                                                 bgp->v_update_delay);
7883
7884                                         if (bgp->v_update_delay
7885                                             != bgp->v_establish_wait)
7886                                                 json_object_int_add(
7887                                                         json,
7888                                                         "updateDelayEstablishWait",
7889                                                         bgp->v_establish_wait);
7890
7891                                         if (bgp_update_delay_active(bgp)) {
7892                                                 json_object_string_add(
7893                                                         json,
7894                                                         "updateDelayFirstNeighbor",
7895                                                         bgp->update_delay_begin_time);
7896                                                 json_object_boolean_true_add(
7897                                                         json,
7898                                                         "updateDelayInProgress");
7899                                         } else {
7900                                                 if (bgp->update_delay_over) {
7901                                                         json_object_string_add(
7902                                                                 json,
7903                                                                 "updateDelayFirstNeighbor",
7904                                                                 bgp->update_delay_begin_time);
7905                                                         json_object_string_add(
7906                                                                 json,
7907                                                                 "updateDelayBestpathResumed",
7908                                                                 bgp->update_delay_end_time);
7909                                                         json_object_string_add(
7910                                                                 json,
7911                                                                 "updateDelayZebraUpdateResume",
7912                                                                 bgp->update_delay_zebra_resume_time);
7913                                                         json_object_string_add(
7914                                                                 json,
7915                                                                 "updateDelayPeerUpdateResume",
7916                                                                 bgp->update_delay_peers_resume_time);
7917                                                 }
7918                                         }
7919                                 } else {
7920                                         vty_out(vty,
7921                                                 "Read-only mode update-delay limit: %d seconds\n",
7922                                                 bgp->v_update_delay);
7923                                         if (bgp->v_update_delay
7924                                             != bgp->v_establish_wait)
7925                                                 vty_out(vty,
7926                                                         "                   Establish wait: %d seconds\n",
7927                                                         bgp->v_establish_wait);
7928
7929                                         if (bgp_update_delay_active(bgp)) {
7930                                                 vty_out(vty,
7931                                                         "  First neighbor established: %s\n",
7932                                                         bgp->update_delay_begin_time);
7933                                                 vty_out(vty,
7934                                                         "  Delay in progress\n");
7935                                         } else {
7936                                                 if (bgp->update_delay_over) {
7937                                                         vty_out(vty,
7938                                                                 "  First neighbor established: %s\n",
7939                                                                 bgp->update_delay_begin_time);
7940                                                         vty_out(vty,
7941                                                                 "          Best-paths resumed: %s\n",
7942                                                                 bgp->update_delay_end_time);
7943                                                         vty_out(vty,
7944                                                                 "        zebra update resumed: %s\n",
7945                                                                 bgp->update_delay_zebra_resume_time);
7946                                                         vty_out(vty,
7947                                                                 "        peers update resumed: %s\n",
7948                                                                 bgp->update_delay_peers_resume_time);
7949                                                 }
7950                                         }
7951                                 }
7952                         }
7953
7954                         if (use_json) {
7955                                 if (bgp_maxmed_onstartup_configured(bgp)
7956                                     && bgp->maxmed_active)
7957                                         json_object_boolean_true_add(
7958                                                 json, "maxMedOnStartup");
7959                                 if (bgp->v_maxmed_admin)
7960                                         json_object_boolean_true_add(
7961                                                 json, "maxMedAdministrative");
7962
7963                                 json_object_int_add(
7964                                         json, "tableVersion",
7965                                         bgp_table_version(bgp->rib[afi][safi]));
7966
7967                                 ents = bgp_table_count(bgp->rib[afi][safi]);
7968                                 json_object_int_add(json, "ribCount", ents);
7969                                 json_object_int_add(
7970                                         json, "ribMemory",
7971                                         ents * sizeof(struct bgp_node));
7972
7973                                 ents = bgp->af_peer_count[afi][safi];
7974                                 json_object_int_add(json, "peerCount", ents);
7975                                 json_object_int_add(json, "peerMemory",
7976                                                     ents * sizeof(struct peer));
7977
7978                                 if ((ents = listcount(bgp->group))) {
7979                                         json_object_int_add(
7980                                                 json, "peerGroupCount", ents);
7981                                         json_object_int_add(
7982                                                 json, "peerGroupMemory",
7983                                                 ents * sizeof(struct
7984                                                               peer_group));
7985                                 }
7986
7987                                 if (CHECK_FLAG(bgp->af_flags[afi][safi],
7988                                                BGP_CONFIG_DAMPENING))
7989                                         json_object_boolean_true_add(
7990                                                 json, "dampeningEnabled");
7991                         } else {
7992                                 if (bgp_maxmed_onstartup_configured(bgp)
7993                                     && bgp->maxmed_active)
7994                                         vty_out(vty,
7995                                                 "Max-med on-startup active\n");
7996                                 if (bgp->v_maxmed_admin)
7997                                         vty_out(vty,
7998                                                 "Max-med administrative active\n");
7999
8000                                 vty_out(vty, "BGP table version %" PRIu64 "\n",
8001                                         bgp_table_version(bgp->rib[afi][safi]));
8002
8003                                 ents = bgp_table_count(bgp->rib[afi][safi]);
8004                                 vty_out(vty,
8005                                         "RIB entries %ld, using %s of memory\n",
8006                                         ents,
8007                                         mtype_memstr(memstrbuf,
8008                                                      sizeof(memstrbuf),
8009                                                      ents * sizeof(struct
8010                                                                    bgp_node)));
8011
8012                                 /* Peer related usage */
8013                                 ents = bgp->af_peer_count[afi][safi];
8014                                 vty_out(vty, "Peers %ld, using %s of memory\n",
8015                                         ents,
8016                                         mtype_memstr(
8017                                                 memstrbuf, sizeof(memstrbuf),
8018                                                 ents * sizeof(struct peer)));
8019
8020                                 if ((ents = listcount(bgp->group)))
8021                                         vty_out(vty,
8022                                                 "Peer groups %ld, using %s of memory\n",
8023                                                 ents,
8024                                                 mtype_memstr(
8025                                                         memstrbuf,
8026                                                         sizeof(memstrbuf),
8027                                                         ents * sizeof(struct
8028                                                                       peer_group)));
8029
8030                                 if (CHECK_FLAG(bgp->af_flags[afi][safi],
8031                                                BGP_CONFIG_DAMPENING))
8032                                         vty_out(vty, "Dampening enabled.\n");
8033                                 vty_out(vty, "\n");
8034
8035                                 /* Subtract 8 here because 'Neighbor' is
8036                                  * 8 characters */
8037                                 vty_out(vty, "Neighbor");
8038                                 vty_out(vty, "%*s", max_neighbor_width - 8,
8039                                         " ");
8040                                 vty_out(vty,
8041                                         "V         AS MsgRcvd MsgSent   TblVer  InQ OutQ  Up/Down State/PfxRcd\n");
8042                         }
8043                 }
8044
8045                 count++;
8046
8047                 if (use_json) {
8048                         json_peer = json_object_new_object();
8049
8050                         if (peer_dynamic_neighbor(peer)) {
8051                                 dn_count++;
8052                                 json_object_boolean_true_add(json_peer,
8053                                                              "dynamicPeer");
8054                         }
8055
8056                         if (peer->hostname)
8057                                 json_object_string_add(json_peer, "hostname",
8058                                                        peer->hostname);
8059
8060                         if (peer->domainname)
8061                                 json_object_string_add(json_peer, "domainname",
8062                                                        peer->domainname);
8063
8064                         json_object_int_add(json_peer, "remoteAs", peer->as);
8065                         json_object_int_add(json_peer, "version", 4);
8066                         json_object_int_add(json_peer, "msgRcvd",
8067                                             PEER_TOTAL_RX(peer));
8068                         json_object_int_add(json_peer, "msgSent",
8069                                             PEER_TOTAL_TX(peer));
8070
8071                         json_object_int_add(json_peer, "tableVersion",
8072                                             peer->version[afi][safi]);
8073                         json_object_int_add(json_peer, "outq",
8074                                             peer->obuf->count);
8075                         json_object_int_add(json_peer, "inq", 0);
8076                         peer_uptime(peer->uptime, timebuf, BGP_UPTIME_LEN,
8077                                     use_json, json_peer);
8078
8079                         /*
8080                          * Adding "pfxRcd" field to match with the corresponding
8081                          * CLI. "prefixReceivedCount" will be deprecated in
8082                          * future.
8083                          */
8084                         json_object_int_add(json_peer, "prefixReceivedCount",
8085                                             peer->pcount[afi][pfx_rcd_safi]);
8086                         json_object_int_add(json_peer, "pfxRcd",
8087                                         peer->pcount[afi][pfx_rcd_safi]);
8088
8089                         paf = peer_af_find(peer, afi, pfx_rcd_safi);
8090                         if (paf && PAF_SUBGRP(paf))
8091                                 json_object_int_add(json_peer,
8092                                                 "pfxSnt",
8093                                                 (PAF_SUBGRP(paf))->scount);
8094
8095                         if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
8096                                 json_object_string_add(json_peer, "state",
8097                                                        "Idle (Admin)");
8098                         else if (peer->afc_recv[afi][safi])
8099                                 json_object_string_add(
8100                                         json_peer, "state",
8101                                         lookup_msg(bgp_status_msg, peer->status,
8102                                                    NULL));
8103                         else if (CHECK_FLAG(peer->sflags,
8104                                             PEER_STATUS_PREFIX_OVERFLOW))
8105                                 json_object_string_add(json_peer, "state",
8106                                                        "Idle (PfxCt)");
8107                         else
8108                                 json_object_string_add(
8109                                         json_peer, "state",
8110                                         lookup_msg(bgp_status_msg, peer->status,
8111                                                    NULL));
8112
8113                         if (peer->conf_if)
8114                                 json_object_string_add(json_peer, "idType",
8115                                                        "interface");
8116                         else if (peer->su.sa.sa_family == AF_INET)
8117                                 json_object_string_add(json_peer, "idType",
8118                                                        "ipv4");
8119                         else if (peer->su.sa.sa_family == AF_INET6)
8120                                 json_object_string_add(json_peer, "idType",
8121                                                        "ipv6");
8122
8123                         json_object_object_add(json_peers, peer->host,
8124                                                json_peer);
8125                 } else {
8126                         memset(dn_flag, '\0', sizeof(dn_flag));
8127                         if (peer_dynamic_neighbor(peer)) {
8128                                 dn_count++;
8129                                 dn_flag[0] = '*';
8130                         }
8131
8132                         if (peer->hostname
8133                             && bgp_flag_check(bgp, BGP_FLAG_SHOW_HOSTNAME))
8134                                 len = vty_out(vty, "%s%s(%s)", dn_flag,
8135                                               peer->hostname, peer->host);
8136                         else
8137                                 len = vty_out(vty, "%s%s", dn_flag, peer->host);
8138
8139                         /* pad the neighbor column with spaces */
8140                         if (len < max_neighbor_width)
8141                                 vty_out(vty, "%*s", max_neighbor_width - len,
8142                                         " ");
8143
8144                         vty_out(vty, "4 %10u %7u %7u %8" PRIu64 " %4d %4zd %8s",
8145                                 peer->as, PEER_TOTAL_RX(peer),
8146                                 PEER_TOTAL_TX(peer), peer->version[afi][safi],
8147                                 0, peer->obuf->count,
8148                                 peer_uptime(peer->uptime, timebuf,
8149                                             BGP_UPTIME_LEN, 0, NULL));
8150
8151                         if (peer->status == Established)
8152                                 if (peer->afc_recv[afi][safi])
8153                                         vty_out(vty, " %12ld",
8154                                                 peer->pcount[afi]
8155                                                             [pfx_rcd_safi]);
8156                                 else
8157                                         vty_out(vty, " NoNeg");
8158                         else {
8159                                 if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
8160                                         vty_out(vty, " Idle (Admin)");
8161                                 else if (CHECK_FLAG(
8162                                                  peer->sflags,
8163                                                  PEER_STATUS_PREFIX_OVERFLOW))
8164                                         vty_out(vty, " Idle (PfxCt)");
8165                                 else
8166                                         vty_out(vty, " %12s",
8167                                                 lookup_msg(bgp_status_msg,
8168                                                            peer->status, NULL));
8169                         }
8170                         vty_out(vty, "\n");
8171                 }
8172         }
8173
8174         if (use_json) {
8175                 json_object_object_add(json, "peers", json_peers);
8176
8177                 json_object_int_add(json, "totalPeers", count);
8178                 json_object_int_add(json, "dynamicPeers", dn_count);
8179
8180                 bgp_show_bestpath_json(bgp, json);
8181
8182                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
8183                                              json, JSON_C_TO_STRING_PRETTY));
8184                 json_object_free(json);
8185         } else {
8186                 if (count)
8187                         vty_out(vty, "\nTotal number of neighbors %d\n", count);
8188                 else {
8189                         vty_out(vty, "No %s neighbor is configured\n",
8190                                 afi_safi_print(afi, safi));
8191                 }
8192
8193                 if (dn_count) {
8194                         vty_out(vty, "* - dynamic neighbor\n");
8195                         vty_out(vty, "%d dynamic neighbor(s), limit %d\n",
8196                                 dn_count, bgp->dynamic_neighbors_limit);
8197                 }
8198         }
8199
8200         return CMD_SUCCESS;
8201 }
8202
8203 static void bgp_show_summary_afi_safi(struct vty *vty, struct bgp *bgp, int afi,
8204                                       int safi, bool use_json)
8205 {
8206         int is_first = 1;
8207         int afi_wildcard = (afi == AFI_MAX);
8208         int safi_wildcard = (safi == SAFI_MAX);
8209         int is_wildcard = (afi_wildcard || safi_wildcard);
8210         bool nbr_output = false;
8211
8212         if (use_json && is_wildcard)
8213                 vty_out(vty, "{\n");
8214         if (afi_wildcard)
8215                 afi = 1; /* AFI_IP */
8216         while (afi < AFI_MAX) {
8217                 if (safi_wildcard)
8218                         safi = 1; /* SAFI_UNICAST */
8219                 while (safi < SAFI_MAX) {
8220                         if (bgp_afi_safi_peer_exists(bgp, afi, safi)) {
8221                                 nbr_output = true;
8222
8223                                 if (is_wildcard) {
8224                                         /*
8225                                          * So limit output to those afi/safi
8226                                          * pairs that
8227                                          * actualy have something interesting in
8228                                          * them
8229                                          */
8230                                         if (use_json) {
8231                                                 if (!is_first)
8232                                                         vty_out(vty, ",\n");
8233                                                 else
8234                                                         is_first = 0;
8235
8236                                                 vty_out(vty, "\"%s\":",
8237                                                         afi_safi_json(afi,
8238                                                                       safi));
8239                                         } else {
8240                                                 vty_out(vty, "\n%s Summary:\n",
8241                                                         afi_safi_print(afi,
8242                                                                        safi));
8243                                         }
8244                                 }
8245                                 bgp_show_summary(vty, bgp, afi, safi, use_json);
8246                         }
8247                         safi++;
8248                         if (!safi_wildcard)
8249                                 safi = SAFI_MAX;
8250                 }
8251                 afi++;
8252                 if (!afi_wildcard)
8253                         afi = AFI_MAX;
8254         }
8255
8256         if (use_json && is_wildcard)
8257                 vty_out(vty, "}\n");
8258         else if (!nbr_output) {
8259                 if (use_json)
8260                         vty_out(vty, "{}\n");
8261                 else
8262                         vty_out(vty, "%% No BGP neighbors found\n");
8263         }
8264 }
8265
8266 static void bgp_show_all_instances_summary_vty(struct vty *vty, afi_t afi,
8267                                                safi_t safi, bool use_json)
8268 {
8269         struct listnode *node, *nnode;
8270         struct bgp *bgp;
8271         int is_first = 1;
8272         bool nbr_output = false;
8273
8274         if (use_json)
8275                 vty_out(vty, "{\n");
8276
8277         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
8278                 nbr_output = true;
8279                 if (use_json) {
8280                         if (!is_first)
8281                                 vty_out(vty, ",\n");
8282                         else
8283                                 is_first = 0;
8284
8285                         vty_out(vty, "\"%s\":",
8286                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8287                                         ? VRF_DEFAULT_NAME
8288                                         : bgp->name);
8289                 } else {
8290                         vty_out(vty, "\nInstance %s:\n",
8291                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8292                                         ? VRF_DEFAULT_NAME
8293                                         : bgp->name);
8294                 }
8295                 bgp_show_summary_afi_safi(vty, bgp, afi, safi, use_json);
8296         }
8297
8298         if (use_json)
8299                 vty_out(vty, "}\n");
8300         else if (!nbr_output)
8301                 vty_out(vty, "%% BGP instance not found\n");
8302 }
8303
8304 int bgp_show_summary_vty(struct vty *vty, const char *name, afi_t afi,
8305                          safi_t safi, bool use_json)
8306 {
8307         struct bgp *bgp;
8308
8309         if (name) {
8310                 if (strmatch(name, "all")) {
8311                         bgp_show_all_instances_summary_vty(vty, afi, safi,
8312                                                            use_json);
8313                         return CMD_SUCCESS;
8314                 } else {
8315                         bgp = bgp_lookup_by_name(name);
8316
8317                         if (!bgp) {
8318                                 if (use_json)
8319                                         vty_out(vty, "{}\n");
8320                                 else
8321                                         vty_out(vty,
8322                                                 "%% BGP instance not found\n");
8323                                 return CMD_WARNING;
8324                         }
8325
8326                         bgp_show_summary_afi_safi(vty, bgp, afi, safi,
8327                                                   use_json);
8328                         return CMD_SUCCESS;
8329                 }
8330         }
8331
8332         bgp = bgp_get_default();
8333
8334         if (bgp)
8335                 bgp_show_summary_afi_safi(vty, bgp, afi, safi, use_json);
8336         else {
8337                 if (use_json)
8338                         vty_out(vty, "{}\n");
8339                 else
8340                         vty_out(vty, "%% BGP instance not found\n");
8341                 return CMD_WARNING;
8342         }
8343
8344         return CMD_SUCCESS;
8345 }
8346
8347 /* `show [ip] bgp summary' commands. */
8348 DEFUN (show_ip_bgp_summary,
8349        show_ip_bgp_summary_cmd,
8350        "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] summary [json]",
8351        SHOW_STR
8352        IP_STR
8353        BGP_STR
8354        BGP_INSTANCE_HELP_STR
8355        BGP_AFI_HELP_STR
8356        BGP_SAFI_WITH_LABEL_HELP_STR
8357        "Summary of BGP neighbor status\n"
8358        JSON_STR)
8359 {
8360         char *vrf = NULL;
8361         afi_t afi = AFI_MAX;
8362         safi_t safi = SAFI_MAX;
8363
8364         int idx = 0;
8365
8366         /* show [ip] bgp */
8367         if (argv_find(argv, argc, "ip", &idx))
8368                 afi = AFI_IP;
8369         /* [<vrf> VIEWVRFNAME] */
8370         if (argv_find(argv, argc, "vrf", &idx)) {
8371                 vrf = argv[idx + 1]->arg;
8372                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
8373                         vrf = NULL;
8374         } else if (argv_find(argv, argc, "view", &idx))
8375                 /* [<view> VIEWVRFNAME] */
8376                 vrf = argv[idx + 1]->arg;
8377         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
8378         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
8379                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
8380         }
8381
8382         bool uj = use_json(argc, argv);
8383
8384         return bgp_show_summary_vty(vty, vrf, afi, safi, uj);
8385 }
8386
8387 const char *afi_safi_print(afi_t afi, safi_t safi)
8388 {
8389         if (afi == AFI_IP && safi == SAFI_UNICAST)
8390                 return "IPv4 Unicast";
8391         else if (afi == AFI_IP && safi == SAFI_MULTICAST)
8392                 return "IPv4 Multicast";
8393         else if (afi == AFI_IP && safi == SAFI_LABELED_UNICAST)
8394                 return "IPv4 Labeled Unicast";
8395         else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
8396                 return "IPv4 VPN";
8397         else if (afi == AFI_IP && safi == SAFI_ENCAP)
8398                 return "IPv4 Encap";
8399         else if (afi == AFI_IP && safi == SAFI_FLOWSPEC)
8400                 return "IPv4 Flowspec";
8401         else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
8402                 return "IPv6 Unicast";
8403         else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
8404                 return "IPv6 Multicast";
8405         else if (afi == AFI_IP6 && safi == SAFI_LABELED_UNICAST)
8406                 return "IPv6 Labeled Unicast";
8407         else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
8408                 return "IPv6 VPN";
8409         else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
8410                 return "IPv6 Encap";
8411         else if (afi == AFI_IP6 && safi == SAFI_FLOWSPEC)
8412                 return "IPv6 Flowspec";
8413         else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
8414                 return "L2VPN EVPN";
8415         else
8416                 return "Unknown";
8417 }
8418
8419 /*
8420  * Please note that we have intentionally camelCased
8421  * the return strings here.  So if you want
8422  * to use this function, please ensure you
8423  * are doing this within json output
8424  */
8425 const char *afi_safi_json(afi_t afi, safi_t safi)
8426 {
8427         if (afi == AFI_IP && safi == SAFI_UNICAST)
8428                 return "ipv4Unicast";
8429         else if (afi == AFI_IP && safi == SAFI_MULTICAST)
8430                 return "ipv4Multicast";
8431         else if (afi == AFI_IP && safi == SAFI_LABELED_UNICAST)
8432                 return "ipv4LabeledUnicast";
8433         else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
8434                 return "ipv4Vpn";
8435         else if (afi == AFI_IP && safi == SAFI_ENCAP)
8436                 return "ipv4Encap";
8437         else if (afi == AFI_IP && safi == SAFI_FLOWSPEC)
8438                 return "ipv4Flowspec";
8439         else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
8440                 return "ipv6Unicast";
8441         else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
8442                 return "ipv6Multicast";
8443         else if (afi == AFI_IP6 && safi == SAFI_LABELED_UNICAST)
8444                 return "ipv6LabeledUnicast";
8445         else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
8446                 return "ipv6Vpn";
8447         else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
8448                 return "ipv6Encap";
8449         else if (afi == AFI_IP6 && safi == SAFI_FLOWSPEC)
8450                 return "ipv6Flowspec";
8451         else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
8452                 return "l2VpnEvpn";
8453         else
8454                 return "Unknown";
8455 }
8456
8457 /* Show BGP peer's information. */
8458 enum show_type { show_all, show_peer, show_ipv4_all, show_ipv6_all, show_ipv4_peer, show_ipv6_peer };
8459
8460 static void bgp_show_peer_afi_orf_cap(struct vty *vty, struct peer *p,
8461                                       afi_t afi, safi_t safi,
8462                                       uint16_t adv_smcap, uint16_t adv_rmcap,
8463                                       uint16_t rcv_smcap, uint16_t rcv_rmcap,
8464                                       bool use_json, json_object *json_pref)
8465 {
8466         /* Send-Mode */
8467         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
8468             || CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap)) {
8469                 if (use_json) {
8470                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap)
8471                             && CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8472                                 json_object_string_add(json_pref, "sendMode",
8473                                                        "advertisedAndReceived");
8474                         else if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
8475                                 json_object_string_add(json_pref, "sendMode",
8476                                                        "advertised");
8477                         else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8478                                 json_object_string_add(json_pref, "sendMode",
8479                                                        "received");
8480                 } else {
8481                         vty_out(vty, "      Send-mode: ");
8482                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_smcap))
8483                                 vty_out(vty, "advertised");
8484                         if (CHECK_FLAG(p->af_cap[afi][safi], rcv_smcap))
8485                                 vty_out(vty, "%sreceived",
8486                                         CHECK_FLAG(p->af_cap[afi][safi],
8487                                                    adv_smcap)
8488                                                 ? ", "
8489                                                 : "");
8490                         vty_out(vty, "\n");
8491                 }
8492         }
8493
8494         /* Receive-Mode */
8495         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
8496             || CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap)) {
8497                 if (use_json) {
8498                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap)
8499                             && CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8500                                 json_object_string_add(json_pref, "recvMode",
8501                                                        "advertisedAndReceived");
8502                         else if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
8503                                 json_object_string_add(json_pref, "recvMode",
8504                                                        "advertised");
8505                         else if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8506                                 json_object_string_add(json_pref, "recvMode",
8507                                                        "received");
8508                 } else {
8509                         vty_out(vty, "      Receive-mode: ");
8510                         if (CHECK_FLAG(p->af_cap[afi][safi], adv_rmcap))
8511                                 vty_out(vty, "advertised");
8512                         if (CHECK_FLAG(p->af_cap[afi][safi], rcv_rmcap))
8513                                 vty_out(vty, "%sreceived",
8514                                         CHECK_FLAG(p->af_cap[afi][safi],
8515                                                    adv_rmcap)
8516                                                 ? ", "
8517                                                 : "");
8518                         vty_out(vty, "\n");
8519                 }
8520         }
8521 }
8522
8523 static void bgp_show_peer_afi(struct vty *vty, struct peer *p, afi_t afi,
8524                               safi_t safi, bool use_json,
8525                               json_object *json_neigh)
8526 {
8527         struct bgp_filter *filter;
8528         struct peer_af *paf;
8529         char orf_pfx_name[BUFSIZ];
8530         int orf_pfx_count;
8531         json_object *json_af = NULL;
8532         json_object *json_prefA = NULL;
8533         json_object *json_prefB = NULL;
8534         json_object *json_addr = NULL;
8535
8536         if (use_json) {
8537                 json_addr = json_object_new_object();
8538                 json_af = json_object_new_object();
8539                 filter = &p->filter[afi][safi];
8540
8541                 if (peer_group_active(p))
8542                         json_object_string_add(json_addr, "peerGroupMember",
8543                                                p->group->name);
8544
8545                 paf = peer_af_find(p, afi, safi);
8546                 if (paf && PAF_SUBGRP(paf)) {
8547                         json_object_int_add(json_addr, "updateGroupId",
8548                                             PAF_UPDGRP(paf)->id);
8549                         json_object_int_add(json_addr, "subGroupId",
8550                                             PAF_SUBGRP(paf)->id);
8551                         json_object_int_add(json_addr, "packetQueueLength",
8552                                             bpacket_queue_virtual_length(paf));
8553                 }
8554
8555                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8556                     || CHECK_FLAG(p->af_cap[afi][safi],
8557                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8558                     || CHECK_FLAG(p->af_cap[afi][safi],
8559                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8560                     || CHECK_FLAG(p->af_cap[afi][safi],
8561                                   PEER_CAP_ORF_PREFIX_RM_RCV)) {
8562                         json_object_int_add(json_af, "orfType",
8563                                             ORF_TYPE_PREFIX);
8564                         json_prefA = json_object_new_object();
8565                         bgp_show_peer_afi_orf_cap(vty, p, afi, safi,
8566                                                   PEER_CAP_ORF_PREFIX_SM_ADV,
8567                                                   PEER_CAP_ORF_PREFIX_RM_ADV,
8568                                                   PEER_CAP_ORF_PREFIX_SM_RCV,
8569                                                   PEER_CAP_ORF_PREFIX_RM_RCV,
8570                                                   use_json, json_prefA);
8571                         json_object_object_add(json_af, "orfPrefixList",
8572                                                json_prefA);
8573                 }
8574
8575                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8576                     || CHECK_FLAG(p->af_cap[afi][safi],
8577                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8578                     || CHECK_FLAG(p->af_cap[afi][safi],
8579                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8580                     || CHECK_FLAG(p->af_cap[afi][safi],
8581                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
8582                         json_object_int_add(json_af, "orfOldType",
8583                                             ORF_TYPE_PREFIX_OLD);
8584                         json_prefB = json_object_new_object();
8585                         bgp_show_peer_afi_orf_cap(
8586                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8587                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8588                                 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
8589                                 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json,
8590                                 json_prefB);
8591                         json_object_object_add(json_af, "orfOldPrefixList",
8592                                                json_prefB);
8593                 }
8594
8595                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8596                     || CHECK_FLAG(p->af_cap[afi][safi],
8597                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8598                     || CHECK_FLAG(p->af_cap[afi][safi],
8599                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8600                     || CHECK_FLAG(p->af_cap[afi][safi],
8601                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8602                     || CHECK_FLAG(p->af_cap[afi][safi],
8603                                   PEER_CAP_ORF_PREFIX_RM_RCV)
8604                     || CHECK_FLAG(p->af_cap[afi][safi],
8605                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
8606                         json_object_object_add(json_addr, "afDependentCap",
8607                                                json_af);
8608                 else
8609                         json_object_free(json_af);
8610
8611                 sprintf(orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
8612                 orf_pfx_count = prefix_bgp_show_prefix_list(
8613                         NULL, afi, orf_pfx_name, use_json);
8614
8615                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8616                                PEER_STATUS_ORF_PREFIX_SEND)
8617                     || orf_pfx_count) {
8618                         if (CHECK_FLAG(p->af_sflags[afi][safi],
8619                                        PEER_STATUS_ORF_PREFIX_SEND))
8620                                 json_object_boolean_true_add(json_neigh,
8621                                                              "orfSent");
8622                         if (orf_pfx_count)
8623                                 json_object_int_add(json_addr, "orfRecvCounter",
8624                                                     orf_pfx_count);
8625                 }
8626                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8627                                PEER_STATUS_ORF_WAIT_REFRESH))
8628                         json_object_string_add(
8629                                 json_addr, "orfFirstUpdate",
8630                                 "deferredUntilORFOrRouteRefreshRecvd");
8631
8632                 if (CHECK_FLAG(p->af_flags[afi][safi],
8633                                PEER_FLAG_REFLECTOR_CLIENT))
8634                         json_object_boolean_true_add(json_addr,
8635                                                      "routeReflectorClient");
8636                 if (CHECK_FLAG(p->af_flags[afi][safi],
8637                                PEER_FLAG_RSERVER_CLIENT))
8638                         json_object_boolean_true_add(json_addr,
8639                                                      "routeServerClient");
8640                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
8641                         json_object_boolean_true_add(json_addr,
8642                                                      "inboundSoftConfigPermit");
8643
8644                 if (CHECK_FLAG(p->af_flags[afi][safi],
8645                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
8646                         json_object_boolean_true_add(
8647                                 json_addr,
8648                                 "privateAsNumsAllReplacedInUpdatesToNbr");
8649                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8650                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
8651                         json_object_boolean_true_add(
8652                                 json_addr,
8653                                 "privateAsNumsReplacedInUpdatesToNbr");
8654                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8655                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
8656                         json_object_boolean_true_add(
8657                                 json_addr,
8658                                 "privateAsNumsAllRemovedInUpdatesToNbr");
8659                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8660                                     PEER_FLAG_REMOVE_PRIVATE_AS))
8661                         json_object_boolean_true_add(
8662                                 json_addr,
8663                                 "privateAsNumsRemovedInUpdatesToNbr");
8664
8665                 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
8666                         json_object_boolean_true_add(
8667                                 json_addr,
8668                                 bgp_addpath_names(p->addpath_type[afi][safi])
8669                                         ->type_json_name);
8670
8671                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
8672                         json_object_string_add(json_addr,
8673                                                "overrideASNsInOutboundUpdates",
8674                                                "ifAspathEqualRemoteAs");
8675
8676                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
8677                     || CHECK_FLAG(p->af_flags[afi][safi],
8678                                   PEER_FLAG_FORCE_NEXTHOP_SELF))
8679                         json_object_boolean_true_add(json_addr,
8680                                                      "routerAlwaysNextHop");
8681                 if (CHECK_FLAG(p->af_flags[afi][safi],
8682                                PEER_FLAG_AS_PATH_UNCHANGED))
8683                         json_object_boolean_true_add(
8684                                 json_addr, "unchangedAsPathPropogatedToNbr");
8685                 if (CHECK_FLAG(p->af_flags[afi][safi],
8686                                PEER_FLAG_NEXTHOP_UNCHANGED))
8687                         json_object_boolean_true_add(
8688                                 json_addr, "unchangedNextHopPropogatedToNbr");
8689                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
8690                         json_object_boolean_true_add(
8691                                 json_addr, "unchangedMedPropogatedToNbr");
8692                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
8693                     || CHECK_FLAG(p->af_flags[afi][safi],
8694                                   PEER_FLAG_SEND_EXT_COMMUNITY)) {
8695                         if (CHECK_FLAG(p->af_flags[afi][safi],
8696                                        PEER_FLAG_SEND_COMMUNITY)
8697                             && CHECK_FLAG(p->af_flags[afi][safi],
8698                                           PEER_FLAG_SEND_EXT_COMMUNITY))
8699                                 json_object_string_add(json_addr,
8700                                                        "commAttriSentToNbr",
8701                                                        "extendedAndStandard");
8702                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8703                                             PEER_FLAG_SEND_EXT_COMMUNITY))
8704                                 json_object_string_add(json_addr,
8705                                                        "commAttriSentToNbr",
8706                                                        "extended");
8707                         else
8708                                 json_object_string_add(json_addr,
8709                                                        "commAttriSentToNbr",
8710                                                        "standard");
8711                 }
8712                 if (CHECK_FLAG(p->af_flags[afi][safi],
8713                                PEER_FLAG_DEFAULT_ORIGINATE)) {
8714                         if (p->default_rmap[afi][safi].name)
8715                                 json_object_string_add(
8716                                         json_addr, "defaultRouteMap",
8717                                         p->default_rmap[afi][safi].name);
8718
8719                         if (paf && PAF_SUBGRP(paf)
8720                             && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
8721                                           SUBGRP_STATUS_DEFAULT_ORIGINATE))
8722                                 json_object_boolean_true_add(json_addr,
8723                                                              "defaultSent");
8724                         else
8725                                 json_object_boolean_true_add(json_addr,
8726                                                              "defaultNotSent");
8727                 }
8728
8729                 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
8730                         if (is_evpn_enabled())
8731                                 json_object_boolean_true_add(
8732                                         json_addr, "advertiseAllVnis");
8733                 }
8734
8735                 if (filter->plist[FILTER_IN].name
8736                     || filter->dlist[FILTER_IN].name
8737                     || filter->aslist[FILTER_IN].name
8738                     || filter->map[RMAP_IN].name)
8739                         json_object_boolean_true_add(json_addr,
8740                                                      "inboundPathPolicyConfig");
8741                 if (filter->plist[FILTER_OUT].name
8742                     || filter->dlist[FILTER_OUT].name
8743                     || filter->aslist[FILTER_OUT].name
8744                     || filter->map[RMAP_OUT].name || filter->usmap.name)
8745                         json_object_boolean_true_add(
8746                                 json_addr, "outboundPathPolicyConfig");
8747
8748                 /* prefix-list */
8749                 if (filter->plist[FILTER_IN].name)
8750                         json_object_string_add(json_addr,
8751                                                "incomingUpdatePrefixFilterList",
8752                                                filter->plist[FILTER_IN].name);
8753                 if (filter->plist[FILTER_OUT].name)
8754                         json_object_string_add(json_addr,
8755                                                "outgoingUpdatePrefixFilterList",
8756                                                filter->plist[FILTER_OUT].name);
8757
8758                 /* distribute-list */
8759                 if (filter->dlist[FILTER_IN].name)
8760                         json_object_string_add(
8761                                 json_addr, "incomingUpdateNetworkFilterList",
8762                                 filter->dlist[FILTER_IN].name);
8763                 if (filter->dlist[FILTER_OUT].name)
8764                         json_object_string_add(
8765                                 json_addr, "outgoingUpdateNetworkFilterList",
8766                                 filter->dlist[FILTER_OUT].name);
8767
8768                 /* filter-list. */
8769                 if (filter->aslist[FILTER_IN].name)
8770                         json_object_string_add(json_addr,
8771                                                "incomingUpdateAsPathFilterList",
8772                                                filter->aslist[FILTER_IN].name);
8773                 if (filter->aslist[FILTER_OUT].name)
8774                         json_object_string_add(json_addr,
8775                                                "outgoingUpdateAsPathFilterList",
8776                                                filter->aslist[FILTER_OUT].name);
8777
8778                 /* route-map. */
8779                 if (filter->map[RMAP_IN].name)
8780                         json_object_string_add(
8781                                 json_addr, "routeMapForIncomingAdvertisements",
8782                                 filter->map[RMAP_IN].name);
8783                 if (filter->map[RMAP_OUT].name)
8784                         json_object_string_add(
8785                                 json_addr, "routeMapForOutgoingAdvertisements",
8786                                 filter->map[RMAP_OUT].name);
8787
8788                 /* ebgp-requires-policy (inbound) */
8789                 if (p->bgp->ebgp_requires_policy == DEFAULT_EBGP_POLICY_ENABLED
8790                     && !bgp_inbound_policy_exists(p, filter))
8791                         json_object_string_add(
8792                                 json_addr, "inboundEbgpRequiresPolicy",
8793                                 "Inbound updates discarded due to missing policy");
8794
8795                 /* ebgp-requires-policy (outbound) */
8796                 if (p->bgp->ebgp_requires_policy == DEFAULT_EBGP_POLICY_ENABLED
8797                     && (!bgp_outbound_policy_exists(p, filter)))
8798                         json_object_string_add(
8799                                 json_addr, "outboundEbgpRequiresPolicy",
8800                                 "Outbound updates discarded due to missing policy");
8801
8802                 /* unsuppress-map */
8803                 if (filter->usmap.name)
8804                         json_object_string_add(json_addr,
8805                                                "selectiveUnsuppressRouteMap",
8806                                                filter->usmap.name);
8807
8808                 /* Receive prefix count */
8809                 json_object_int_add(json_addr, "acceptedPrefixCounter",
8810                                     p->pcount[afi][safi]);
8811                 if (paf && PAF_SUBGRP(paf))
8812                         json_object_int_add(json_addr, "sentPrefixCounter",
8813                                                 (PAF_SUBGRP(paf))->scount);
8814
8815                 /* Maximum prefix */
8816                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
8817                         json_object_int_add(json_addr, "prefixAllowedMax",
8818                                             p->pmax[afi][safi]);
8819                         if (CHECK_FLAG(p->af_flags[afi][safi],
8820                                        PEER_FLAG_MAX_PREFIX_WARNING))
8821                                 json_object_boolean_true_add(
8822                                         json_addr, "prefixAllowedMaxWarning");
8823                         json_object_int_add(json_addr,
8824                                             "prefixAllowedWarningThresh",
8825                                             p->pmax_threshold[afi][safi]);
8826                         if (p->pmax_restart[afi][safi])
8827                                 json_object_int_add(
8828                                         json_addr,
8829                                         "prefixAllowedRestartIntervalMsecs",
8830                                         p->pmax_restart[afi][safi] * 60000);
8831                 }
8832                 json_object_object_add(json_neigh, afi_safi_print(afi, safi),
8833                                        json_addr);
8834
8835         } else {
8836                 filter = &p->filter[afi][safi];
8837
8838                 vty_out(vty, " For address family: %s\n",
8839                         afi_safi_print(afi, safi));
8840
8841                 if (peer_group_active(p))
8842                         vty_out(vty, "  %s peer-group member\n",
8843                                 p->group->name);
8844
8845                 paf = peer_af_find(p, afi, safi);
8846                 if (paf && PAF_SUBGRP(paf)) {
8847                         vty_out(vty, "  Update group %" PRIu64
8848                                      ", subgroup %" PRIu64 "\n",
8849                                 PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id);
8850                         vty_out(vty, "  Packet Queue length %d\n",
8851                                 bpacket_queue_virtual_length(paf));
8852                 } else {
8853                         vty_out(vty, "  Not part of any update group\n");
8854                 }
8855                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8856                     || CHECK_FLAG(p->af_cap[afi][safi],
8857                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8858                     || CHECK_FLAG(p->af_cap[afi][safi],
8859                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8860                     || CHECK_FLAG(p->af_cap[afi][safi],
8861                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8862                     || CHECK_FLAG(p->af_cap[afi][safi],
8863                                   PEER_CAP_ORF_PREFIX_RM_RCV)
8864                     || CHECK_FLAG(p->af_cap[afi][safi],
8865                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
8866                         vty_out(vty, "  AF-dependant capabilities:\n");
8867
8868                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8869                     || CHECK_FLAG(p->af_cap[afi][safi],
8870                                   PEER_CAP_ORF_PREFIX_SM_RCV)
8871                     || CHECK_FLAG(p->af_cap[afi][safi],
8872                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8873                     || CHECK_FLAG(p->af_cap[afi][safi],
8874                                   PEER_CAP_ORF_PREFIX_RM_RCV)) {
8875                         vty_out(vty,
8876                                 "    Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
8877                                 ORF_TYPE_PREFIX);
8878                         bgp_show_peer_afi_orf_cap(
8879                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8880                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8881                                 PEER_CAP_ORF_PREFIX_SM_RCV,
8882                                 PEER_CAP_ORF_PREFIX_RM_RCV, use_json, NULL);
8883                 }
8884                 if (CHECK_FLAG(p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
8885                     || CHECK_FLAG(p->af_cap[afi][safi],
8886                                   PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
8887                     || CHECK_FLAG(p->af_cap[afi][safi],
8888                                   PEER_CAP_ORF_PREFIX_RM_ADV)
8889                     || CHECK_FLAG(p->af_cap[afi][safi],
8890                                   PEER_CAP_ORF_PREFIX_RM_OLD_RCV)) {
8891                         vty_out(vty,
8892                                 "    Outbound Route Filter (ORF) type (%d) Prefix-list:\n",
8893                                 ORF_TYPE_PREFIX_OLD);
8894                         bgp_show_peer_afi_orf_cap(
8895                                 vty, p, afi, safi, PEER_CAP_ORF_PREFIX_SM_ADV,
8896                                 PEER_CAP_ORF_PREFIX_RM_ADV,
8897                                 PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
8898                                 PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, NULL);
8899                 }
8900
8901                 sprintf(orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
8902                 orf_pfx_count = prefix_bgp_show_prefix_list(
8903                         NULL, afi, orf_pfx_name, use_json);
8904
8905                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8906                                PEER_STATUS_ORF_PREFIX_SEND)
8907                     || orf_pfx_count) {
8908                         vty_out(vty, "  Outbound Route Filter (ORF):");
8909                         if (CHECK_FLAG(p->af_sflags[afi][safi],
8910                                        PEER_STATUS_ORF_PREFIX_SEND))
8911                                 vty_out(vty, " sent;");
8912                         if (orf_pfx_count)
8913                                 vty_out(vty, " received (%d entries)",
8914                                         orf_pfx_count);
8915                         vty_out(vty, "\n");
8916                 }
8917                 if (CHECK_FLAG(p->af_sflags[afi][safi],
8918                                PEER_STATUS_ORF_WAIT_REFRESH))
8919                         vty_out(vty,
8920                                 "  First update is deferred until ORF or ROUTE-REFRESH is received\n");
8921
8922                 if (CHECK_FLAG(p->af_flags[afi][safi],
8923                                PEER_FLAG_REFLECTOR_CLIENT))
8924                         vty_out(vty, "  Route-Reflector Client\n");
8925                 if (CHECK_FLAG(p->af_flags[afi][safi],
8926                                PEER_FLAG_RSERVER_CLIENT))
8927                         vty_out(vty, "  Route-Server Client\n");
8928                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
8929                         vty_out(vty,
8930                                 "  Inbound soft reconfiguration allowed\n");
8931
8932                 if (CHECK_FLAG(p->af_flags[afi][safi],
8933                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
8934                         vty_out(vty,
8935                                 "  Private AS numbers (all) replaced in updates to this neighbor\n");
8936                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8937                                     PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
8938                         vty_out(vty,
8939                                 "  Private AS numbers replaced in updates to this neighbor\n");
8940                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8941                                     PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
8942                         vty_out(vty,
8943                                 "  Private AS numbers (all) removed in updates to this neighbor\n");
8944                 else if (CHECK_FLAG(p->af_flags[afi][safi],
8945                                     PEER_FLAG_REMOVE_PRIVATE_AS))
8946                         vty_out(vty,
8947                                 "  Private AS numbers removed in updates to this neighbor\n");
8948
8949                 if (p->addpath_type[afi][safi] != BGP_ADDPATH_NONE)
8950                         vty_out(vty, "  %s\n",
8951                                 bgp_addpath_names(p->addpath_type[afi][safi])
8952                                         ->human_description);
8953
8954                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
8955                         vty_out(vty,
8956                                 "  Override ASNs in outbound updates if aspath equals remote-as\n");
8957
8958                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF)
8959                     || CHECK_FLAG(p->af_flags[afi][safi],
8960                                   PEER_FLAG_FORCE_NEXTHOP_SELF))
8961                         vty_out(vty, "  NEXT_HOP is always this router\n");
8962                 if (CHECK_FLAG(p->af_flags[afi][safi],
8963                                PEER_FLAG_AS_PATH_UNCHANGED))
8964                         vty_out(vty,
8965                                 "  AS_PATH is propagated unchanged to this neighbor\n");
8966                 if (CHECK_FLAG(p->af_flags[afi][safi],
8967                                PEER_FLAG_NEXTHOP_UNCHANGED))
8968                         vty_out(vty,
8969                                 "  NEXT_HOP is propagated unchanged to this neighbor\n");
8970                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
8971                         vty_out(vty,
8972                                 "  MED is propagated unchanged to this neighbor\n");
8973                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
8974                     || CHECK_FLAG(p->af_flags[afi][safi],
8975                                   PEER_FLAG_SEND_EXT_COMMUNITY)
8976                     || CHECK_FLAG(p->af_flags[afi][safi],
8977                                   PEER_FLAG_SEND_LARGE_COMMUNITY)) {
8978                         vty_out(vty,
8979                                 "  Community attribute sent to this neighbor");
8980                         if (CHECK_FLAG(p->af_flags[afi][safi],
8981                                        PEER_FLAG_SEND_COMMUNITY)
8982                             && CHECK_FLAG(p->af_flags[afi][safi],
8983                                           PEER_FLAG_SEND_EXT_COMMUNITY)
8984                             && CHECK_FLAG(p->af_flags[afi][safi],
8985                                           PEER_FLAG_SEND_LARGE_COMMUNITY))
8986                                 vty_out(vty, "(all)\n");
8987                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8988                                             PEER_FLAG_SEND_LARGE_COMMUNITY))
8989                                 vty_out(vty, "(large)\n");
8990                         else if (CHECK_FLAG(p->af_flags[afi][safi],
8991                                             PEER_FLAG_SEND_EXT_COMMUNITY))
8992                                 vty_out(vty, "(extended)\n");
8993                         else
8994                                 vty_out(vty, "(standard)\n");
8995                 }
8996                 if (CHECK_FLAG(p->af_flags[afi][safi],
8997                                PEER_FLAG_DEFAULT_ORIGINATE)) {
8998                         vty_out(vty, "  Default information originate,");
8999
9000                         if (p->default_rmap[afi][safi].name)
9001                                 vty_out(vty, " default route-map %s%s,",
9002                                         p->default_rmap[afi][safi].map ? "*"
9003                                                                        : "",
9004                                         p->default_rmap[afi][safi].name);
9005                         if (paf && PAF_SUBGRP(paf)
9006                             && CHECK_FLAG(PAF_SUBGRP(paf)->sflags,
9007                                           SUBGRP_STATUS_DEFAULT_ORIGINATE))
9008                                 vty_out(vty, " default sent\n");
9009                         else
9010                                 vty_out(vty, " default not sent\n");
9011                 }
9012
9013                 /* advertise-vni-all */
9014                 if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
9015                         if (is_evpn_enabled())
9016                                 vty_out(vty, "  advertise-all-vni\n");
9017                 }
9018
9019                 if (filter->plist[FILTER_IN].name
9020                     || filter->dlist[FILTER_IN].name
9021                     || filter->aslist[FILTER_IN].name
9022                     || filter->map[RMAP_IN].name)
9023                         vty_out(vty, "  Inbound path policy configured\n");
9024                 if (filter->plist[FILTER_OUT].name
9025                     || filter->dlist[FILTER_OUT].name
9026                     || filter->aslist[FILTER_OUT].name
9027                     || filter->map[RMAP_OUT].name || filter->usmap.name)
9028                         vty_out(vty, "  Outbound path policy configured\n");
9029
9030                 /* prefix-list */
9031                 if (filter->plist[FILTER_IN].name)
9032                         vty_out(vty,
9033                                 "  Incoming update prefix filter list is %s%s\n",
9034                                 filter->plist[FILTER_IN].plist ? "*" : "",
9035                                 filter->plist[FILTER_IN].name);
9036                 if (filter->plist[FILTER_OUT].name)
9037                         vty_out(vty,
9038                                 "  Outgoing update prefix filter list is %s%s\n",
9039                                 filter->plist[FILTER_OUT].plist ? "*" : "",
9040                                 filter->plist[FILTER_OUT].name);
9041
9042                 /* distribute-list */
9043                 if (filter->dlist[FILTER_IN].name)
9044                         vty_out(vty,
9045                                 "  Incoming update network filter list is %s%s\n",
9046                                 filter->dlist[FILTER_IN].alist ? "*" : "",
9047                                 filter->dlist[FILTER_IN].name);
9048                 if (filter->dlist[FILTER_OUT].name)
9049                         vty_out(vty,
9050                                 "  Outgoing update network filter list is %s%s\n",
9051                                 filter->dlist[FILTER_OUT].alist ? "*" : "",
9052                                 filter->dlist[FILTER_OUT].name);
9053
9054                 /* filter-list. */
9055                 if (filter->aslist[FILTER_IN].name)
9056                         vty_out(vty,
9057                                 "  Incoming update AS path filter list is %s%s\n",
9058                                 filter->aslist[FILTER_IN].aslist ? "*" : "",
9059                                 filter->aslist[FILTER_IN].name);
9060                 if (filter->aslist[FILTER_OUT].name)
9061                         vty_out(vty,
9062                                 "  Outgoing update AS path filter list is %s%s\n",
9063                                 filter->aslist[FILTER_OUT].aslist ? "*" : "",
9064                                 filter->aslist[FILTER_OUT].name);
9065
9066                 /* route-map. */
9067                 if (filter->map[RMAP_IN].name)
9068                         vty_out(vty,
9069                                 "  Route map for incoming advertisements is %s%s\n",
9070                                 filter->map[RMAP_IN].map ? "*" : "",
9071                                 filter->map[RMAP_IN].name);
9072                 if (filter->map[RMAP_OUT].name)
9073                         vty_out(vty,
9074                                 "  Route map for outgoing advertisements is %s%s\n",
9075                                 filter->map[RMAP_OUT].map ? "*" : "",
9076                                 filter->map[RMAP_OUT].name);
9077
9078                 /* ebgp-requires-policy (inbound) */
9079                 if (p->bgp->ebgp_requires_policy == DEFAULT_EBGP_POLICY_ENABLED
9080                     && !bgp_inbound_policy_exists(p, filter))
9081                         vty_out(vty,
9082                                 "  Inbound updates discarded due to missing policy\n");
9083
9084                 /* ebgp-requires-policy (outbound) */
9085                 if (p->bgp->ebgp_requires_policy == DEFAULT_EBGP_POLICY_ENABLED
9086                     && !bgp_outbound_policy_exists(p, filter))
9087                         vty_out(vty,
9088                                 "  Outbound updates discarded due to missing policy\n");
9089
9090                 /* unsuppress-map */
9091                 if (filter->usmap.name)
9092                         vty_out(vty,
9093                                 "  Route map for selective unsuppress is %s%s\n",
9094                                 filter->usmap.map ? "*" : "",
9095                                 filter->usmap.name);
9096
9097                 /* Receive prefix count */
9098                 vty_out(vty, "  %ld accepted prefixes\n", p->pcount[afi][safi]);
9099
9100                 /* Maximum prefix */
9101                 if (CHECK_FLAG(p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX)) {
9102                         vty_out(vty, "  Maximum prefixes allowed %ld%s\n",
9103                                 p->pmax[afi][safi],
9104                                 CHECK_FLAG(p->af_flags[afi][safi],
9105                                            PEER_FLAG_MAX_PREFIX_WARNING)
9106                                         ? " (warning-only)"
9107                                         : "");
9108                         vty_out(vty, "  Threshold for warning message %d%%",
9109                                 p->pmax_threshold[afi][safi]);
9110                         if (p->pmax_restart[afi][safi])
9111                                 vty_out(vty, ", restart interval %d min",
9112                                         p->pmax_restart[afi][safi]);
9113                         vty_out(vty, "\n");
9114                 }
9115
9116                 vty_out(vty, "\n");
9117         }
9118 }
9119
9120 static void bgp_show_peer(struct vty *vty, struct peer *p, bool use_json,
9121                           json_object *json)
9122 {
9123         struct bgp *bgp;
9124         char buf1[PREFIX2STR_BUFFER], buf[SU_ADDRSTRLEN];
9125         char timebuf[BGP_UPTIME_LEN];
9126         char dn_flag[2];
9127         const char *subcode_str;
9128         const char *code_str;
9129         afi_t afi;
9130         safi_t safi;
9131         uint16_t i;
9132         uint8_t *msg;
9133         json_object *json_neigh = NULL;
9134         time_t epoch_tbuf;
9135
9136         bgp = p->bgp;
9137
9138         if (use_json)
9139                 json_neigh = json_object_new_object();
9140
9141         memset(dn_flag, '\0', sizeof(dn_flag));
9142         if (!p->conf_if && peer_dynamic_neighbor(p))
9143                 dn_flag[0] = '*';
9144
9145         if (!use_json) {
9146                 if (p->conf_if) /* Configured interface name. */
9147                         vty_out(vty, "BGP neighbor on %s: %s, ", p->conf_if,
9148                                 BGP_PEER_SU_UNSPEC(p)
9149                                         ? "None"
9150                                         : sockunion2str(&p->su, buf,
9151                                                         SU_ADDRSTRLEN));
9152                 else /* Configured IP address. */
9153                         vty_out(vty, "BGP neighbor is %s%s, ", dn_flag,
9154                                 p->host);
9155         }
9156
9157         if (use_json) {
9158                 if (p->conf_if && BGP_PEER_SU_UNSPEC(p))
9159                         json_object_string_add(json_neigh, "bgpNeighborAddr",
9160                                                "none");
9161                 else if (p->conf_if && !BGP_PEER_SU_UNSPEC(p))
9162                         json_object_string_add(
9163                                 json_neigh, "bgpNeighborAddr",
9164                                 sockunion2str(&p->su, buf, SU_ADDRSTRLEN));
9165
9166                 json_object_int_add(json_neigh, "remoteAs", p->as);
9167
9168                 if (p->change_local_as)
9169                         json_object_int_add(json_neigh, "localAs",
9170                                             p->change_local_as);
9171                 else
9172                         json_object_int_add(json_neigh, "localAs", p->local_as);
9173
9174                 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
9175                         json_object_boolean_true_add(json_neigh,
9176                                                      "localAsNoPrepend");
9177
9178                 if (CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS))
9179                         json_object_boolean_true_add(json_neigh,
9180                                                      "localAsReplaceAs");
9181         } else {
9182                 if ((p->as_type == AS_SPECIFIED) || (p->as_type == AS_EXTERNAL)
9183                     || (p->as_type == AS_INTERNAL))
9184                         vty_out(vty, "remote AS %u, ", p->as);
9185                 else
9186                         vty_out(vty, "remote AS Unspecified, ");
9187                 vty_out(vty, "local AS %u%s%s, ",
9188                         p->change_local_as ? p->change_local_as : p->local_as,
9189                         CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND)
9190                                 ? " no-prepend"
9191                                 : "",
9192                         CHECK_FLAG(p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS)
9193                                 ? " replace-as"
9194                                 : "");
9195         }
9196         /* peer type internal or confed-internal */
9197         if ((p->as == p->local_as) || (p->as_type == AS_INTERNAL)) {
9198                 if (use_json) {
9199                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9200                                 json_object_boolean_true_add(
9201                                         json_neigh, "nbrConfedInternalLink");
9202                         else
9203                                 json_object_boolean_true_add(json_neigh,
9204                                                              "nbrInternalLink");
9205                 } else {
9206                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9207                                 vty_out(vty, "confed-internal link\n");
9208                         else
9209                                 vty_out(vty, "internal link\n");
9210                 }
9211         /* peer type external or confed-external */
9212         } else if (p->as || (p->as_type == AS_EXTERNAL)) {
9213                 if (use_json) {
9214                         if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
9215                                 json_object_boolean_true_add(
9216                                         json_neigh, "nbrConfedExternalLink");
9217                         else
9218                                 json_object_boolean_true_add(json_neigh,
9219                                                              "nbrExternalLink");
9220                 } else {
9221                         if (bgp_confederation_peers_check(bgp, p->as))
9222                                 vty_out(vty, "confed-external link\n");
9223                         else
9224                                 vty_out(vty, "external link\n");
9225                 }
9226         } else {
9227                 if (use_json)
9228                         json_object_boolean_true_add(json_neigh,
9229                                                      "nbrUnspecifiedLink");
9230                 else
9231                         vty_out(vty, "unspecified link\n");
9232         }
9233
9234         /* Description. */
9235         if (p->desc) {
9236                 if (use_json)
9237                         json_object_string_add(json_neigh, "nbrDesc", p->desc);
9238                 else
9239                         vty_out(vty, " Description: %s\n", p->desc);
9240         }
9241
9242         if (p->hostname) {
9243                 if (use_json) {
9244                         if (p->hostname)
9245                                 json_object_string_add(json_neigh, "hostname",
9246                                                        p->hostname);
9247
9248                         if (p->domainname)
9249                                 json_object_string_add(json_neigh, "domainname",
9250                                                        p->domainname);
9251                 } else {
9252                         if (p->domainname && (p->domainname[0] != '\0'))
9253                                 vty_out(vty, "Hostname: %s.%s\n", p->hostname,
9254                                         p->domainname);
9255                         else
9256                                 vty_out(vty, "Hostname: %s\n", p->hostname);
9257                 }
9258         }
9259
9260         /* Peer-group */
9261         if (p->group) {
9262                 if (use_json) {
9263                         json_object_string_add(json_neigh, "peerGroup",
9264                                                p->group->name);
9265
9266                         if (dn_flag[0]) {
9267                                 struct prefix prefix, *range = NULL;
9268
9269                                 sockunion2hostprefix(&(p->su), &prefix);
9270                                 range = peer_group_lookup_dynamic_neighbor_range(
9271                                         p->group, &prefix);
9272
9273                                 if (range) {
9274                                         prefix2str(range, buf1, sizeof(buf1));
9275                                         json_object_string_add(
9276                                                 json_neigh,
9277                                                 "peerSubnetRangeGroup", buf1);
9278                                 }
9279                         }
9280                 } else {
9281                         vty_out(vty,
9282                                 " Member of peer-group %s for session parameters\n",
9283                                 p->group->name);
9284
9285                         if (dn_flag[0]) {
9286                                 struct prefix prefix, *range = NULL;
9287
9288                                 sockunion2hostprefix(&(p->su), &prefix);
9289                                 range = peer_group_lookup_dynamic_neighbor_range(
9290                                         p->group, &prefix);
9291
9292                                 if (range) {
9293                                         prefix2str(range, buf1, sizeof(buf1));
9294                                         vty_out(vty,
9295                                                 " Belongs to the subnet range group: %s\n",
9296                                                 buf1);
9297                                 }
9298                         }
9299                 }
9300         }
9301
9302         if (use_json) {
9303                 /* Administrative shutdown. */
9304                 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN))
9305                         json_object_boolean_true_add(json_neigh,
9306                                                      "adminShutDown");
9307
9308                 /* BGP Version. */
9309                 json_object_int_add(json_neigh, "bgpVersion", 4);
9310                 json_object_string_add(
9311                         json_neigh, "remoteRouterId",
9312                         inet_ntop(AF_INET, &p->remote_id, buf1, sizeof(buf1)));
9313                 json_object_string_add(
9314                         json_neigh, "localRouterId",
9315                         inet_ntop(AF_INET, &bgp->router_id, buf1,
9316                                         sizeof(buf1)));
9317
9318                 /* Confederation */
9319                 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
9320                     && bgp_confederation_peers_check(bgp, p->as))
9321                         json_object_boolean_true_add(json_neigh,
9322                                                      "nbrCommonAdmin");
9323
9324                 /* Status. */
9325                 json_object_string_add(
9326                         json_neigh, "bgpState",
9327                         lookup_msg(bgp_status_msg, p->status, NULL));
9328
9329                 if (p->status == Established) {
9330                         time_t uptime;
9331
9332                         uptime = bgp_clock();
9333                         uptime -= p->uptime;
9334                         epoch_tbuf = time(NULL) - uptime;
9335
9336 #if CONFDATE > 20200101
9337                         CPP_NOTICE(
9338                                 "bgpTimerUp should be deprecated and can be removed now");
9339 #endif
9340                         /*
9341                          * bgpTimerUp was miliseconds that was accurate
9342                          * up to 1 day, then the value returned
9343                          * became garbage.  So in order to provide
9344                          * some level of backwards compatability,
9345                          * we still provde the data, but now
9346                          * we are returning the correct value
9347                          * and also adding a new bgpTimerUpMsec
9348                          * which will allow us to deprecate
9349                          * this eventually
9350                          */
9351                         json_object_int_add(json_neigh, "bgpTimerUp",
9352                                             uptime * 1000);
9353                         json_object_int_add(json_neigh, "bgpTimerUpMsec",
9354                                             uptime * 1000);
9355                         json_object_string_add(json_neigh, "bgpTimerUpString",
9356                                                peer_uptime(p->uptime, timebuf,
9357                                                            BGP_UPTIME_LEN, 0,
9358                                                            NULL));
9359                         json_object_int_add(json_neigh,
9360                                             "bgpTimerUpEstablishedEpoch",
9361                                             epoch_tbuf);
9362                 }
9363
9364                 else if (p->status == Active) {
9365                         if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
9366                                 json_object_string_add(json_neigh, "bgpStateIs",
9367                                                        "passive");
9368                         else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
9369                                 json_object_string_add(json_neigh, "bgpStateIs",
9370                                                        "passiveNSF");
9371                 }
9372
9373                 /* read timer */
9374                 time_t uptime;
9375                 struct tm *tm;
9376
9377                 uptime = bgp_clock();
9378                 uptime -= p->readtime;
9379                 tm = gmtime(&uptime);
9380                 json_object_int_add(json_neigh, "bgpTimerLastRead",
9381                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9382                                             + (tm->tm_hour * 3600000));
9383
9384                 uptime = bgp_clock();
9385                 uptime -= p->last_write;
9386                 tm = gmtime(&uptime);
9387                 json_object_int_add(json_neigh, "bgpTimerLastWrite",
9388                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9389                                             + (tm->tm_hour * 3600000));
9390
9391                 uptime = bgp_clock();
9392                 uptime -= p->update_time;
9393                 tm = gmtime(&uptime);
9394                 json_object_int_add(json_neigh, "bgpInUpdateElapsedTimeMsecs",
9395                                     (tm->tm_sec * 1000) + (tm->tm_min * 60000)
9396                                             + (tm->tm_hour * 3600000));
9397
9398                 /* Configured timer values. */
9399                 json_object_int_add(json_neigh, "bgpTimerHoldTimeMsecs",
9400                                     p->v_holdtime * 1000);
9401                 json_object_int_add(json_neigh,
9402                                     "bgpTimerKeepAliveIntervalMsecs",
9403                                     p->v_keepalive * 1000);
9404                 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER)) {
9405                         json_object_int_add(json_neigh,
9406                                             "bgpTimerConfiguredHoldTimeMsecs",
9407                                             p->holdtime * 1000);
9408                         json_object_int_add(
9409                                 json_neigh,
9410                                 "bgpTimerConfiguredKeepAliveIntervalMsecs",
9411                                 p->keepalive * 1000);
9412                 } else if ((bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
9413                            || (bgp->default_keepalive
9414                                != BGP_DEFAULT_KEEPALIVE)) {
9415                         json_object_int_add(json_neigh,
9416                                             "bgpTimerConfiguredHoldTimeMsecs",
9417                                             bgp->default_holdtime);
9418                         json_object_int_add(
9419                                 json_neigh,
9420                                 "bgpTimerConfiguredKeepAliveIntervalMsecs",
9421                                 bgp->default_keepalive);
9422                 }
9423         } else {
9424                 /* Administrative shutdown. */
9425                 if (CHECK_FLAG(p->flags, PEER_FLAG_SHUTDOWN))
9426                         vty_out(vty, " Administratively shut down\n");
9427
9428                 /* BGP Version. */
9429                 vty_out(vty, "  BGP version 4");
9430                 vty_out(vty, ", remote router ID %s",
9431                         inet_ntop(AF_INET, &p->remote_id, buf1, sizeof(buf1)));
9432                 vty_out(vty, ", local router ID %s\n",
9433                         inet_ntop(AF_INET, &bgp->router_id, buf1,
9434                                         sizeof(buf1)));
9435
9436                 /* Confederation */
9437                 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)
9438                     && bgp_confederation_peers_check(bgp, p->as))
9439                         vty_out(vty,
9440                                 "  Neighbor under common administration\n");
9441
9442                 /* Status. */
9443                 vty_out(vty, "  BGP state = %s",
9444                         lookup_msg(bgp_status_msg, p->status, NULL));
9445
9446                 if (p->status == Established)
9447                         vty_out(vty, ", up for %8s",
9448                                 peer_uptime(p->uptime, timebuf, BGP_UPTIME_LEN,
9449                                             0, NULL));
9450
9451                 else if (p->status == Active) {
9452                         if (CHECK_FLAG(p->flags, PEER_FLAG_PASSIVE))
9453                                 vty_out(vty, " (passive)");
9454                         else if (CHECK_FLAG(p->sflags, PEER_STATUS_NSF_WAIT))
9455                                 vty_out(vty, " (NSF passive)");
9456                 }
9457                 vty_out(vty, "\n");
9458
9459                 /* read timer */
9460                 vty_out(vty, "  Last read %s",
9461                         peer_uptime(p->readtime, timebuf, BGP_UPTIME_LEN, 0,
9462                                     NULL));
9463                 vty_out(vty, ", Last write %s\n",
9464                         peer_uptime(p->last_write, timebuf, BGP_UPTIME_LEN, 0,
9465                                     NULL));
9466
9467                 /* Configured timer values. */
9468                 vty_out(vty,
9469                         "  Hold time is %d, keepalive interval is %d seconds\n",
9470                         p->v_holdtime, p->v_keepalive);
9471                 if (CHECK_FLAG(p->flags, PEER_FLAG_TIMER)) {
9472                         vty_out(vty, "  Configured hold time is %d",
9473                                 p->holdtime);
9474                         vty_out(vty, ", keepalive interval is %d seconds\n",
9475                                 p->keepalive);
9476                 } else if ((bgp->default_holdtime != BGP_DEFAULT_HOLDTIME)
9477                            || (bgp->default_keepalive
9478                                != BGP_DEFAULT_KEEPALIVE)) {
9479                         vty_out(vty, "  Configured hold time is %d",
9480                                 bgp->default_holdtime);
9481                         vty_out(vty, ", keepalive interval is %d seconds\n",
9482                                 bgp->default_keepalive);
9483                 }
9484         }
9485         /* Capability. */
9486         if (p->status == Established) {
9487                 if (p->cap || p->afc_adv[AFI_IP][SAFI_UNICAST]
9488                     || p->afc_recv[AFI_IP][SAFI_UNICAST]
9489                     || p->afc_adv[AFI_IP][SAFI_MULTICAST]
9490                     || p->afc_recv[AFI_IP][SAFI_MULTICAST]
9491                     || p->afc_adv[AFI_IP6][SAFI_UNICAST]
9492                     || p->afc_recv[AFI_IP6][SAFI_UNICAST]
9493                     || p->afc_adv[AFI_IP6][SAFI_MULTICAST]
9494                     || p->afc_recv[AFI_IP6][SAFI_MULTICAST]
9495                     || p->afc_adv[AFI_IP6][SAFI_MPLS_VPN]
9496                     || p->afc_recv[AFI_IP6][SAFI_MPLS_VPN]
9497                     || p->afc_adv[AFI_IP6][SAFI_ENCAP]
9498                     || p->afc_recv[AFI_IP6][SAFI_ENCAP]
9499                     || p->afc_adv[AFI_IP6][SAFI_FLOWSPEC]
9500                     || p->afc_recv[AFI_IP6][SAFI_FLOWSPEC]
9501                     || p->afc_adv[AFI_IP][SAFI_ENCAP]
9502                     || p->afc_recv[AFI_IP][SAFI_ENCAP]
9503                     || p->afc_adv[AFI_IP][SAFI_FLOWSPEC]
9504                     || p->afc_recv[AFI_IP][SAFI_FLOWSPEC]
9505                     || p->afc_adv[AFI_IP][SAFI_MPLS_VPN]
9506                     || p->afc_recv[AFI_IP][SAFI_MPLS_VPN]) {
9507                         if (use_json) {
9508                                 json_object *json_cap = NULL;
9509
9510                                 json_cap = json_object_new_object();
9511
9512                                 /* AS4 */
9513                                 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV)
9514                                     || CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
9515                                         if (CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)
9516                                             && CHECK_FLAG(p->cap,
9517                                                           PEER_CAP_AS4_RCV))
9518                                                 json_object_string_add(
9519                                                         json_cap, "4byteAs",
9520                                                         "advertisedAndReceived");
9521                                         else if (CHECK_FLAG(p->cap,
9522                                                             PEER_CAP_AS4_ADV))
9523                                                 json_object_string_add(
9524                                                         json_cap, "4byteAs",
9525                                                         "advertised");
9526                                         else if (CHECK_FLAG(p->cap,
9527                                                             PEER_CAP_AS4_RCV))
9528                                                 json_object_string_add(
9529                                                         json_cap, "4byteAs",
9530                                                         "received");
9531                                 }
9532
9533                                 /* AddPath */
9534                                 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV)
9535                                     || CHECK_FLAG(p->cap,
9536                                                   PEER_CAP_ADDPATH_ADV)) {
9537                                         json_object *json_add = NULL;
9538                                         const char *print_store;
9539
9540                                         json_add = json_object_new_object();
9541
9542                                         FOREACH_AFI_SAFI (afi, safi) {
9543                                                 json_object *json_sub = NULL;
9544                                                 json_sub =
9545                                                         json_object_new_object();
9546                                                 print_store = afi_safi_print(
9547                                                         afi, safi);
9548
9549                                                 if (CHECK_FLAG(
9550                                                             p->af_cap[afi]
9551                                                                      [safi],
9552                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9553                                                     || CHECK_FLAG(
9554                                                                p->af_cap[afi]
9555                                                                         [safi],
9556                                                                PEER_CAP_ADDPATH_AF_TX_RCV)) {
9557                                                         if (CHECK_FLAG(
9558                                                                     p->af_cap
9559                                                                             [afi]
9560                                                                             [safi],
9561                                                                     PEER_CAP_ADDPATH_AF_TX_ADV)
9562                                                             && CHECK_FLAG(
9563                                                                        p->af_cap
9564                                                                                [afi]
9565                                                                                [safi],
9566                                                                        PEER_CAP_ADDPATH_AF_TX_RCV))
9567                                                                 json_object_boolean_true_add(
9568                                                                         json_sub,
9569                                                                         "txAdvertisedAndReceived");
9570                                                         else if (
9571                                                                 CHECK_FLAG(
9572                                                                         p->af_cap
9573                                                                                 [afi]
9574                                                                                 [safi],
9575                                                                         PEER_CAP_ADDPATH_AF_TX_ADV))
9576                                                                 json_object_boolean_true_add(
9577                                                                         json_sub,
9578                                                                         "txAdvertised");
9579                                                         else if (
9580                                                                 CHECK_FLAG(
9581                                                                         p->af_cap
9582                                                                                 [afi]
9583                                                                                 [safi],
9584                                                                         PEER_CAP_ADDPATH_AF_TX_RCV))
9585                                                                 json_object_boolean_true_add(
9586                                                                         json_sub,
9587                                                                         "txReceived");
9588                                                 }
9589
9590                                                 if (CHECK_FLAG(
9591                                                             p->af_cap[afi]
9592                                                                      [safi],
9593                                                             PEER_CAP_ADDPATH_AF_RX_ADV)
9594                                                     || CHECK_FLAG(
9595                                                                p->af_cap[afi]
9596                                                                         [safi],
9597                                                                PEER_CAP_ADDPATH_AF_RX_RCV)) {
9598                                                         if (CHECK_FLAG(
9599                                                                     p->af_cap
9600                                                                             [afi]
9601                                                                             [safi],
9602                                                                     PEER_CAP_ADDPATH_AF_RX_ADV)
9603                                                             && CHECK_FLAG(
9604                                                                        p->af_cap
9605                                                                                [afi]
9606                                                                                [safi],
9607                                                                        PEER_CAP_ADDPATH_AF_RX_RCV))
9608                                                                 json_object_boolean_true_add(
9609                                                                         json_sub,
9610                                                                         "rxAdvertisedAndReceived");
9611                                                         else if (
9612                                                                 CHECK_FLAG(
9613                                                                         p->af_cap
9614                                                                                 [afi]
9615                                                                                 [safi],
9616                                                                         PEER_CAP_ADDPATH_AF_RX_ADV))
9617                                                                 json_object_boolean_true_add(
9618                                                                         json_sub,
9619                                                                         "rxAdvertised");
9620                                                         else if (
9621                                                                 CHECK_FLAG(
9622                                                                         p->af_cap
9623                                                                                 [afi]
9624                                                                                 [safi],
9625                                                                         PEER_CAP_ADDPATH_AF_RX_RCV))
9626                                                                 json_object_boolean_true_add(
9627                                                                         json_sub,
9628                                                                         "rxReceived");
9629                                                 }
9630
9631                                                 if (CHECK_FLAG(
9632                                                             p->af_cap[afi]
9633                                                                      [safi],
9634                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9635                                                     || CHECK_FLAG(
9636                                                                p->af_cap[afi]
9637                                                                         [safi],
9638                                                                PEER_CAP_ADDPATH_AF_TX_RCV)
9639                                                     || CHECK_FLAG(
9640                                                                p->af_cap[afi]
9641                                                                         [safi],
9642                                                                PEER_CAP_ADDPATH_AF_RX_ADV)
9643                                                     || CHECK_FLAG(
9644                                                                p->af_cap[afi]
9645                                                                         [safi],
9646                                                                PEER_CAP_ADDPATH_AF_RX_RCV))
9647                                                         json_object_object_add(
9648                                                                 json_add,
9649                                                                 print_store,
9650                                                                 json_sub);
9651                                                 else
9652                                                         json_object_free(
9653                                                                 json_sub);
9654                                         }
9655
9656                                         json_object_object_add(
9657                                                 json_cap, "addPath", json_add);
9658                                 }
9659
9660                                 /* Dynamic */
9661                                 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV)
9662                                     || CHECK_FLAG(p->cap,
9663                                                   PEER_CAP_DYNAMIC_ADV)) {
9664                                         if (CHECK_FLAG(p->cap,
9665                                                        PEER_CAP_DYNAMIC_ADV)
9666                                             && CHECK_FLAG(p->cap,
9667                                                           PEER_CAP_DYNAMIC_RCV))
9668                                                 json_object_string_add(
9669                                                         json_cap, "dynamic",
9670                                                         "advertisedAndReceived");
9671                                         else if (CHECK_FLAG(
9672                                                          p->cap,
9673                                                          PEER_CAP_DYNAMIC_ADV))
9674                                                 json_object_string_add(
9675                                                         json_cap, "dynamic",
9676                                                         "advertised");
9677                                         else if (CHECK_FLAG(
9678                                                          p->cap,
9679                                                          PEER_CAP_DYNAMIC_RCV))
9680                                                 json_object_string_add(
9681                                                         json_cap, "dynamic",
9682                                                         "received");
9683                                 }
9684
9685                                 /* Extended nexthop */
9686                                 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)
9687                                     || CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
9688                                         json_object *json_nxt = NULL;
9689                                         const char *print_store;
9690
9691
9692                                         if (CHECK_FLAG(p->cap,
9693                                                        PEER_CAP_ENHE_ADV)
9694                                             && CHECK_FLAG(p->cap,
9695                                                           PEER_CAP_ENHE_RCV))
9696                                                 json_object_string_add(
9697                                                         json_cap,
9698                                                         "extendedNexthop",
9699                                                         "advertisedAndReceived");
9700                                         else if (CHECK_FLAG(p->cap,
9701                                                             PEER_CAP_ENHE_ADV))
9702                                                 json_object_string_add(
9703                                                         json_cap,
9704                                                         "extendedNexthop",
9705                                                         "advertised");
9706                                         else if (CHECK_FLAG(p->cap,
9707                                                             PEER_CAP_ENHE_RCV))
9708                                                 json_object_string_add(
9709                                                         json_cap,
9710                                                         "extendedNexthop",
9711                                                         "received");
9712
9713                                         if (CHECK_FLAG(p->cap,
9714                                                        PEER_CAP_ENHE_RCV)) {
9715                                                 json_nxt =
9716                                                         json_object_new_object();
9717
9718                                                 for (safi = SAFI_UNICAST;
9719                                                      safi < SAFI_MAX; safi++) {
9720                                                         if (CHECK_FLAG(
9721                                                                     p->af_cap
9722                                                                             [AFI_IP]
9723                                                                             [safi],
9724                                                                     PEER_CAP_ENHE_AF_RCV)) {
9725                                                                 print_store = afi_safi_print(
9726                                                                         AFI_IP,
9727                                                                         safi);
9728                                                                 json_object_string_add(
9729                                                                         json_nxt,
9730                                                                         print_store,
9731                                                                         "recieved"); /* misspelled for compatibility */
9732                                                         }
9733                                                 }
9734                                                 json_object_object_add(
9735                                                         json_cap,
9736                                                         "extendedNexthopFamililesByPeer",
9737                                                         json_nxt);
9738                                         }
9739                                 }
9740
9741                                 /* Route Refresh */
9742                                 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV)
9743                                     || CHECK_FLAG(p->cap,
9744                                                   PEER_CAP_REFRESH_NEW_RCV)
9745                                     || CHECK_FLAG(p->cap,
9746                                                   PEER_CAP_REFRESH_OLD_RCV)) {
9747                                         if (CHECK_FLAG(p->cap,
9748                                                        PEER_CAP_REFRESH_ADV)
9749                                             && (CHECK_FLAG(
9750                                                         p->cap,
9751                                                         PEER_CAP_REFRESH_NEW_RCV)
9752                                                 || CHECK_FLAG(
9753                                                            p->cap,
9754                                                            PEER_CAP_REFRESH_OLD_RCV))) {
9755                                                 if (CHECK_FLAG(
9756                                                             p->cap,
9757                                                             PEER_CAP_REFRESH_OLD_RCV)
9758                                                     && CHECK_FLAG(
9759                                                                p->cap,
9760                                                                PEER_CAP_REFRESH_NEW_RCV))
9761                                                         json_object_string_add(
9762                                                                 json_cap,
9763                                                                 "routeRefresh",
9764                                                                 "advertisedAndReceivedOldNew");
9765                                                 else {
9766                                                         if (CHECK_FLAG(
9767                                                                     p->cap,
9768                                                                     PEER_CAP_REFRESH_OLD_RCV))
9769                                                                 json_object_string_add(
9770                                                                         json_cap,
9771                                                                         "routeRefresh",
9772                                                                         "advertisedAndReceivedOld");
9773                                                         else
9774                                                                 json_object_string_add(
9775                                                                         json_cap,
9776                                                                         "routeRefresh",
9777                                                                         "advertisedAndReceivedNew");
9778                                                 }
9779                                         } else if (
9780                                                 CHECK_FLAG(
9781                                                         p->cap,
9782                                                         PEER_CAP_REFRESH_ADV))
9783                                                 json_object_string_add(
9784                                                         json_cap,
9785                                                         "routeRefresh",
9786                                                         "advertised");
9787                                         else if (
9788                                                 CHECK_FLAG(
9789                                                         p->cap,
9790                                                         PEER_CAP_REFRESH_NEW_RCV)
9791                                                 || CHECK_FLAG(
9792                                                            p->cap,
9793                                                            PEER_CAP_REFRESH_OLD_RCV))
9794                                                 json_object_string_add(
9795                                                         json_cap,
9796                                                         "routeRefresh",
9797                                                         "received");
9798                                 }
9799
9800                                 /* Multiprotocol Extensions */
9801                                 json_object *json_multi = NULL;
9802                                 json_multi = json_object_new_object();
9803
9804                                 FOREACH_AFI_SAFI (afi, safi) {
9805                                         if (p->afc_adv[afi][safi]
9806                                             || p->afc_recv[afi][safi]) {
9807                                                 json_object *json_exten = NULL;
9808                                                 json_exten =
9809                                                         json_object_new_object();
9810
9811                                                 if (p->afc_adv[afi][safi]
9812                                                     && p->afc_recv[afi][safi])
9813                                                         json_object_boolean_true_add(
9814                                                                 json_exten,
9815                                                                 "advertisedAndReceived");
9816                                                 else if (p->afc_adv[afi][safi])
9817                                                         json_object_boolean_true_add(
9818                                                                 json_exten,
9819                                                                 "advertised");
9820                                                 else if (p->afc_recv[afi][safi])
9821                                                         json_object_boolean_true_add(
9822                                                                 json_exten,
9823                                                                 "received");
9824
9825                                                 json_object_object_add(
9826                                                         json_multi,
9827                                                         afi_safi_print(afi,
9828                                                                        safi),
9829                                                         json_exten);
9830                                         }
9831                                 }
9832                                 json_object_object_add(
9833                                         json_cap, "multiprotocolExtensions",
9834                                         json_multi);
9835
9836                                 /* Hostname capabilities */
9837                                 json_object *json_hname = NULL;
9838
9839                                 json_hname = json_object_new_object();
9840
9841                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
9842                                         json_object_string_add(
9843                                                 json_hname, "advHostName",
9844                                                 bgp->peer_self->hostname
9845                                                         ? bgp->peer_self
9846                                                                   ->hostname
9847                                                         : "n/a");
9848                                         json_object_string_add(
9849                                                 json_hname, "advDomainName",
9850                                                 bgp->peer_self->domainname
9851                                                         ? bgp->peer_self
9852                                                                   ->domainname
9853                                                         : "n/a");
9854                                 }
9855
9856
9857                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
9858                                         json_object_string_add(
9859                                                 json_hname, "rcvHostName",
9860                                                 p->hostname ? p->hostname
9861                                                             : "n/a");
9862                                         json_object_string_add(
9863                                                 json_hname, "rcvDomainName",
9864                                                 p->domainname ? p->domainname
9865                                                               : "n/a");
9866                                 }
9867
9868                                 json_object_object_add(json_cap, "hostName",
9869                                                        json_hname);
9870
9871                                 /* Gracefull Restart */
9872                                 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)
9873                                     || CHECK_FLAG(p->cap,
9874                                                   PEER_CAP_RESTART_ADV)) {
9875                                         if (CHECK_FLAG(p->cap,
9876                                                        PEER_CAP_RESTART_ADV)
9877                                             && CHECK_FLAG(p->cap,
9878                                                           PEER_CAP_RESTART_RCV))
9879                                                 json_object_string_add(
9880                                                         json_cap,
9881                                                         "gracefulRestart",
9882                                                         "advertisedAndReceived");
9883                                         else if (CHECK_FLAG(
9884                                                          p->cap,
9885                                                          PEER_CAP_RESTART_ADV))
9886                                                 json_object_string_add(
9887                                                         json_cap,
9888                                                         "gracefulRestartCapability",
9889                                                         "advertised");
9890                                         else if (CHECK_FLAG(
9891                                                          p->cap,
9892                                                          PEER_CAP_RESTART_RCV))
9893                                                 json_object_string_add(
9894                                                         json_cap,
9895                                                         "gracefulRestartCapability",
9896                                                         "received");
9897
9898                                         if (CHECK_FLAG(p->cap,
9899                                                        PEER_CAP_RESTART_RCV)) {
9900                                                 int restart_af_count = 0;
9901                                                 json_object *json_restart =
9902                                                         NULL;
9903                                                 json_restart =
9904                                                         json_object_new_object();
9905
9906                                                 json_object_int_add(
9907                                                         json_cap,
9908                                                         "gracefulRestartRemoteTimerMsecs",
9909                                                         p->v_gr_restart * 1000);
9910
9911                                                 FOREACH_AFI_SAFI (afi, safi) {
9912                                                         if (CHECK_FLAG(
9913                                                                     p->af_cap
9914                                                                             [afi]
9915                                                                             [safi],
9916                                                                     PEER_CAP_RESTART_AF_RCV)) {
9917                                                                 json_object *
9918                                                                         json_sub =
9919                                                                                 NULL;
9920                                                                 json_sub =
9921                                                                         json_object_new_object();
9922
9923                                                                 if (CHECK_FLAG(
9924                                                                             p->af_cap
9925                                                                                     [afi]
9926                                                                                     [safi],
9927                                                                             PEER_CAP_RESTART_AF_PRESERVE_RCV))
9928                                                                         json_object_boolean_true_add(
9929                                                                                 json_sub,
9930                                                                                 "preserved");
9931                                                                 restart_af_count++;
9932                                                                 json_object_object_add(
9933                                                                         json_restart,
9934                                                                         afi_safi_print(
9935                                                                                 afi,
9936                                                                                 safi),
9937                                                                         json_sub);
9938                                                         }
9939                                                 }
9940                                                 if (!restart_af_count) {
9941                                                         json_object_string_add(
9942                                                                 json_cap,
9943                                                                 "addressFamiliesByPeer",
9944                                                                 "none");
9945                                                         json_object_free(
9946                                                                 json_restart);
9947                                                 } else
9948                                                         json_object_object_add(
9949                                                                 json_cap,
9950                                                                 "addressFamiliesByPeer",
9951                                                                 json_restart);
9952                                         }
9953                                 }
9954                                 json_object_object_add(json_neigh,
9955                                                        "neighborCapabilities",
9956                                                        json_cap);
9957                         } else {
9958                                 vty_out(vty, "  Neighbor capabilities:\n");
9959
9960                                 /* AS4 */
9961                                 if (CHECK_FLAG(p->cap, PEER_CAP_AS4_RCV)
9962                                     || CHECK_FLAG(p->cap, PEER_CAP_AS4_ADV)) {
9963                                         vty_out(vty, "    4 Byte AS:");
9964                                         if (CHECK_FLAG(p->cap,
9965                                                        PEER_CAP_AS4_ADV))
9966                                                 vty_out(vty, " advertised");
9967                                         if (CHECK_FLAG(p->cap,
9968                                                        PEER_CAP_AS4_RCV))
9969                                                 vty_out(vty, " %sreceived",
9970                                                         CHECK_FLAG(
9971                                                                 p->cap,
9972                                                                 PEER_CAP_AS4_ADV)
9973                                                                 ? "and "
9974                                                                 : "");
9975                                         vty_out(vty, "\n");
9976                                 }
9977
9978                                 /* AddPath */
9979                                 if (CHECK_FLAG(p->cap, PEER_CAP_ADDPATH_RCV)
9980                                     || CHECK_FLAG(p->cap,
9981                                                   PEER_CAP_ADDPATH_ADV)) {
9982                                         vty_out(vty, "    AddPath:\n");
9983
9984                                         FOREACH_AFI_SAFI (afi, safi) {
9985                                                 if (CHECK_FLAG(
9986                                                             p->af_cap[afi]
9987                                                                      [safi],
9988                                                             PEER_CAP_ADDPATH_AF_TX_ADV)
9989                                                     || CHECK_FLAG(
9990                                                                p->af_cap[afi]
9991                                                                         [safi],
9992                                                                PEER_CAP_ADDPATH_AF_TX_RCV)) {
9993                                                         vty_out(vty,
9994                                                                 "      %s: TX ",
9995                                                                 afi_safi_print(
9996                                                                         afi,
9997                                                                         safi));
9998
9999                                                         if (CHECK_FLAG(
10000                                                                     p->af_cap
10001                                                                             [afi]
10002                                                                             [safi],
10003                                                                     PEER_CAP_ADDPATH_AF_TX_ADV))
10004                                                                 vty_out(vty,
10005                                                                         "advertised %s",
10006                                                                         afi_safi_print(
10007                                                                                 afi,
10008                                                                                 safi));
10009
10010                                                         if (CHECK_FLAG(
10011                                                                     p->af_cap
10012                                                                             [afi]
10013                                                                             [safi],
10014                                                                     PEER_CAP_ADDPATH_AF_TX_RCV))
10015                                                                 vty_out(vty,
10016                                                                         "%sreceived",
10017                                                                         CHECK_FLAG(
10018                                                                                 p->af_cap
10019                                                                                         [afi]
10020                                                                                         [safi],
10021                                                                                 PEER_CAP_ADDPATH_AF_TX_ADV)
10022                                                                                 ? " and "
10023                                                                                 : "");
10024
10025                                                         vty_out(vty, "\n");
10026                                                 }
10027
10028                                                 if (CHECK_FLAG(
10029                                                             p->af_cap[afi]
10030                                                                      [safi],
10031                                                             PEER_CAP_ADDPATH_AF_RX_ADV)
10032                                                     || CHECK_FLAG(
10033                                                                p->af_cap[afi]
10034                                                                         [safi],
10035                                                                PEER_CAP_ADDPATH_AF_RX_RCV)) {
10036                                                         vty_out(vty,
10037                                                                 "      %s: RX ",
10038                                                                 afi_safi_print(
10039                                                                         afi,
10040                                                                         safi));
10041
10042                                                         if (CHECK_FLAG(
10043                                                                     p->af_cap
10044                                                                             [afi]
10045                                                                             [safi],
10046                                                                     PEER_CAP_ADDPATH_AF_RX_ADV))
10047                                                                 vty_out(vty,
10048                                                                         "advertised %s",
10049                                                                         afi_safi_print(
10050                                                                                 afi,
10051                                                                                 safi));
10052
10053                                                         if (CHECK_FLAG(
10054                                                                     p->af_cap
10055                                                                             [afi]
10056                                                                             [safi],
10057                                                                     PEER_CAP_ADDPATH_AF_RX_RCV))
10058                                                                 vty_out(vty,
10059                                                                         "%sreceived",
10060                                                                         CHECK_FLAG(
10061                                                                                 p->af_cap
10062                                                                                         [afi]
10063                                                                                         [safi],
10064                                                                                 PEER_CAP_ADDPATH_AF_RX_ADV)
10065                                                                                 ? " and "
10066                                                                                 : "");
10067
10068                                                         vty_out(vty, "\n");
10069                                                 }
10070                                         }
10071                                 }
10072
10073                                 /* Dynamic */
10074                                 if (CHECK_FLAG(p->cap, PEER_CAP_DYNAMIC_RCV)
10075                                     || CHECK_FLAG(p->cap,
10076                                                   PEER_CAP_DYNAMIC_ADV)) {
10077                                         vty_out(vty, "    Dynamic:");
10078                                         if (CHECK_FLAG(p->cap,
10079                                                        PEER_CAP_DYNAMIC_ADV))
10080                                                 vty_out(vty, " advertised");
10081                                         if (CHECK_FLAG(p->cap,
10082                                                        PEER_CAP_DYNAMIC_RCV))
10083                                                 vty_out(vty, " %sreceived",
10084                                                         CHECK_FLAG(
10085                                                                 p->cap,
10086                                                                 PEER_CAP_DYNAMIC_ADV)
10087                                                                 ? "and "
10088                                                                 : "");
10089                                         vty_out(vty, "\n");
10090                                 }
10091
10092                                 /* Extended nexthop */
10093                                 if (CHECK_FLAG(p->cap, PEER_CAP_ENHE_RCV)
10094                                     || CHECK_FLAG(p->cap, PEER_CAP_ENHE_ADV)) {
10095                                         vty_out(vty, "    Extended nexthop:");
10096                                         if (CHECK_FLAG(p->cap,
10097                                                        PEER_CAP_ENHE_ADV))
10098                                                 vty_out(vty, " advertised");
10099                                         if (CHECK_FLAG(p->cap,
10100                                                        PEER_CAP_ENHE_RCV))
10101                                                 vty_out(vty, " %sreceived",
10102                                                         CHECK_FLAG(
10103                                                                 p->cap,
10104                                                                 PEER_CAP_ENHE_ADV)
10105                                                                 ? "and "
10106                                                                 : "");
10107                                         vty_out(vty, "\n");
10108
10109                                         if (CHECK_FLAG(p->cap,
10110                                                        PEER_CAP_ENHE_RCV)) {
10111                                                 vty_out(vty,
10112                                                         "      Address families by peer:\n        ");
10113                                                 for (safi = SAFI_UNICAST;
10114                                                      safi < SAFI_MAX; safi++)
10115                                                         if (CHECK_FLAG(
10116                                                                     p->af_cap
10117                                                                             [AFI_IP]
10118                                                                             [safi],
10119                                                                     PEER_CAP_ENHE_AF_RCV))
10120                                                                 vty_out(vty,
10121                                                                         "           %s\n",
10122                                                                         afi_safi_print(
10123                                                                                 AFI_IP,
10124                                                                                 safi));
10125                                         }
10126                                 }
10127
10128                                 /* Route Refresh */
10129                                 if (CHECK_FLAG(p->cap, PEER_CAP_REFRESH_ADV)
10130                                     || CHECK_FLAG(p->cap,
10131                                                   PEER_CAP_REFRESH_NEW_RCV)
10132                                     || CHECK_FLAG(p->cap,
10133                                                   PEER_CAP_REFRESH_OLD_RCV)) {
10134                                         vty_out(vty, "    Route refresh:");
10135                                         if (CHECK_FLAG(p->cap,
10136                                                        PEER_CAP_REFRESH_ADV))
10137                                                 vty_out(vty, " advertised");
10138                                         if (CHECK_FLAG(p->cap,
10139                                                        PEER_CAP_REFRESH_NEW_RCV)
10140                                             || CHECK_FLAG(
10141                                                        p->cap,
10142                                                        PEER_CAP_REFRESH_OLD_RCV))
10143                                                 vty_out(vty, " %sreceived(%s)",
10144                                                         CHECK_FLAG(
10145                                                                 p->cap,
10146                                                                 PEER_CAP_REFRESH_ADV)
10147                                                                 ? "and "
10148                                                                 : "",
10149                                                         (CHECK_FLAG(
10150                                                                  p->cap,
10151                                                                  PEER_CAP_REFRESH_OLD_RCV)
10152                                                          && CHECK_FLAG(
10153                                                                     p->cap,
10154                                                                     PEER_CAP_REFRESH_NEW_RCV))
10155                                                                 ? "old & new"
10156                                                                 : CHECK_FLAG(
10157                                                                           p->cap,
10158                                                                           PEER_CAP_REFRESH_OLD_RCV)
10159                                                                           ? "old"
10160                                                                           : "new");
10161
10162                                         vty_out(vty, "\n");
10163                                 }
10164
10165                                 /* Multiprotocol Extensions */
10166                                 FOREACH_AFI_SAFI (afi, safi)
10167                                         if (p->afc_adv[afi][safi]
10168                                             || p->afc_recv[afi][safi]) {
10169                                                 vty_out(vty,
10170                                                         "    Address Family %s:",
10171                                                         afi_safi_print(afi,
10172                                                                        safi));
10173                                                 if (p->afc_adv[afi][safi])
10174                                                         vty_out(vty,
10175                                                                 " advertised");
10176                                                 if (p->afc_recv[afi][safi])
10177                                                         vty_out(vty,
10178                                                                 " %sreceived",
10179                                                                 p->afc_adv[afi]
10180                                                                           [safi]
10181                                                                         ? "and "
10182                                                                         : "");
10183                                                 vty_out(vty, "\n");
10184                                         }
10185
10186                                 /* Hostname capability */
10187                                 vty_out(vty, "    Hostname Capability:");
10188
10189                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV)) {
10190                                         vty_out(vty,
10191                                                 " advertised (name: %s,domain name: %s)",
10192                                                 bgp->peer_self->hostname
10193                                                         ? bgp->peer_self
10194                                                                   ->hostname
10195                                                         : "n/a",
10196                                                 bgp->peer_self->domainname
10197                                                         ? bgp->peer_self
10198                                                                   ->domainname
10199                                                         : "n/a");
10200                                 } else {
10201                                         vty_out(vty, " not advertised");
10202                                 }
10203
10204                                 if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV)) {
10205                                         vty_out(vty,
10206                                                 " received (name: %s,domain name: %s)",
10207                                                 p->hostname ? p->hostname
10208                                                             : "n/a",
10209                                                 p->domainname ? p->domainname
10210                                                               : "n/a");
10211                                 } else {
10212                                         vty_out(vty, " not received");
10213                                 }
10214
10215                                 vty_out(vty, "\n");
10216
10217                                 /* Gracefull Restart */
10218                                 if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV)
10219                                     || CHECK_FLAG(p->cap,
10220                                                   PEER_CAP_RESTART_ADV)) {
10221                                         vty_out(vty,
10222                                                 "    Graceful Restart Capabilty:");
10223                                         if (CHECK_FLAG(p->cap,
10224                                                        PEER_CAP_RESTART_ADV))
10225                                                 vty_out(vty, " advertised");
10226                                         if (CHECK_FLAG(p->cap,
10227                                                        PEER_CAP_RESTART_RCV))
10228                                                 vty_out(vty, " %sreceived",
10229                                                         CHECK_FLAG(
10230                                                                 p->cap,
10231                                                                 PEER_CAP_RESTART_ADV)
10232                                                                 ? "and "
10233                                                                 : "");
10234                                         vty_out(vty, "\n");
10235
10236                                         if (CHECK_FLAG(p->cap,
10237                                                        PEER_CAP_RESTART_RCV)) {
10238                                                 int restart_af_count = 0;
10239
10240                                                 vty_out(vty,
10241                                                         "      Remote Restart timer is %d seconds\n",
10242                                                         p->v_gr_restart);
10243                                                 vty_out(vty,
10244                                                         "      Address families by peer:\n        ");
10245
10246                                                 FOREACH_AFI_SAFI (afi, safi)
10247                                                         if (CHECK_FLAG(
10248                                                                     p->af_cap
10249                                                                             [afi]
10250                                                                             [safi],
10251                                                                     PEER_CAP_RESTART_AF_RCV)) {
10252                                                                 vty_out(vty,
10253                                                                         "%s%s(%s)",
10254                                                                         restart_af_count
10255                                                                                 ? ", "
10256                                                                                 : "",
10257                                                                         afi_safi_print(
10258                                                                                 afi,
10259                                                                                 safi),
10260                                                                         CHECK_FLAG(
10261                                                                                 p->af_cap
10262                                                                                         [afi]
10263                                                                                         [safi],
10264                                                                                 PEER_CAP_RESTART_AF_PRESERVE_RCV)
10265                                                                                 ? "preserved"
10266                                                                                 : "not preserved");
10267                                                                 restart_af_count++;
10268                                                         }
10269                                                 if (!restart_af_count)
10270                                                         vty_out(vty, "none");
10271                                                 vty_out(vty, "\n");
10272                                         }
10273                                 }
10274                         }
10275                 }
10276         }
10277
10278         /* graceful restart information */
10279         if (CHECK_FLAG(p->cap, PEER_CAP_RESTART_RCV) || p->t_gr_restart
10280             || p->t_gr_stale) {
10281                 json_object *json_grace = NULL;
10282                 json_object *json_grace_send = NULL;
10283                 json_object *json_grace_recv = NULL;
10284                 int eor_send_af_count = 0;
10285                 int eor_receive_af_count = 0;
10286
10287                 if (use_json) {
10288                         json_grace = json_object_new_object();
10289                         json_grace_send = json_object_new_object();
10290                         json_grace_recv = json_object_new_object();
10291
10292                         if (p->status == Established) {
10293                                 FOREACH_AFI_SAFI (afi, safi) {
10294                                         if (CHECK_FLAG(p->af_sflags[afi][safi],
10295                                                        PEER_STATUS_EOR_SEND)) {
10296                                                 json_object_boolean_true_add(
10297                                                         json_grace_send,
10298                                                         afi_safi_print(afi,
10299                                                                        safi));
10300                                                 eor_send_af_count++;
10301                                         }
10302                                 }
10303                                 FOREACH_AFI_SAFI (afi, safi) {
10304                                         if (CHECK_FLAG(
10305                                                     p->af_sflags[afi][safi],
10306                                                     PEER_STATUS_EOR_RECEIVED)) {
10307                                                 json_object_boolean_true_add(
10308                                                         json_grace_recv,
10309                                                         afi_safi_print(afi,
10310                                                                        safi));
10311                                                 eor_receive_af_count++;
10312                                         }
10313                                 }
10314                         }
10315
10316                         json_object_object_add(json_grace, "endOfRibSend",
10317                                                json_grace_send);
10318                         json_object_object_add(json_grace, "endOfRibRecv",
10319                                                json_grace_recv);
10320
10321                         if (p->t_gr_restart)
10322                                 json_object_int_add(json_grace,
10323                                                     "gracefulRestartTimerMsecs",
10324                                                     thread_timer_remain_second(
10325                                                             p->t_gr_restart)
10326                                                             * 1000);
10327
10328                         if (p->t_gr_stale)
10329                                 json_object_int_add(
10330                                         json_grace,
10331                                         "gracefulStalepathTimerMsecs",
10332                                         thread_timer_remain_second(
10333                                                 p->t_gr_stale)
10334                                                 * 1000);
10335
10336                         json_object_object_add(
10337                                 json_neigh, "gracefulRestartInfo", json_grace);
10338                 } else {
10339                         vty_out(vty, "  Graceful restart information:\n");
10340                         if (p->status == Established) {
10341                                 vty_out(vty, "    End-of-RIB send: ");
10342                                 FOREACH_AFI_SAFI (afi, safi) {
10343                                         if (CHECK_FLAG(p->af_sflags[afi][safi],
10344                                                        PEER_STATUS_EOR_SEND)) {
10345                                                 vty_out(vty, "%s%s",
10346                                                         eor_send_af_count ? ", "
10347                                                                           : "",
10348                                                         afi_safi_print(afi,
10349                                                                        safi));
10350                                                 eor_send_af_count++;
10351                                         }
10352                                 }
10353                                 vty_out(vty, "\n");
10354                                 vty_out(vty, "    End-of-RIB received: ");
10355                                 FOREACH_AFI_SAFI (afi, safi) {
10356                                         if (CHECK_FLAG(
10357                                                     p->af_sflags[afi][safi],
10358                                                     PEER_STATUS_EOR_RECEIVED)) {
10359                                                 vty_out(vty, "%s%s",
10360                                                         eor_receive_af_count
10361                                                                 ? ", "
10362                                                                 : "",
10363                                                         afi_safi_print(afi,
10364                                                                        safi));
10365                                                 eor_receive_af_count++;
10366                                         }
10367                                 }
10368                                 vty_out(vty, "\n");
10369                         }
10370
10371                         if (p->t_gr_restart)
10372                                 vty_out(vty,
10373                                         "    The remaining time of restart timer is %ld\n",
10374                                         thread_timer_remain_second(
10375                                                 p->t_gr_restart));
10376
10377                         if (p->t_gr_stale)
10378                                 vty_out(vty,
10379                                         "    The remaining time of stalepath timer is %ld\n",
10380                                         thread_timer_remain_second(
10381                                                 p->t_gr_stale));
10382                 }
10383         }
10384         if (use_json) {
10385                 json_object *json_stat = NULL;
10386                 json_stat = json_object_new_object();
10387                 /* Packet counts. */
10388                 json_object_int_add(json_stat, "depthInq", 0);
10389                 json_object_int_add(json_stat, "depthOutq",
10390                                     (unsigned long)p->obuf->count);
10391                 json_object_int_add(json_stat, "opensSent",
10392                                     atomic_load_explicit(&p->open_out,
10393                                                          memory_order_relaxed));
10394                 json_object_int_add(json_stat, "opensRecv",
10395                                     atomic_load_explicit(&p->open_in,
10396                                                          memory_order_relaxed));
10397                 json_object_int_add(json_stat, "notificationsSent",
10398                                     atomic_load_explicit(&p->notify_out,
10399                                                          memory_order_relaxed));
10400                 json_object_int_add(json_stat, "notificationsRecv",
10401                                     atomic_load_explicit(&p->notify_in,
10402                                                          memory_order_relaxed));
10403                 json_object_int_add(json_stat, "updatesSent",
10404                                     atomic_load_explicit(&p->update_out,
10405                                                          memory_order_relaxed));
10406                 json_object_int_add(json_stat, "updatesRecv",
10407                                     atomic_load_explicit(&p->update_in,
10408                                                          memory_order_relaxed));
10409                 json_object_int_add(json_stat, "keepalivesSent",
10410                                     atomic_load_explicit(&p->keepalive_out,
10411                                                          memory_order_relaxed));
10412                 json_object_int_add(json_stat, "keepalivesRecv",
10413                                     atomic_load_explicit(&p->keepalive_in,
10414                                                          memory_order_relaxed));
10415                 json_object_int_add(json_stat, "routeRefreshSent",
10416                                     atomic_load_explicit(&p->refresh_out,
10417                                                          memory_order_relaxed));
10418                 json_object_int_add(json_stat, "routeRefreshRecv",
10419                                     atomic_load_explicit(&p->refresh_in,
10420                                                          memory_order_relaxed));
10421                 json_object_int_add(json_stat, "capabilitySent",
10422                                     atomic_load_explicit(&p->dynamic_cap_out,
10423                                                          memory_order_relaxed));
10424                 json_object_int_add(json_stat, "capabilityRecv",
10425                                     atomic_load_explicit(&p->dynamic_cap_in,
10426                                                          memory_order_relaxed));
10427                 json_object_int_add(json_stat, "totalSent", PEER_TOTAL_TX(p));
10428                 json_object_int_add(json_stat, "totalRecv", PEER_TOTAL_RX(p));
10429                 json_object_object_add(json_neigh, "messageStats", json_stat);
10430         } else {
10431                 /* Packet counts. */
10432                 vty_out(vty, "  Message statistics:\n");
10433                 vty_out(vty, "    Inq depth is 0\n");
10434                 vty_out(vty, "    Outq depth is %lu\n",
10435                         (unsigned long)p->obuf->count);
10436                 vty_out(vty, "                         Sent       Rcvd\n");
10437                 vty_out(vty, "    Opens:         %10d %10d\n",
10438                         atomic_load_explicit(&p->open_out,
10439                                              memory_order_relaxed),
10440                         atomic_load_explicit(&p->open_in,
10441                                              memory_order_relaxed));
10442                 vty_out(vty, "    Notifications: %10d %10d\n",
10443                         atomic_load_explicit(&p->notify_out,
10444                                              memory_order_relaxed),
10445                         atomic_load_explicit(&p->notify_in,
10446                                              memory_order_relaxed));
10447                 vty_out(vty, "    Updates:       %10d %10d\n",
10448                         atomic_load_explicit(&p->update_out,
10449                                              memory_order_relaxed),
10450                         atomic_load_explicit(&p->update_in,
10451                                              memory_order_relaxed));
10452                 vty_out(vty, "    Keepalives:    %10d %10d\n",
10453                         atomic_load_explicit(&p->keepalive_out,
10454                                              memory_order_relaxed),
10455                         atomic_load_explicit(&p->keepalive_in,
10456                                              memory_order_relaxed));
10457                 vty_out(vty, "    Route Refresh: %10d %10d\n",
10458                         atomic_load_explicit(&p->refresh_out,
10459                                              memory_order_relaxed),
10460                         atomic_load_explicit(&p->refresh_in,
10461                                              memory_order_relaxed));
10462                 vty_out(vty, "    Capability:    %10d %10d\n",
10463                         atomic_load_explicit(&p->dynamic_cap_out,
10464                                              memory_order_relaxed),
10465                         atomic_load_explicit(&p->dynamic_cap_in,
10466                                              memory_order_relaxed));
10467                 vty_out(vty, "    Total:         %10d %10d\n", PEER_TOTAL_TX(p),
10468                         PEER_TOTAL_RX(p));
10469         }
10470
10471         if (use_json) {
10472                 /* advertisement-interval */
10473                 json_object_int_add(json_neigh,
10474                                     "minBtwnAdvertisementRunsTimerMsecs",
10475                                     p->v_routeadv * 1000);
10476
10477                 /* Update-source. */
10478                 if (p->update_if || p->update_source) {
10479                         if (p->update_if)
10480                                 json_object_string_add(json_neigh,
10481                                                        "updateSource",
10482                                                        p->update_if);
10483                         else if (p->update_source)
10484                                 json_object_string_add(
10485                                         json_neigh, "updateSource",
10486                                         sockunion2str(p->update_source, buf1,
10487                                                       SU_ADDRSTRLEN));
10488                 }
10489         } else {
10490                 /* advertisement-interval */
10491                 vty_out(vty,
10492                         "  Minimum time between advertisement runs is %d seconds\n",
10493                         p->v_routeadv);
10494
10495                 /* Update-source. */
10496                 if (p->update_if || p->update_source) {
10497                         vty_out(vty, "  Update source is ");
10498                         if (p->update_if)
10499                                 vty_out(vty, "%s", p->update_if);
10500                         else if (p->update_source)
10501                                 vty_out(vty, "%s",
10502                                         sockunion2str(p->update_source, buf1,
10503                                                       SU_ADDRSTRLEN));
10504                         vty_out(vty, "\n");
10505                 }
10506
10507                 vty_out(vty, "\n");
10508         }
10509
10510         /* Address Family Information */
10511         json_object *json_hold = NULL;
10512
10513         if (use_json)
10514                 json_hold = json_object_new_object();
10515
10516         FOREACH_AFI_SAFI (afi, safi)
10517                 if (p->afc[afi][safi])
10518                         bgp_show_peer_afi(vty, p, afi, safi, use_json,
10519                                           json_hold);
10520
10521         if (use_json) {
10522                 json_object_object_add(json_neigh, "addressFamilyInfo",
10523                                        json_hold);
10524                 json_object_int_add(json_neigh, "connectionsEstablished",
10525                                     p->established);
10526                 json_object_int_add(json_neigh, "connectionsDropped",
10527                                     p->dropped);
10528         } else
10529                 vty_out(vty, "  Connections established %d; dropped %d\n",
10530                         p->established, p->dropped);
10531
10532         if (!p->last_reset) {
10533                 if (use_json)
10534                         json_object_string_add(json_neigh, "lastReset",
10535                                                "never");
10536                 else
10537                         vty_out(vty, "  Last reset never\n");
10538         } else {
10539                 if (use_json) {
10540                         time_t uptime;
10541                         struct tm *tm;
10542
10543                         uptime = bgp_clock();
10544                         uptime -= p->resettime;
10545                         tm = gmtime(&uptime);
10546                         json_object_int_add(json_neigh, "lastResetTimerMsecs",
10547                                             (tm->tm_sec * 1000)
10548                                                     + (tm->tm_min * 60000)
10549                                                     + (tm->tm_hour * 3600000));
10550                         json_object_string_add(
10551                                 json_neigh, "lastResetDueTo",
10552                                 peer_down_str[(int)p->last_reset]);
10553                         if (p->last_reset == PEER_DOWN_NOTIFY_SEND
10554                             || p->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10555                                 char errorcodesubcode_hexstr[5];
10556                                 char errorcodesubcode_str[256];
10557
10558                                 code_str = bgp_notify_code_str(p->notify.code);
10559                                 subcode_str = bgp_notify_subcode_str(
10560                                         p->notify.code, p->notify.subcode);
10561
10562                                 sprintf(errorcodesubcode_hexstr, "%02X%02X",
10563                                         p->notify.code, p->notify.subcode);
10564                                 json_object_string_add(json_neigh,
10565                                                        "lastErrorCodeSubcode",
10566                                                        errorcodesubcode_hexstr);
10567                                 snprintf(errorcodesubcode_str, 255, "%s%s",
10568                                          code_str, subcode_str);
10569                                 json_object_string_add(json_neigh,
10570                                                        "lastNotificationReason",
10571                                                        errorcodesubcode_str);
10572                                 if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10573                                     && p->notify.code == BGP_NOTIFY_CEASE
10574                                     && (p->notify.subcode
10575                                                 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10576                                         || p->notify.subcode
10577                                                    == BGP_NOTIFY_CEASE_ADMIN_RESET)
10578                                     && p->notify.length) {
10579                                         char msgbuf[1024];
10580                                         const char *msg_str;
10581
10582                                         msg_str = bgp_notify_admin_message(
10583                                                 msgbuf, sizeof(msgbuf),
10584                                                 (uint8_t *)p->notify.data,
10585                                                 p->notify.length);
10586                                         if (msg_str)
10587                                                 json_object_string_add(
10588                                                         json_neigh,
10589                                                         "lastShutdownDescription",
10590                                                         msg_str);
10591                                 }
10592                         }
10593                 } else {
10594                         vty_out(vty, "  Last reset %s, ",
10595                                 peer_uptime(p->resettime, timebuf,
10596                                             BGP_UPTIME_LEN, 0, NULL));
10597
10598                         if (p->last_reset == PEER_DOWN_NOTIFY_SEND
10599                             || p->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
10600                                 code_str = bgp_notify_code_str(p->notify.code);
10601                                 subcode_str = bgp_notify_subcode_str(
10602                                         p->notify.code, p->notify.subcode);
10603                                 vty_out(vty, "due to NOTIFICATION %s (%s%s)\n",
10604                                         p->last_reset == PEER_DOWN_NOTIFY_SEND
10605                                                 ? "sent"
10606                                                 : "received",
10607                                         code_str, subcode_str);
10608                                 if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
10609                                     && p->notify.code == BGP_NOTIFY_CEASE
10610                                     && (p->notify.subcode
10611                                                 == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
10612                                         || p->notify.subcode
10613                                                    == BGP_NOTIFY_CEASE_ADMIN_RESET)
10614                                     && p->notify.length) {
10615                                         char msgbuf[1024];
10616                                         const char *msg_str;
10617
10618                                         msg_str = bgp_notify_admin_message(
10619                                                 msgbuf, sizeof(msgbuf),
10620                                                 (uint8_t *)p->notify.data,
10621                                                 p->notify.length);
10622                                         if (msg_str)
10623                                                 vty_out(vty,
10624                                                         "    Message: \"%s\"\n",
10625                                                         msg_str);
10626                                 }
10627                         } else {
10628                                 vty_out(vty, "due to %s\n",
10629                                         peer_down_str[(int)p->last_reset]);
10630                         }
10631
10632                         if (p->last_reset_cause_size) {
10633                                 msg = p->last_reset_cause;
10634                                 vty_out(vty,
10635                                         "  Message received that caused BGP to send a NOTIFICATION:\n    ");
10636                                 for (i = 1; i <= p->last_reset_cause_size;
10637                                      i++) {
10638                                         vty_out(vty, "%02X", *msg++);
10639
10640                                         if (i != p->last_reset_cause_size) {
10641                                                 if (i % 16 == 0) {
10642                                                         vty_out(vty, "\n    ");
10643                                                 } else if (i % 4 == 0) {
10644                                                         vty_out(vty, " ");
10645                                                 }
10646                                         }
10647                                 }
10648                                 vty_out(vty, "\n");
10649                         }
10650                 }
10651         }
10652
10653         if (CHECK_FLAG(p->sflags, PEER_STATUS_PREFIX_OVERFLOW)) {
10654                 if (use_json)
10655                         json_object_boolean_true_add(json_neigh,
10656                                                      "prefixesConfigExceedMax");
10657                 else
10658                         vty_out(vty,
10659                                 "  Peer had exceeded the max. no. of prefixes configured.\n");
10660
10661                 if (p->t_pmax_restart) {
10662                         if (use_json) {
10663                                 json_object_boolean_true_add(
10664                                         json_neigh, "reducePrefixNumFrom");
10665                                 json_object_int_add(json_neigh,
10666                                                     "restartInTimerMsec",
10667                                                     thread_timer_remain_second(
10668                                                             p->t_pmax_restart)
10669                                                             * 1000);
10670                         } else
10671                                 vty_out(vty,
10672                                         "  Reduce the no. of prefix from %s, will restart in %ld seconds\n",
10673                                         p->host, thread_timer_remain_second(
10674                                                          p->t_pmax_restart));
10675                 } else {
10676                         if (use_json)
10677                                 json_object_boolean_true_add(
10678                                         json_neigh,
10679                                         "reducePrefixNumAndClearIpBgp");
10680                         else
10681                                 vty_out(vty,
10682                                         "  Reduce the no. of prefix and clear ip bgp %s to restore peering\n",
10683                                         p->host);
10684                 }
10685         }
10686
10687         /* EBGP Multihop and GTSM */
10688         if (p->sort != BGP_PEER_IBGP) {
10689                 if (use_json) {
10690                         if (p->gtsm_hops > 0)
10691                                 json_object_int_add(json_neigh,
10692                                                     "externalBgpNbrMaxHopsAway",
10693                                                     p->gtsm_hops);
10694                         else if (p->ttl > 1)
10695                                 json_object_int_add(json_neigh,
10696                                                     "externalBgpNbrMaxHopsAway",
10697                                                     p->ttl);
10698                 } else {
10699                         if (p->gtsm_hops > 0)
10700                                 vty_out(vty,
10701                                         "  External BGP neighbor may be up to %d hops away.\n",
10702                                         p->gtsm_hops);
10703                         else if (p->ttl > 1)
10704                                 vty_out(vty,
10705                                         "  External BGP neighbor may be up to %d hops away.\n",
10706                                         p->ttl);
10707                 }
10708         } else {
10709                 if (p->gtsm_hops > 0) {
10710                         if (use_json)
10711                                 json_object_int_add(json_neigh,
10712                                                     "internalBgpNbrMaxHopsAway",
10713                                                     p->gtsm_hops);
10714                         else
10715                                 vty_out(vty,
10716                                         "  Internal BGP neighbor may be up to %d hops away.\n",
10717                                         p->gtsm_hops);
10718                 }
10719         }
10720
10721         /* Local address. */
10722         if (p->su_local) {
10723                 if (use_json) {
10724                         json_object_string_add(json_neigh, "hostLocal",
10725                                                sockunion2str(p->su_local, buf1,
10726                                                              SU_ADDRSTRLEN));
10727                         json_object_int_add(json_neigh, "portLocal",
10728                                             ntohs(p->su_local->sin.sin_port));
10729                 } else
10730                         vty_out(vty, "Local host: %s, Local port: %d\n",
10731                                 sockunion2str(p->su_local, buf1, SU_ADDRSTRLEN),
10732                                 ntohs(p->su_local->sin.sin_port));
10733         }
10734
10735         /* Remote address. */
10736         if (p->su_remote) {
10737                 if (use_json) {
10738                         json_object_string_add(json_neigh, "hostForeign",
10739                                                sockunion2str(p->su_remote, buf1,
10740                                                              SU_ADDRSTRLEN));
10741                         json_object_int_add(json_neigh, "portForeign",
10742                                             ntohs(p->su_remote->sin.sin_port));
10743                 } else
10744                         vty_out(vty, "Foreign host: %s, Foreign port: %d\n",
10745                                 sockunion2str(p->su_remote, buf1,
10746                                               SU_ADDRSTRLEN),
10747                                 ntohs(p->su_remote->sin.sin_port));
10748         }
10749
10750         /* Nexthop display. */
10751         if (p->su_local) {
10752                 if (use_json) {
10753                         json_object_string_add(json_neigh, "nexthop",
10754                                                inet_ntop(AF_INET,
10755                                                          &p->nexthop.v4, buf1,
10756                                                          sizeof(buf1)));
10757                         json_object_string_add(json_neigh, "nexthopGlobal",
10758                                                inet_ntop(AF_INET6,
10759                                                          &p->nexthop.v6_global,
10760                                                          buf1, sizeof(buf1)));
10761                         json_object_string_add(json_neigh, "nexthopLocal",
10762                                                inet_ntop(AF_INET6,
10763                                                          &p->nexthop.v6_local,
10764                                                          buf1, sizeof(buf1)));
10765                         if (p->shared_network)
10766                                 json_object_string_add(json_neigh,
10767                                                        "bgpConnection",
10768                                                        "sharedNetwork");
10769                         else
10770                                 json_object_string_add(json_neigh,
10771                                                        "bgpConnection",
10772                                                        "nonSharedNetwork");
10773                 } else {
10774                         vty_out(vty, "Nexthop: %s\n",
10775                                 inet_ntop(AF_INET, &p->nexthop.v4, buf1,
10776                                           sizeof(buf1)));
10777                         vty_out(vty, "Nexthop global: %s\n",
10778                                 inet_ntop(AF_INET6, &p->nexthop.v6_global, buf1,
10779                                           sizeof(buf1)));
10780                         vty_out(vty, "Nexthop local: %s\n",
10781                                 inet_ntop(AF_INET6, &p->nexthop.v6_local, buf1,
10782                                           sizeof(buf1)));
10783                         vty_out(vty, "BGP connection: %s\n",
10784                                 p->shared_network ? "shared network"
10785                                                   : "non shared network");
10786                 }
10787         }
10788
10789         /* Timer information. */
10790         if (use_json) {
10791                 json_object_int_add(json_neigh, "connectRetryTimer",
10792                                     p->v_connect);
10793                 if (p->status == Established && p->rtt)
10794                         json_object_int_add(json_neigh, "estimatedRttInMsecs",
10795                                             p->rtt);
10796                 if (p->t_start)
10797                         json_object_int_add(
10798                                 json_neigh, "nextStartTimerDueInMsecs",
10799                                 thread_timer_remain_second(p->t_start) * 1000);
10800                 if (p->t_connect)
10801                         json_object_int_add(
10802                                 json_neigh, "nextConnectTimerDueInMsecs",
10803                                 thread_timer_remain_second(p->t_connect)
10804                                         * 1000);
10805                 if (p->t_routeadv) {
10806                         json_object_int_add(json_neigh, "mraiInterval",
10807                                             p->v_routeadv);
10808                         json_object_int_add(
10809                                 json_neigh, "mraiTimerExpireInMsecs",
10810                                 thread_timer_remain_second(p->t_routeadv)
10811                                         * 1000);
10812                 }
10813                 if (p->password)
10814                         json_object_int_add(json_neigh, "authenticationEnabled",
10815                                             1);
10816
10817                 if (p->t_read)
10818                         json_object_string_add(json_neigh, "readThread", "on");
10819                 else
10820                         json_object_string_add(json_neigh, "readThread", "off");
10821
10822                 if (CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON))
10823                         json_object_string_add(json_neigh, "writeThread", "on");
10824                 else
10825                         json_object_string_add(json_neigh, "writeThread",
10826                                                "off");
10827         } else {
10828                 vty_out(vty, "BGP Connect Retry Timer in Seconds: %d\n",
10829                         p->v_connect);
10830                 if (p->status == Established && p->rtt)
10831                         vty_out(vty, "Estimated round trip time: %d ms\n",
10832                                 p->rtt);
10833                 if (p->t_start)
10834                         vty_out(vty, "Next start timer due in %ld seconds\n",
10835                                 thread_timer_remain_second(p->t_start));
10836                 if (p->t_connect)
10837                         vty_out(vty, "Next connect timer due in %ld seconds\n",
10838                                 thread_timer_remain_second(p->t_connect));
10839                 if (p->t_routeadv)
10840                         vty_out(vty,
10841                                 "MRAI (interval %u) timer expires in %ld seconds\n",
10842                                 p->v_routeadv,
10843                                 thread_timer_remain_second(p->t_routeadv));
10844                 if (p->password)
10845                         vty_out(vty, "Peer Authentication Enabled\n");
10846
10847                 vty_out(vty, "Read thread: %s  Write thread: %s  FD used: %d\n",
10848                         p->t_read ? "on" : "off",
10849                         CHECK_FLAG(p->thread_flags, PEER_THREAD_WRITES_ON)
10850                                 ? "on"
10851                                 : "off", p->fd);
10852         }
10853
10854         if (p->notify.code == BGP_NOTIFY_OPEN_ERR
10855             && p->notify.subcode == BGP_NOTIFY_OPEN_UNSUP_CAPBL)
10856                 bgp_capability_vty_out(vty, p, use_json, json_neigh);
10857
10858         if (!use_json)
10859                 vty_out(vty, "\n");
10860
10861         /* BFD information. */
10862         bgp_bfd_show_info(vty, p, use_json, json_neigh);
10863
10864         if (use_json) {
10865                 if (p->conf_if) /* Configured interface name. */
10866                         json_object_object_add(json, p->conf_if, json_neigh);
10867                 else /* Configured IP address. */
10868                         json_object_object_add(json, p->host, json_neigh);
10869         }
10870 }
10871
10872 static int bgp_show_neighbor(struct vty *vty, struct bgp *bgp,
10873                              enum show_type type, union sockunion *su,
10874                              const char *conf_if, bool use_json,
10875                              json_object *json)
10876 {
10877         struct listnode *node, *nnode;
10878         struct peer *peer;
10879         int find = 0;
10880         bool nbr_output = false;
10881         afi_t afi = AFI_MAX;
10882         safi_t safi = SAFI_MAX;
10883
10884         if (type == show_ipv4_peer || type == show_ipv4_all) {
10885                 afi = AFI_IP;
10886         } else if (type == show_ipv6_peer || type == show_ipv6_all) {
10887                 afi = AFI_IP6;
10888         }
10889
10890         for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
10891                 if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
10892                         continue;
10893
10894                 switch (type) {
10895                 case show_all:
10896                         bgp_show_peer(vty, peer, use_json, json);
10897                         nbr_output = true;
10898                         break;
10899                 case show_peer:
10900                         if (conf_if) {
10901                                 if ((peer->conf_if
10902                                      && !strcmp(peer->conf_if, conf_if))
10903                                     || (peer->hostname
10904                                         && !strcmp(peer->hostname, conf_if))) {
10905                                         find = 1;
10906                                         bgp_show_peer(vty, peer, use_json,
10907                                                       json);
10908                                 }
10909                         } else {
10910                                 if (sockunion_same(&peer->su, su)) {
10911                                         find = 1;
10912                                         bgp_show_peer(vty, peer, use_json,
10913                                                       json);
10914                                 }
10915                         }
10916                         break;
10917                 case show_ipv4_peer:
10918                 case show_ipv6_peer:
10919                         FOREACH_SAFI (safi) {
10920                                 if (peer->afc[afi][safi]) {
10921                                         if (conf_if) {
10922                                                 if ((peer->conf_if
10923                                                      && !strcmp(peer->conf_if, conf_if))
10924                                                     || (peer->hostname
10925                                                         && !strcmp(peer->hostname, conf_if))) {
10926                                                         find = 1;
10927                                                         bgp_show_peer(vty, peer, use_json,
10928                                                                       json);
10929                                                         break;
10930                                                 }
10931                                         } else {
10932                                                 if (sockunion_same(&peer->su, su)) {
10933                                                         find = 1;
10934                                                         bgp_show_peer(vty, peer, use_json,
10935                                                                       json);
10936                                                         break;
10937                                                 }
10938                                         }
10939                                 }
10940                         }
10941                         break;
10942                 case show_ipv4_all:
10943                 case show_ipv6_all:
10944                         FOREACH_SAFI (safi) {
10945                                 if (peer->afc[afi][safi]) {
10946                                         bgp_show_peer(vty, peer, use_json, json);
10947                                         nbr_output = true;
10948                                         break;
10949                                 }
10950                         }
10951                         break;
10952                 }
10953         }
10954
10955         if ((type == show_peer || type == show_ipv4_peer ||
10956              type == show_ipv6_peer) && !find) {
10957                 if (use_json)
10958                         json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
10959                 else
10960                         vty_out(vty, "%% No such neighbor in this view/vrf\n");
10961         }
10962
10963         if (type != show_peer && type != show_ipv4_peer &&
10964             type != show_ipv6_peer && !nbr_output && !use_json)
10965                 vty_out(vty, "%% No BGP neighbors found\n");
10966
10967         if (use_json) {
10968                 vty_out(vty, "%s\n", json_object_to_json_string_ext(
10969                                              json, JSON_C_TO_STRING_PRETTY));
10970         } else {
10971                 vty_out(vty, "\n");
10972         }
10973
10974         return CMD_SUCCESS;
10975 }
10976
10977 static void bgp_show_all_instances_neighbors_vty(struct vty *vty,
10978                                                  enum show_type type,
10979                                                  const char *ip_str,
10980                                                  bool use_json)
10981 {
10982         struct listnode *node, *nnode;
10983         struct bgp *bgp;
10984         union sockunion su;
10985         json_object *json = NULL;
10986         int ret, is_first = 1;
10987         bool nbr_output = false;
10988
10989         if (use_json)
10990                 vty_out(vty, "{\n");
10991
10992         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
10993                 nbr_output = true;
10994                 if (use_json) {
10995                         if (!(json = json_object_new_object())) {
10996                                 flog_err(
10997                                         EC_BGP_JSON_MEM_ERROR,
10998                                         "Unable to allocate memory for JSON object");
10999                                 vty_out(vty,
11000                                         "{\"error\": {\"message:\": \"Unable to allocate memory for JSON object\"}}}\n");
11001                                 return;
11002                         }
11003
11004                         json_object_int_add(json, "vrfId",
11005                                             (bgp->vrf_id == VRF_UNKNOWN)
11006                                                     ? -1
11007                                                     : (int64_t)bgp->vrf_id);
11008                         json_object_string_add(
11009                                 json, "vrfName",
11010                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11011                                         ? VRF_DEFAULT_NAME
11012                                         : bgp->name);
11013
11014                         if (!is_first)
11015                                 vty_out(vty, ",\n");
11016                         else
11017                                 is_first = 0;
11018
11019                         vty_out(vty, "\"%s\":",
11020                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11021                                         ? VRF_DEFAULT_NAME
11022                                         : bgp->name);
11023                 } else {
11024                         vty_out(vty, "\nInstance %s:\n",
11025                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11026                                         ? VRF_DEFAULT_NAME
11027                                         : bgp->name);
11028                 }
11029
11030                 if (type == show_peer || type == show_ipv4_peer ||
11031                     type == show_ipv6_peer) {
11032                         ret = str2sockunion(ip_str, &su);
11033                         if (ret < 0)
11034                                 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
11035                                                   use_json, json);
11036                         else
11037                                 bgp_show_neighbor(vty, bgp, type, &su, NULL,
11038                                                   use_json, json);
11039                 } else {
11040                         bgp_show_neighbor(vty, bgp, type, NULL, NULL,
11041                                           use_json, json);
11042                 }
11043                 json_object_free(json);
11044         }
11045
11046         if (use_json) {
11047                 vty_out(vty, "}\n");
11048                 json_object_free(json);
11049         }
11050         else if (!nbr_output)
11051                 vty_out(vty, "%% BGP instance not found\n");
11052 }
11053
11054 static int bgp_show_neighbor_vty(struct vty *vty, const char *name,
11055                                  enum show_type type, const char *ip_str,
11056                                  bool use_json)
11057 {
11058         int ret;
11059         struct bgp *bgp;
11060         union sockunion su;
11061         json_object *json = NULL;
11062
11063         if (name) {
11064                 if (strmatch(name, "all")) {
11065                         bgp_show_all_instances_neighbors_vty(vty, type, ip_str,
11066                                                              use_json);
11067                         return CMD_SUCCESS;
11068                 } else {
11069                         bgp = bgp_lookup_by_name(name);
11070                         if (!bgp) {
11071                                 if (use_json) {
11072                                         json = json_object_new_object();
11073                                         vty_out(vty, "%s\n",
11074                                                 json_object_to_json_string_ext(
11075                                                         json,
11076                                                         JSON_C_TO_STRING_PRETTY));
11077                                         json_object_free(json);
11078                                 } else
11079                                         vty_out(vty,
11080                                                 "%% BGP instance not found\n");
11081
11082                                 return CMD_WARNING;
11083                         }
11084                 }
11085         } else {
11086                 bgp = bgp_get_default();
11087         }
11088
11089         if (bgp) {
11090                 json = json_object_new_object();
11091                 if (ip_str) {
11092                         ret = str2sockunion(ip_str, &su);
11093                         if (ret < 0)
11094                                 bgp_show_neighbor(vty, bgp, type, NULL, ip_str,
11095                                                   use_json, json);
11096                         else
11097                                 bgp_show_neighbor(vty, bgp, type, &su, NULL,
11098                                                   use_json, json);
11099                 } else {
11100                         bgp_show_neighbor(vty, bgp, type, NULL, NULL, use_json,
11101                                           json);
11102                 }
11103                 json_object_free(json);
11104         } else {
11105                 if (use_json)
11106                         vty_out(vty, "{}\n");
11107                 else
11108                         vty_out(vty, "%% BGP instance not found\n");
11109         }
11110
11111         return CMD_SUCCESS;
11112 }
11113
11114 /* "show [ip] bgp neighbors" commands.  */
11115 DEFUN (show_ip_bgp_neighbors,
11116        show_ip_bgp_neighbors_cmd,
11117        "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6>] neighbors [<A.B.C.D|X:X::X:X|WORD>] [json]",
11118        SHOW_STR
11119        IP_STR
11120        BGP_STR
11121        BGP_INSTANCE_HELP_STR
11122        "Address Family\n"
11123        "Address Family\n"
11124        "Detailed information on TCP and BGP neighbor connections\n"
11125        "Neighbor to display information about\n"
11126        "Neighbor to display information about\n"
11127        "Neighbor on BGP configured interface\n"
11128        JSON_STR)
11129 {
11130         char *vrf = NULL;
11131         char *sh_arg = NULL;
11132         enum show_type sh_type;
11133         afi_t afi = AFI_MAX;
11134
11135         bool uj = use_json(argc, argv);
11136
11137         int idx = 0;
11138
11139         /* [<vrf> VIEWVRFNAME] */
11140         if (argv_find(argv, argc, "vrf", &idx)) {
11141                 vrf = argv[idx + 1]->arg;
11142                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11143                         vrf = NULL;
11144         } else if (argv_find(argv, argc, "view", &idx))
11145                 /* [<view> VIEWVRFNAME] */
11146                 vrf = argv[idx + 1]->arg;
11147
11148         idx++;
11149
11150         if (argv_find(argv, argc, "ipv4", &idx)) {
11151                 sh_type = show_ipv4_all;
11152                 afi = AFI_IP;
11153         } else if (argv_find(argv, argc, "ipv6", &idx)) {
11154                 sh_type = show_ipv6_all;
11155                 afi = AFI_IP6;
11156         } else {
11157                 sh_type = show_all;
11158         }
11159
11160         if (argv_find(argv, argc, "A.B.C.D", &idx)
11161             || argv_find(argv, argc, "X:X::X:X", &idx)
11162             || argv_find(argv, argc, "WORD", &idx)) {
11163                 sh_type = show_peer;
11164                 sh_arg = argv[idx]->arg;
11165         }
11166
11167         if (sh_type == show_peer && afi == AFI_IP) {
11168                 sh_type = show_ipv4_peer;
11169         } else if (sh_type == show_peer && afi == AFI_IP6) {
11170                 sh_type = show_ipv6_peer;
11171         }
11172
11173         return bgp_show_neighbor_vty(vty, vrf, sh_type, sh_arg, uj);
11174 }
11175
11176 /* Show BGP's AS paths internal data.  There are both `show [ip] bgp
11177    paths' and `show ip mbgp paths'.  Those functions results are the
11178    same.*/
11179 DEFUN (show_ip_bgp_paths,
11180        show_ip_bgp_paths_cmd,
11181        "show [ip] bgp ["BGP_SAFI_CMD_STR"] paths",
11182        SHOW_STR
11183        IP_STR
11184        BGP_STR
11185        BGP_SAFI_HELP_STR
11186        "Path information\n")
11187 {
11188         vty_out(vty, "Address Refcnt Path\n");
11189         aspath_print_all_vty(vty);
11190         return CMD_SUCCESS;
11191 }
11192
11193 #include "hash.h"
11194
11195 static void community_show_all_iterator(struct hash_bucket *bucket,
11196                                         struct vty *vty)
11197 {
11198         struct community *com;
11199
11200         com = (struct community *)bucket->data;
11201         vty_out(vty, "[%p] (%ld) %s\n", (void *)com, com->refcnt,
11202                 community_str(com, false));
11203 }
11204
11205 /* Show BGP's community internal data. */
11206 DEFUN (show_ip_bgp_community_info,
11207        show_ip_bgp_community_info_cmd,
11208        "show [ip] bgp community-info",
11209        SHOW_STR
11210        IP_STR
11211        BGP_STR
11212        "List all bgp community information\n")
11213 {
11214         vty_out(vty, "Address Refcnt Community\n");
11215
11216         hash_iterate(community_hash(),
11217                      (void (*)(struct hash_bucket *,
11218                                void *))community_show_all_iterator,
11219                      vty);
11220
11221         return CMD_SUCCESS;
11222 }
11223
11224 static void lcommunity_show_all_iterator(struct hash_bucket *bucket,
11225                                          struct vty *vty)
11226 {
11227         struct lcommunity *lcom;
11228
11229         lcom = (struct lcommunity *)bucket->data;
11230         vty_out(vty, "[%p] (%ld) %s\n", (void *)lcom, lcom->refcnt,
11231                 lcommunity_str(lcom, false));
11232 }
11233
11234 /* Show BGP's community internal data. */
11235 DEFUN (show_ip_bgp_lcommunity_info,
11236        show_ip_bgp_lcommunity_info_cmd,
11237        "show ip bgp large-community-info",
11238        SHOW_STR
11239        IP_STR
11240        BGP_STR
11241        "List all bgp large-community information\n")
11242 {
11243         vty_out(vty, "Address Refcnt Large-community\n");
11244
11245         hash_iterate(lcommunity_hash(),
11246                      (void (*)(struct hash_bucket *,
11247                                void *))lcommunity_show_all_iterator,
11248                      vty);
11249
11250         return CMD_SUCCESS;
11251 }
11252
11253
11254 DEFUN (show_ip_bgp_attr_info,
11255        show_ip_bgp_attr_info_cmd,
11256        "show [ip] bgp attribute-info",
11257        SHOW_STR
11258        IP_STR
11259        BGP_STR
11260        "List all bgp attribute information\n")
11261 {
11262         attr_show_all(vty);
11263         return CMD_SUCCESS;
11264 }
11265
11266 static int bgp_show_route_leak_vty(struct vty *vty, const char *name,
11267                                    afi_t afi, safi_t safi,
11268                                    bool use_json, json_object *json)
11269 {
11270         struct bgp *bgp;
11271         struct listnode *node;
11272         char *vname;
11273         char buf1[INET6_ADDRSTRLEN];
11274         char *ecom_str;
11275         vpn_policy_direction_t dir;
11276
11277         if (json) {
11278                 json_object *json_import_vrfs = NULL;
11279                 json_object *json_export_vrfs = NULL;
11280
11281                 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11282
11283                 if (!bgp) {
11284                         vty_out(vty, "%s\n",
11285                                 json_object_to_json_string_ext(
11286                                         json,
11287                                         JSON_C_TO_STRING_PRETTY));
11288                         json_object_free(json);
11289
11290                         return CMD_WARNING;
11291                 }
11292
11293                 /* Provide context for the block */
11294                 json_object_string_add(json, "vrf", name ? name : "default");
11295                 json_object_string_add(json, "afiSafi",
11296                                        afi_safi_print(afi, safi));
11297
11298                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11299                                 BGP_CONFIG_VRF_TO_VRF_IMPORT)) {
11300                         json_object_string_add(json, "importFromVrfs", "none");
11301                         json_object_string_add(json, "importRts", "none");
11302                 } else {
11303                         json_import_vrfs = json_object_new_array();
11304
11305                         for (ALL_LIST_ELEMENTS_RO(
11306                                                 bgp->vpn_policy[afi].import_vrf,
11307                                                 node, vname))
11308                                 json_object_array_add(json_import_vrfs,
11309                                                 json_object_new_string(vname));
11310
11311                         json_object_object_add(json, "importFromVrfs",
11312                                                        json_import_vrfs);
11313                         dir = BGP_VPN_POLICY_DIR_FROMVPN;
11314                         if (bgp->vpn_policy[afi].rtlist[dir]) {
11315                                 ecom_str = ecommunity_ecom2str(
11316                                         bgp->vpn_policy[afi].rtlist[dir],
11317                                         ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11318                                 json_object_string_add(json, "importRts",
11319                                                        ecom_str);
11320                                 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11321                         } else
11322                                 json_object_string_add(json, "importRts",
11323                                                        "none");
11324                 }
11325
11326                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11327                                 BGP_CONFIG_VRF_TO_VRF_EXPORT)) {
11328                         json_object_string_add(json, "exportToVrfs", "none");
11329                         json_object_string_add(json, "routeDistinguisher",
11330                                                "none");
11331                         json_object_string_add(json, "exportRts", "none");
11332                 } else {
11333                         json_export_vrfs = json_object_new_array();
11334
11335                         for (ALL_LIST_ELEMENTS_RO(
11336                                                 bgp->vpn_policy[afi].export_vrf,
11337                                                 node, vname))
11338                                 json_object_array_add(json_export_vrfs,
11339                                                 json_object_new_string(vname));
11340                         json_object_object_add(json, "exportToVrfs",
11341                                                json_export_vrfs);
11342                         json_object_string_add(json, "routeDistinguisher",
11343                                    prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd,
11344                                                  buf1, RD_ADDRSTRLEN));
11345
11346                         dir = BGP_VPN_POLICY_DIR_TOVPN;
11347                         if (bgp->vpn_policy[afi].rtlist[dir]) {
11348                                 ecom_str = ecommunity_ecom2str(
11349                                                bgp->vpn_policy[afi].rtlist[dir],
11350                                                ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11351                                 json_object_string_add(json, "exportRts",
11352                                                        ecom_str);
11353                                 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11354                         } else
11355                                 json_object_string_add(json, "exportRts",
11356                                                        "none");
11357                 }
11358
11359                 if (use_json) {
11360                         vty_out(vty, "%s\n",
11361                                 json_object_to_json_string_ext(json,
11362                                                       JSON_C_TO_STRING_PRETTY));
11363                         json_object_free(json);
11364                 }
11365         } else {
11366                 bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11367
11368                 if (!bgp) {
11369                         vty_out(vty, "%% No such BGP instance exist\n");
11370                         return CMD_WARNING;
11371                 }
11372
11373                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11374                                 BGP_CONFIG_VRF_TO_VRF_IMPORT))
11375                         vty_out(vty,
11376                      "This VRF is not importing %s routes from any other VRF\n",
11377                       afi_safi_print(afi, safi));
11378                 else {
11379                         vty_out(vty,
11380                    "This VRF is importing %s routes from the following VRFs:\n",
11381                     afi_safi_print(afi, safi));
11382
11383                         for (ALL_LIST_ELEMENTS_RO(
11384                                                 bgp->vpn_policy[afi].import_vrf,
11385                                                 node, vname))
11386                                 vty_out(vty, "  %s\n", vname);
11387
11388                         dir = BGP_VPN_POLICY_DIR_FROMVPN;
11389                         ecom_str = NULL;
11390                         if (bgp->vpn_policy[afi].rtlist[dir]) {
11391                                 ecom_str = ecommunity_ecom2str(
11392                                                bgp->vpn_policy[afi].rtlist[dir],
11393                                                ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11394                                 vty_out(vty, "Import RT(s): %s\n", ecom_str);
11395
11396                                 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11397                         } else
11398                                 vty_out(vty, "Import RT(s):\n");
11399                 }
11400
11401                 if (!CHECK_FLAG(bgp->af_flags[afi][safi],
11402                                 BGP_CONFIG_VRF_TO_VRF_EXPORT))
11403                         vty_out(vty,
11404                        "This VRF is not exporting %s routes to any other VRF\n",
11405                         afi_safi_print(afi, safi));
11406                 else {
11407                         vty_out(vty,
11408                        "This VRF is exporting %s routes to the following VRFs:\n",
11409                         afi_safi_print(afi, safi));
11410
11411                         for (ALL_LIST_ELEMENTS_RO(
11412                                                 bgp->vpn_policy[afi].export_vrf,
11413                                                 node, vname))
11414                                 vty_out(vty, "  %s\n", vname);
11415
11416                         vty_out(vty, "RD: %s\n",
11417                                 prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd,
11418                                               buf1, RD_ADDRSTRLEN));
11419
11420                         dir = BGP_VPN_POLICY_DIR_TOVPN;
11421                         if (bgp->vpn_policy[afi].rtlist[dir]) {
11422                                 ecom_str = ecommunity_ecom2str(
11423                                         bgp->vpn_policy[afi].rtlist[dir],
11424                                         ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
11425                                 vty_out(vty, "Export RT: %s\n", ecom_str);
11426                                 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
11427                         } else
11428                                 vty_out(vty, "Import RT(s):\n");
11429                 }
11430         }
11431
11432         return CMD_SUCCESS;
11433 }
11434
11435 static int bgp_show_all_instance_route_leak_vty(struct vty *vty, afi_t afi,
11436                                                 safi_t safi, bool use_json)
11437 {
11438         struct listnode *node, *nnode;
11439         struct bgp *bgp;
11440         char *vrf_name = NULL;
11441         json_object *json = NULL;
11442         json_object *json_vrf = NULL;
11443         json_object *json_vrfs = NULL;
11444
11445         if (use_json) {
11446                 json = json_object_new_object();
11447                 json_vrfs = json_object_new_object();
11448         }
11449
11450         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
11451
11452                 if (bgp->inst_type != BGP_INSTANCE_TYPE_DEFAULT)
11453                         vrf_name = bgp->name;
11454
11455                 if (use_json) {
11456                         json_vrf = json_object_new_object();
11457                 } else {
11458                         vty_out(vty, "\nInstance %s:\n",
11459                                 (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11460                                 ? VRF_DEFAULT_NAME : bgp->name);
11461                 }
11462                 bgp_show_route_leak_vty(vty, vrf_name, afi, safi, 0, json_vrf);
11463                 if (use_json) {
11464                         if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11465                                 json_object_object_add(json_vrfs,
11466                                                 VRF_DEFAULT_NAME, json_vrf);
11467                         else
11468                                 json_object_object_add(json_vrfs, vrf_name,
11469                                                        json_vrf);
11470                 }
11471         }
11472
11473         if (use_json) {
11474                 json_object_object_add(json, "vrfs", json_vrfs);
11475                 vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
11476                                                 JSON_C_TO_STRING_PRETTY));
11477                 json_object_free(json);
11478         }
11479
11480         return CMD_SUCCESS;
11481 }
11482
11483 /* "show [ip] bgp route-leak" command.  */
11484 DEFUN (show_ip_bgp_route_leak,
11485         show_ip_bgp_route_leak_cmd,
11486         "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] route-leak  [json]",
11487         SHOW_STR
11488         IP_STR
11489         BGP_STR
11490         BGP_INSTANCE_HELP_STR
11491         BGP_AFI_HELP_STR
11492         BGP_SAFI_HELP_STR
11493         "Route leaking information\n"
11494         JSON_STR)
11495 {
11496         char *vrf = NULL;
11497         afi_t afi = AFI_MAX;
11498         safi_t safi = SAFI_MAX;
11499
11500         bool uj = use_json(argc, argv);
11501         int idx = 0;
11502         json_object *json = NULL;
11503
11504         /* show [ip] bgp */
11505         if (argv_find(argv, argc, "ip", &idx)) {
11506                 afi = AFI_IP;
11507                 safi = SAFI_UNICAST;
11508         }
11509         /* [vrf VIEWVRFNAME] */
11510         if (argv_find(argv, argc, "view", &idx)) {
11511                 vty_out(vty,
11512                         "%% This command is not applicable to BGP views\n");
11513                 return CMD_WARNING;
11514         }
11515
11516         if (argv_find(argv, argc, "vrf", &idx)) {
11517                 vrf = argv[idx + 1]->arg;
11518                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11519                         vrf = NULL;
11520         }
11521         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
11522         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
11523                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
11524         }
11525
11526         if (!((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST)) {
11527                 vty_out(vty,
11528                         "%% This command is applicable only for unicast ipv4|ipv6\n");
11529                 return CMD_WARNING;
11530         }
11531
11532         if (vrf && strmatch(vrf, "all"))
11533                 return bgp_show_all_instance_route_leak_vty(vty, afi, safi, uj);
11534
11535         if (uj)
11536                 json = json_object_new_object();
11537
11538         return bgp_show_route_leak_vty(vty, vrf, afi, safi, uj, json);
11539 }
11540
11541 static void bgp_show_all_instances_updgrps_vty(struct vty *vty, afi_t afi,
11542                                                safi_t safi)
11543 {
11544         struct listnode *node, *nnode;
11545         struct bgp *bgp;
11546
11547         for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
11548                 vty_out(vty, "\nInstance %s:\n",
11549                         (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
11550                                 ? VRF_DEFAULT_NAME
11551                                 : bgp->name);
11552                 update_group_show(bgp, afi, safi, vty, 0);
11553         }
11554 }
11555
11556 static int bgp_show_update_groups(struct vty *vty, const char *name, int afi,
11557                                   int safi, uint64_t subgrp_id)
11558 {
11559         struct bgp *bgp;
11560
11561         if (name) {
11562                 if (strmatch(name, "all")) {
11563                         bgp_show_all_instances_updgrps_vty(vty, afi, safi);
11564                         return CMD_SUCCESS;
11565                 } else {
11566                         bgp = bgp_lookup_by_name(name);
11567                 }
11568         } else {
11569                 bgp = bgp_get_default();
11570         }
11571
11572         if (bgp)
11573                 update_group_show(bgp, afi, safi, vty, subgrp_id);
11574         return CMD_SUCCESS;
11575 }
11576
11577 DEFUN (show_ip_bgp_updgrps,
11578        show_ip_bgp_updgrps_cmd,
11579        "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] update-groups [SUBGROUP-ID]",
11580        SHOW_STR
11581        IP_STR
11582        BGP_STR
11583        BGP_INSTANCE_HELP_STR
11584        BGP_AFI_HELP_STR
11585        BGP_SAFI_WITH_LABEL_HELP_STR
11586        "Detailed info about dynamic update groups\n"
11587        "Specific subgroup to display detailed info for\n")
11588 {
11589         char *vrf = NULL;
11590         afi_t afi = AFI_IP6;
11591         safi_t safi = SAFI_UNICAST;
11592         uint64_t subgrp_id = 0;
11593
11594         int idx = 0;
11595
11596         /* show [ip] bgp */
11597         if (argv_find(argv, argc, "ip", &idx))
11598                 afi = AFI_IP;
11599         /* [<vrf> VIEWVRFNAME] */
11600         if (argv_find(argv, argc, "vrf", &idx)) {
11601                 vrf = argv[idx + 1]->arg;
11602                 if (vrf && strmatch(vrf, VRF_DEFAULT_NAME))
11603                         vrf = NULL;
11604         } else if (argv_find(argv, argc, "view", &idx))
11605                 /* [<view> VIEWVRFNAME] */
11606                 vrf = argv[idx + 1]->arg;
11607         /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
11608         if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
11609                 argv_find_and_parse_safi(argv, argc, &idx, &safi);
11610         }
11611
11612         /* get subgroup id, if provided */
11613         idx = argc - 1;
11614         if (argv[idx]->type == VARIABLE_TKN)
11615                 subgrp_id = strtoull(argv[idx]->arg, NULL, 10);
11616
11617         return (bgp_show_update_groups(vty, vrf, afi, safi, subgrp_id));
11618 }
11619
11620 DEFUN (show_bgp_instance_all_ipv6_updgrps,
11621        show_bgp_instance_all_ipv6_updgrps_cmd,
11622        "show [ip] bgp <view|vrf> all update-groups",
11623        SHOW_STR
11624        IP_STR
11625        BGP_STR
11626        BGP_INSTANCE_ALL_HELP_STR
11627        "Detailed info about dynamic update groups\n")
11628 {
11629         bgp_show_all_instances_updgrps_vty(vty, AFI_IP6, SAFI_UNICAST);
11630         return CMD_SUCCESS;
11631 }
11632
11633 DEFUN (show_bgp_l2vpn_evpn_updgrps,
11634         show_bgp_l2vpn_evpn_updgrps_cmd,
11635         "show [ip] bgp l2vpn evpn update-groups",
11636         SHOW_STR
11637         IP_STR
11638         BGP_STR
11639         "l2vpn address family\n"
11640         "evpn sub-address family\n"
11641         "Detailed info about dynamic update groups\n")
11642 {
11643         char *vrf = NULL;
11644         uint64_t subgrp_id = 0;
11645
11646         bgp_show_update_groups(vty, vrf, AFI_L2VPN, SAFI_EVPN, subgrp_id);
11647         return CMD_SUCCESS;
11648 }
11649
11650 DEFUN (show_bgp_updgrps_stats,
11651        show_bgp_updgrps_stats_cmd,
11652        "show [ip] bgp update-groups statistics",
11653        SHOW_STR
11654        IP_STR
11655        BGP_STR
11656        "Detailed info about dynamic update groups\n"
11657        "Statistics\n")
11658 {
11659         struct bgp *bgp;
11660
11661         bgp = bgp_get_default();
11662         if (bgp)
11663                 update_group_show_stats(bgp, vty);
11664
11665         return CMD_SUCCESS;
11666 }
11667
11668 DEFUN (show_bgp_instance_updgrps_stats,
11669        show_bgp_instance_updgrps_stats_cmd,
11670        "show [ip] bgp <view|vrf> VIEWVRFNAME update-groups statistics",
11671        SHOW_STR
11672        IP_STR
11673        BGP_STR
11674        BGP_INSTANCE_HELP_STR
11675        "Detailed info about dynamic update groups\n"
11676        "Statistics\n")
11677 {
11678         int idx_word = 3;
11679         struct bgp *bgp;
11680
11681         bgp = bgp_lookup_by_name(argv[idx_word]->arg);
11682         if (bgp)
11683                 update_group_show_stats(bgp, vty);
11684
11685         return CMD_SUCCESS;
11686 }
11687
11688 static void show_bgp_updgrps_adj_info_aux(struct vty *vty, const char *name,
11689                                           afi_t afi, safi_t safi,
11690                                           const char *what, uint64_t subgrp_id)
11691 {
11692         struct bgp *bgp;
11693
11694         if (name)
11695                 bgp = bgp_lookup_by_name(name);
11696         else
11697                 bgp = bgp_get_default();
11698
11699         if (bgp) {
11700                 if (!strcmp(what, "advertise-queue"))
11701                         update_group_show_adj_queue(bgp, afi, safi, vty,
11702                                                     subgrp_id);
11703                 else if (!strcmp(what, "advertised-routes"))
11704                         update_group_show_advertised(bgp, afi, safi, vty,
11705                                                      subgrp_id);
11706                 else if (!strcmp(what, "packet-queue"))
11707                         update_group_show_packet_queue(bgp, afi, safi, vty,
11708                                                        subgrp_id);
11709         }
11710 }
11711
11712 DEFPY(show_ip_bgp_instance_updgrps_adj_s,
11713       show_ip_bgp_instance_updgrps_adj_s_cmd,
11714       "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",
11715       SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
11716               BGP_SAFI_HELP_STR
11717       "Detailed info about dynamic update groups\n"
11718       "Specific subgroup to display info for\n"
11719       "Advertisement queue\n"
11720       "Announced routes\n"
11721       "Packet queue\n")
11722 {
11723         uint64_t subgrp_id = 0;
11724         afi_t afiz;
11725         safi_t safiz;
11726         if (sgid)
11727                 subgrp_id = strtoull(sgid, NULL, 10);
11728
11729         if (!ip && !afi)
11730                 afiz = AFI_IP6;
11731         if (!ip && afi)
11732                 afiz = bgp_vty_afi_from_str(afi);
11733         if (ip && !afi)
11734                 afiz = AFI_IP;
11735         if (ip && afi) {
11736                 afiz = bgp_vty_afi_from_str(afi);
11737                 if (afiz != AFI_IP)
11738                         vty_out(vty,
11739                                 "%% Cannot specify both 'ip' and 'ipv6'\n");
11740                 return CMD_WARNING;
11741         }
11742
11743         safiz = safi ? bgp_vty_safi_from_str(safi) : SAFI_UNICAST;
11744
11745         show_bgp_updgrps_adj_info_aux(vty, vrf, afiz, safiz, rtq, subgrp_id);
11746         return CMD_SUCCESS;
11747 }
11748
11749 static int bgp_show_one_peer_group(struct vty *vty, struct peer_group *group)
11750 {
11751         struct listnode *node, *nnode;
11752         struct prefix *range;
11753         struct peer *conf;
11754         struct peer *peer;
11755         char buf[PREFIX2STR_BUFFER];
11756         afi_t afi;
11757         safi_t safi;
11758         const char *peer_status;
11759         const char *af_str;
11760         int lr_count;
11761         int dynamic;
11762         int af_cfgd;
11763
11764         conf = group->conf;
11765
11766         if (conf->as_type == AS_SPECIFIED || conf->as_type == AS_EXTERNAL) {
11767                 vty_out(vty, "\nBGP peer-group %s, remote AS %" PRIu32 "\n",
11768                         group->name, conf->as);
11769         } else if (conf->as_type == AS_INTERNAL) {
11770                 vty_out(vty, "\nBGP peer-group %s, remote AS %" PRIu32 "\n",
11771                         group->name, group->bgp->as);
11772         } else {
11773                 vty_out(vty, "\nBGP peer-group %s\n", group->name);
11774         }
11775
11776         if ((group->bgp->as == conf->as) || (conf->as_type == AS_INTERNAL))
11777                 vty_out(vty, "  Peer-group type is internal\n");
11778         else
11779                 vty_out(vty, "  Peer-group type is external\n");
11780
11781         /* Display AFs configured. */
11782         vty_out(vty, "  Configured address-families:");
11783         FOREACH_AFI_SAFI (afi, safi) {
11784                 if (conf->afc[afi][safi]) {
11785                         af_cfgd = 1;
11786                         vty_out(vty, " %s;", afi_safi_print(afi, safi));
11787                 }
11788         }
11789         if (!af_cfgd)
11790                 vty_out(vty, " none\n");
11791         else
11792                 vty_out(vty, "\n");
11793
11794         /* Display listen ranges (for dynamic neighbors), if any */
11795         for (afi = AFI_IP; afi < AFI_MAX; afi++) {
11796                 if (afi == AFI_IP)
11797                         af_str = "IPv4";
11798                 else if (afi == AFI_IP6)
11799                         af_str = "IPv6";
11800                 else
11801                         af_str = "???";
11802                 lr_count = listcount(group->listen_range[afi]);
11803                 if (lr_count) {
11804                         vty_out(vty, "  %d %s listen range(s)\n", lr_count,
11805                                 af_str);
11806
11807
11808                         for (ALL_LIST_ELEMENTS(group->listen_range[afi], node,
11809                                                nnode, range)) {
11810                                 prefix2str(range, buf, sizeof(buf));
11811                                 vty_out(vty, "    %s\n", buf);
11812                         }
11813                 }
11814         }
11815
11816         /* Display group members and their status */
11817         if (listcount(group->peer)) {
11818                 vty_out(vty, "  Peer-group members:\n");
11819                 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
11820                         if (CHECK_FLAG(peer->flags, PEER_FLAG_SHUTDOWN))
11821                                 peer_status = "Idle (Admin)";
11822                         else if (CHECK_FLAG(peer->sflags,
11823                                             PEER_STATUS_PREFIX_OVERFLOW))
11824                                 peer_status = "Idle (PfxCt)";
11825                         else
11826                                 peer_status = lookup_msg(bgp_status_msg,
11827                                                          peer->status, NULL);
11828
11829                         dynamic = peer_dynamic_neighbor(peer);
11830                         vty_out(vty, "    %s %s %s \n", peer->host,
11831                                 dynamic ? "(dynamic)" : "", peer_status);
11832                 }
11833         }
11834
11835         return CMD_SUCCESS;
11836 }
11837
11838 static int bgp_show_peer_group_vty(struct vty *vty, const char *name,
11839                                    const char *group_name)
11840 {
11841         struct bgp *bgp;
11842         struct listnode *node, *nnode;
11843         struct peer_group *group;
11844         bool found = false;
11845
11846         bgp = name ? bgp_lookup_by_name(name) : bgp_get_default();
11847
11848         if (!bgp) {
11849                 vty_out(vty, "%% BGP instance not found\n");
11850                 return CMD_WARNING;
11851         }
11852
11853         for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
11854                 if (group_name) {
11855                         if (strmatch(group->name, group_name)) {
11856                                 bgp_show_one_peer_group(vty, group);
11857                                 found = true;
11858                                 break;
11859                         }
11860                 } else {
11861                         bgp_show_one_peer_group(vty, group);
11862                 }
11863         }
11864
11865         if (group_name && !found)
11866                 vty_out(vty, "%% No such peer-group\n");
11867
11868         return CMD_SUCCESS;
11869 }
11870
11871 DEFUN (show_ip_bgp_peer_groups,
11872        show_ip_bgp_peer_groups_cmd,
11873        "show [ip] bgp [<view|vrf> VIEWVRFNAME] peer-group [PGNAME]",
11874        SHOW_STR
11875        IP_STR
11876        BGP_STR
11877        BGP_INSTANCE_HELP_STR
11878        "Detailed information on BGP peer groups\n"
11879        "Peer group name\n")
11880 {
11881         char *vrf, *pg;
11882         int idx = 0;
11883
11884         vrf = argv_find(argv, argc, "VIEWVRFNAME", &idx) ? argv[idx]->arg
11885                                                          : NULL;
11886         pg = argv_find(argv, argc, "PGNAME", &idx) ? argv[idx]->arg : NULL;
11887
11888         return bgp_show_peer_group_vty(vty, vrf, pg);
11889 }
11890
11891
11892 /* Redistribute VTY commands.  */
11893
11894 DEFUN (bgp_redistribute_ipv4,
11895        bgp_redistribute_ipv4_cmd,
11896        "redistribute " FRR_IP_REDIST_STR_BGPD,
11897        "Redistribute information from another routing protocol\n"
11898        FRR_IP_REDIST_HELP_STR_BGPD)
11899 {
11900         VTY_DECLVAR_CONTEXT(bgp, bgp);
11901         int idx_protocol = 1;
11902         int type;
11903
11904         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11905         if (type < 0) {
11906                 vty_out(vty, "%% Invalid route type\n");
11907                 return CMD_WARNING_CONFIG_FAILED;
11908         }
11909
11910         bgp_redist_add(bgp, AFI_IP, type, 0);
11911         return bgp_redistribute_set(bgp, AFI_IP, type, 0, false);
11912 }
11913
11914 ALIAS_HIDDEN(
11915         bgp_redistribute_ipv4, bgp_redistribute_ipv4_hidden_cmd,
11916         "redistribute " FRR_IP_REDIST_STR_BGPD,
11917         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD)
11918
11919 DEFUN (bgp_redistribute_ipv4_rmap,
11920        bgp_redistribute_ipv4_rmap_cmd,
11921        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD",
11922        "Redistribute information from another routing protocol\n"
11923        FRR_IP_REDIST_HELP_STR_BGPD
11924        "Route map reference\n"
11925        "Pointer to route-map entries\n")
11926 {
11927         VTY_DECLVAR_CONTEXT(bgp, bgp);
11928         int idx_protocol = 1;
11929         int idx_word = 3;
11930         int type;
11931         struct bgp_redist *red;
11932         bool changed;
11933         struct route_map *route_map = route_map_lookup_warn_noexist(
11934                 vty, argv[idx_word]->arg);
11935
11936         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11937         if (type < 0) {
11938                 vty_out(vty, "%% Invalid route type\n");
11939                 return CMD_WARNING_CONFIG_FAILED;
11940         }
11941
11942         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11943         changed =
11944                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
11945         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11946 }
11947
11948 ALIAS_HIDDEN(
11949         bgp_redistribute_ipv4_rmap, bgp_redistribute_ipv4_rmap_hidden_cmd,
11950         "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD",
11951         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11952         "Route map reference\n"
11953         "Pointer to route-map entries\n")
11954
11955 DEFUN (bgp_redistribute_ipv4_metric,
11956        bgp_redistribute_ipv4_metric_cmd,
11957        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
11958        "Redistribute information from another routing protocol\n"
11959        FRR_IP_REDIST_HELP_STR_BGPD
11960        "Metric for redistributed routes\n"
11961        "Default metric\n")
11962 {
11963         VTY_DECLVAR_CONTEXT(bgp, bgp);
11964         int idx_protocol = 1;
11965         int idx_number = 3;
11966         int type;
11967         uint32_t metric;
11968         struct bgp_redist *red;
11969         bool changed;
11970
11971         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
11972         if (type < 0) {
11973                 vty_out(vty, "%% Invalid route type\n");
11974                 return CMD_WARNING_CONFIG_FAILED;
11975         }
11976         metric = strtoul(argv[idx_number]->arg, NULL, 10);
11977
11978         red = bgp_redist_add(bgp, AFI_IP, type, 0);
11979         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
11980         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
11981 }
11982
11983 ALIAS_HIDDEN(
11984         bgp_redistribute_ipv4_metric, bgp_redistribute_ipv4_metric_hidden_cmd,
11985         "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
11986         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
11987         "Metric for redistributed routes\n"
11988         "Default metric\n")
11989
11990 DEFUN (bgp_redistribute_ipv4_rmap_metric,
11991        bgp_redistribute_ipv4_rmap_metric_cmd,
11992        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
11993        "Redistribute information from another routing protocol\n"
11994        FRR_IP_REDIST_HELP_STR_BGPD
11995        "Route map reference\n"
11996        "Pointer to route-map entries\n"
11997        "Metric for redistributed routes\n"
11998        "Default metric\n")
11999 {
12000         VTY_DECLVAR_CONTEXT(bgp, bgp);
12001         int idx_protocol = 1;
12002         int idx_word = 3;
12003         int idx_number = 5;
12004         int type;
12005         uint32_t metric;
12006         struct bgp_redist *red;
12007         bool changed;
12008         struct route_map *route_map =
12009                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12010
12011         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
12012         if (type < 0) {
12013                 vty_out(vty, "%% Invalid route type\n");
12014                 return CMD_WARNING_CONFIG_FAILED;
12015         }
12016         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12017
12018         red = bgp_redist_add(bgp, AFI_IP, type, 0);
12019         changed =
12020                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12021         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
12022         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
12023 }
12024
12025 ALIAS_HIDDEN(
12026         bgp_redistribute_ipv4_rmap_metric,
12027         bgp_redistribute_ipv4_rmap_metric_hidden_cmd,
12028         "redistribute " FRR_IP_REDIST_STR_BGPD
12029         " route-map WORD metric (0-4294967295)",
12030         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
12031         "Route map reference\n"
12032         "Pointer to route-map entries\n"
12033         "Metric for redistributed routes\n"
12034         "Default metric\n")
12035
12036 DEFUN (bgp_redistribute_ipv4_metric_rmap,
12037        bgp_redistribute_ipv4_metric_rmap_cmd,
12038        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
12039        "Redistribute information from another routing protocol\n"
12040        FRR_IP_REDIST_HELP_STR_BGPD
12041        "Metric for redistributed routes\n"
12042        "Default metric\n"
12043        "Route map reference\n"
12044        "Pointer to route-map entries\n")
12045 {
12046         VTY_DECLVAR_CONTEXT(bgp, bgp);
12047         int idx_protocol = 1;
12048         int idx_number = 3;
12049         int idx_word = 5;
12050         int type;
12051         uint32_t metric;
12052         struct bgp_redist *red;
12053         bool changed;
12054         struct route_map *route_map =
12055                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12056
12057         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
12058         if (type < 0) {
12059                 vty_out(vty, "%% Invalid route type\n");
12060                 return CMD_WARNING_CONFIG_FAILED;
12061         }
12062         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12063
12064         red = bgp_redist_add(bgp, AFI_IP, type, 0);
12065         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
12066         changed |=
12067                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12068         return bgp_redistribute_set(bgp, AFI_IP, type, 0, changed);
12069 }
12070
12071 ALIAS_HIDDEN(
12072         bgp_redistribute_ipv4_metric_rmap,
12073         bgp_redistribute_ipv4_metric_rmap_hidden_cmd,
12074         "redistribute " FRR_IP_REDIST_STR_BGPD
12075         " metric (0-4294967295) route-map WORD",
12076         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
12077         "Metric for redistributed routes\n"
12078         "Default metric\n"
12079         "Route map reference\n"
12080         "Pointer to route-map entries\n")
12081
12082 DEFUN (bgp_redistribute_ipv4_ospf,
12083        bgp_redistribute_ipv4_ospf_cmd,
12084        "redistribute <ospf|table> (1-65535)",
12085        "Redistribute information from another routing protocol\n"
12086        "Open Shortest Path First (OSPFv2)\n"
12087        "Non-main Kernel Routing Table\n"
12088        "Instance ID/Table ID\n")
12089 {
12090         VTY_DECLVAR_CONTEXT(bgp, bgp);
12091         int idx_ospf_table = 1;
12092         int idx_number = 2;
12093         unsigned short instance;
12094         unsigned short protocol;
12095
12096         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12097
12098         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12099                 protocol = ZEBRA_ROUTE_OSPF;
12100         else
12101                 protocol = ZEBRA_ROUTE_TABLE;
12102
12103         bgp_redist_add(bgp, AFI_IP, protocol, instance);
12104         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, false);
12105 }
12106
12107 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf, bgp_redistribute_ipv4_ospf_hidden_cmd,
12108              "redistribute <ospf|table> (1-65535)",
12109              "Redistribute information from another routing protocol\n"
12110              "Open Shortest Path First (OSPFv2)\n"
12111              "Non-main Kernel Routing Table\n"
12112              "Instance ID/Table ID\n")
12113
12114 DEFUN (bgp_redistribute_ipv4_ospf_rmap,
12115        bgp_redistribute_ipv4_ospf_rmap_cmd,
12116        "redistribute <ospf|table> (1-65535) route-map WORD",
12117        "Redistribute information from another routing protocol\n"
12118        "Open Shortest Path First (OSPFv2)\n"
12119        "Non-main Kernel Routing Table\n"
12120        "Instance ID/Table ID\n"
12121        "Route map reference\n"
12122        "Pointer to route-map entries\n")
12123 {
12124         VTY_DECLVAR_CONTEXT(bgp, bgp);
12125         int idx_ospf_table = 1;
12126         int idx_number = 2;
12127         int idx_word = 4;
12128         struct bgp_redist *red;
12129         unsigned short instance;
12130         int protocol;
12131         bool changed;
12132         struct route_map *route_map =
12133                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12134
12135         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12136                 protocol = ZEBRA_ROUTE_OSPF;
12137         else
12138                 protocol = ZEBRA_ROUTE_TABLE;
12139
12140         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12141         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
12142         changed =
12143                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12144         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
12145 }
12146
12147 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_rmap,
12148              bgp_redistribute_ipv4_ospf_rmap_hidden_cmd,
12149              "redistribute <ospf|table> (1-65535) route-map WORD",
12150              "Redistribute information from another routing protocol\n"
12151              "Open Shortest Path First (OSPFv2)\n"
12152              "Non-main Kernel Routing Table\n"
12153              "Instance ID/Table ID\n"
12154              "Route map reference\n"
12155              "Pointer to route-map entries\n")
12156
12157 DEFUN (bgp_redistribute_ipv4_ospf_metric,
12158        bgp_redistribute_ipv4_ospf_metric_cmd,
12159        "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
12160        "Redistribute information from another routing protocol\n"
12161        "Open Shortest Path First (OSPFv2)\n"
12162        "Non-main Kernel Routing Table\n"
12163        "Instance ID/Table ID\n"
12164        "Metric for redistributed routes\n"
12165        "Default metric\n")
12166 {
12167         VTY_DECLVAR_CONTEXT(bgp, bgp);
12168         int idx_ospf_table = 1;
12169         int idx_number = 2;
12170         int idx_number_2 = 4;
12171         uint32_t metric;
12172         struct bgp_redist *red;
12173         unsigned short instance;
12174         int protocol;
12175         bool changed;
12176
12177         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12178                 protocol = ZEBRA_ROUTE_OSPF;
12179         else
12180                 protocol = ZEBRA_ROUTE_TABLE;
12181
12182         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12183         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
12184
12185         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
12186         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
12187                                                 metric);
12188         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
12189 }
12190
12191 ALIAS_HIDDEN(bgp_redistribute_ipv4_ospf_metric,
12192              bgp_redistribute_ipv4_ospf_metric_hidden_cmd,
12193              "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
12194              "Redistribute information from another routing protocol\n"
12195              "Open Shortest Path First (OSPFv2)\n"
12196              "Non-main Kernel Routing Table\n"
12197              "Instance ID/Table ID\n"
12198              "Metric for redistributed routes\n"
12199              "Default metric\n")
12200
12201 DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
12202        bgp_redistribute_ipv4_ospf_rmap_metric_cmd,
12203        "redistribute <ospf|table> (1-65535) route-map WORD metric (0-4294967295)",
12204        "Redistribute information from another routing protocol\n"
12205        "Open Shortest Path First (OSPFv2)\n"
12206        "Non-main Kernel Routing Table\n"
12207        "Instance ID/Table ID\n"
12208        "Route map reference\n"
12209        "Pointer to route-map entries\n"
12210        "Metric for redistributed routes\n"
12211        "Default metric\n")
12212 {
12213         VTY_DECLVAR_CONTEXT(bgp, bgp);
12214         int idx_ospf_table = 1;
12215         int idx_number = 2;
12216         int idx_word = 4;
12217         int idx_number_2 = 6;
12218         uint32_t metric;
12219         struct bgp_redist *red;
12220         unsigned short instance;
12221         int protocol;
12222         bool changed;
12223         struct route_map *route_map =
12224                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12225
12226         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12227                 protocol = ZEBRA_ROUTE_OSPF;
12228         else
12229                 protocol = ZEBRA_ROUTE_TABLE;
12230
12231         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12232         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
12233
12234         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
12235         changed =
12236                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12237         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
12238                                                 metric);
12239         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
12240 }
12241
12242 ALIAS_HIDDEN(
12243         bgp_redistribute_ipv4_ospf_rmap_metric,
12244         bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd,
12245         "redistribute <ospf|table> (1-65535) route-map WORD metric (0-4294967295)",
12246         "Redistribute information from another routing protocol\n"
12247         "Open Shortest Path First (OSPFv2)\n"
12248         "Non-main Kernel Routing Table\n"
12249         "Instance ID/Table ID\n"
12250         "Route map reference\n"
12251         "Pointer to route-map entries\n"
12252         "Metric for redistributed routes\n"
12253         "Default metric\n")
12254
12255 DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
12256        bgp_redistribute_ipv4_ospf_metric_rmap_cmd,
12257        "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map WORD",
12258        "Redistribute information from another routing protocol\n"
12259        "Open Shortest Path First (OSPFv2)\n"
12260        "Non-main Kernel Routing Table\n"
12261        "Instance ID/Table ID\n"
12262        "Metric for redistributed routes\n"
12263        "Default metric\n"
12264        "Route map reference\n"
12265        "Pointer to route-map entries\n")
12266 {
12267         VTY_DECLVAR_CONTEXT(bgp, bgp);
12268         int idx_ospf_table = 1;
12269         int idx_number = 2;
12270         int idx_number_2 = 4;
12271         int idx_word = 6;
12272         uint32_t metric;
12273         struct bgp_redist *red;
12274         unsigned short instance;
12275         int protocol;
12276         bool changed;
12277         struct route_map *route_map =
12278                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12279
12280         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12281                 protocol = ZEBRA_ROUTE_OSPF;
12282         else
12283                 protocol = ZEBRA_ROUTE_TABLE;
12284
12285         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12286         metric = strtoul(argv[idx_number_2]->arg, NULL, 10);
12287
12288         red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
12289         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol,
12290                                                 metric);
12291         changed |=
12292                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12293         return bgp_redistribute_set(bgp, AFI_IP, protocol, instance, changed);
12294 }
12295
12296 ALIAS_HIDDEN(
12297         bgp_redistribute_ipv4_ospf_metric_rmap,
12298         bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd,
12299         "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map WORD",
12300         "Redistribute information from another routing protocol\n"
12301         "Open Shortest Path First (OSPFv2)\n"
12302         "Non-main Kernel Routing Table\n"
12303         "Instance ID/Table ID\n"
12304         "Metric for redistributed routes\n"
12305         "Default metric\n"
12306         "Route map reference\n"
12307         "Pointer to route-map entries\n")
12308
12309 DEFUN (no_bgp_redistribute_ipv4_ospf,
12310        no_bgp_redistribute_ipv4_ospf_cmd,
12311        "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map WORD}]",
12312        NO_STR
12313        "Redistribute information from another routing protocol\n"
12314        "Open Shortest Path First (OSPFv2)\n"
12315        "Non-main Kernel Routing Table\n"
12316        "Instance ID/Table ID\n"
12317        "Metric for redistributed routes\n"
12318        "Default metric\n"
12319        "Route map reference\n"
12320        "Pointer to route-map entries\n")
12321 {
12322         VTY_DECLVAR_CONTEXT(bgp, bgp);
12323         int idx_ospf_table = 2;
12324         int idx_number = 3;
12325         unsigned short instance;
12326         int protocol;
12327
12328         if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
12329                 protocol = ZEBRA_ROUTE_OSPF;
12330         else
12331                 protocol = ZEBRA_ROUTE_TABLE;
12332
12333         instance = strtoul(argv[idx_number]->arg, NULL, 10);
12334         return bgp_redistribute_unset(bgp, AFI_IP, protocol, instance);
12335 }
12336
12337 ALIAS_HIDDEN(
12338         no_bgp_redistribute_ipv4_ospf, no_bgp_redistribute_ipv4_ospf_hidden_cmd,
12339         "no redistribute <ospf|table> (1-65535) [{metric (0-4294967295)|route-map WORD}]",
12340         NO_STR
12341         "Redistribute information from another routing protocol\n"
12342         "Open Shortest Path First (OSPFv2)\n"
12343         "Non-main Kernel Routing Table\n"
12344         "Instance ID/Table ID\n"
12345         "Metric for redistributed routes\n"
12346         "Default metric\n"
12347         "Route map reference\n"
12348         "Pointer to route-map entries\n")
12349
12350 DEFUN (no_bgp_redistribute_ipv4,
12351        no_bgp_redistribute_ipv4_cmd,
12352        "no redistribute " FRR_IP_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map WORD}]",
12353        NO_STR
12354        "Redistribute information from another routing protocol\n"
12355        FRR_IP_REDIST_HELP_STR_BGPD
12356        "Metric for redistributed routes\n"
12357        "Default metric\n"
12358        "Route map reference\n"
12359        "Pointer to route-map entries\n")
12360 {
12361         VTY_DECLVAR_CONTEXT(bgp, bgp);
12362         int idx_protocol = 2;
12363         int type;
12364
12365         type = proto_redistnum(AFI_IP, argv[idx_protocol]->text);
12366         if (type < 0) {
12367                 vty_out(vty, "%% Invalid route type\n");
12368                 return CMD_WARNING_CONFIG_FAILED;
12369         }
12370         return bgp_redistribute_unset(bgp, AFI_IP, type, 0);
12371 }
12372
12373 ALIAS_HIDDEN(
12374         no_bgp_redistribute_ipv4, no_bgp_redistribute_ipv4_hidden_cmd,
12375         "no redistribute " FRR_IP_REDIST_STR_BGPD
12376         " [{metric (0-4294967295)|route-map WORD}]",
12377         NO_STR
12378         "Redistribute information from another routing protocol\n" FRR_IP_REDIST_HELP_STR_BGPD
12379         "Metric for redistributed routes\n"
12380         "Default metric\n"
12381         "Route map reference\n"
12382         "Pointer to route-map entries\n")
12383
12384 DEFUN (bgp_redistribute_ipv6,
12385        bgp_redistribute_ipv6_cmd,
12386        "redistribute " FRR_IP6_REDIST_STR_BGPD,
12387        "Redistribute information from another routing protocol\n"
12388        FRR_IP6_REDIST_HELP_STR_BGPD)
12389 {
12390         VTY_DECLVAR_CONTEXT(bgp, bgp);
12391         int idx_protocol = 1;
12392         int type;
12393
12394         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12395         if (type < 0) {
12396                 vty_out(vty, "%% Invalid route type\n");
12397                 return CMD_WARNING_CONFIG_FAILED;
12398         }
12399
12400         bgp_redist_add(bgp, AFI_IP6, type, 0);
12401         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, false);
12402 }
12403
12404 DEFUN (bgp_redistribute_ipv6_rmap,
12405        bgp_redistribute_ipv6_rmap_cmd,
12406        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD",
12407        "Redistribute information from another routing protocol\n"
12408        FRR_IP6_REDIST_HELP_STR_BGPD
12409        "Route map reference\n"
12410        "Pointer to route-map entries\n")
12411 {
12412         VTY_DECLVAR_CONTEXT(bgp, bgp);
12413         int idx_protocol = 1;
12414         int idx_word = 3;
12415         int type;
12416         struct bgp_redist *red;
12417         bool changed;
12418         struct route_map *route_map =
12419                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12420
12421         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12422         if (type < 0) {
12423                 vty_out(vty, "%% Invalid route type\n");
12424                 return CMD_WARNING_CONFIG_FAILED;
12425         }
12426
12427         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12428         changed =
12429                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12430         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12431 }
12432
12433 DEFUN (bgp_redistribute_ipv6_metric,
12434        bgp_redistribute_ipv6_metric_cmd,
12435        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295)",
12436        "Redistribute information from another routing protocol\n"
12437        FRR_IP6_REDIST_HELP_STR_BGPD
12438        "Metric for redistributed routes\n"
12439        "Default metric\n")
12440 {
12441         VTY_DECLVAR_CONTEXT(bgp, bgp);
12442         int idx_protocol = 1;
12443         int idx_number = 3;
12444         int type;
12445         uint32_t metric;
12446         struct bgp_redist *red;
12447         bool changed;
12448
12449         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12450         if (type < 0) {
12451                 vty_out(vty, "%% Invalid route type\n");
12452                 return CMD_WARNING_CONFIG_FAILED;
12453         }
12454         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12455
12456         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12457         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
12458         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12459 }
12460
12461 DEFUN (bgp_redistribute_ipv6_rmap_metric,
12462        bgp_redistribute_ipv6_rmap_metric_cmd,
12463        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
12464        "Redistribute information from another routing protocol\n"
12465        FRR_IP6_REDIST_HELP_STR_BGPD
12466        "Route map reference\n"
12467        "Pointer to route-map entries\n"
12468        "Metric for redistributed routes\n"
12469        "Default metric\n")
12470 {
12471         VTY_DECLVAR_CONTEXT(bgp, bgp);
12472         int idx_protocol = 1;
12473         int idx_word = 3;
12474         int idx_number = 5;
12475         int type;
12476         uint32_t metric;
12477         struct bgp_redist *red;
12478         bool changed;
12479         struct route_map *route_map =
12480                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12481
12482         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12483         if (type < 0) {
12484                 vty_out(vty, "%% Invalid route type\n");
12485                 return CMD_WARNING_CONFIG_FAILED;
12486         }
12487         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12488
12489         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12490         changed =
12491                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12492         changed |= bgp_redistribute_metric_set(bgp, red, AFI_IP6, type,
12493                                                 metric);
12494         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12495 }
12496
12497 DEFUN (bgp_redistribute_ipv6_metric_rmap,
12498        bgp_redistribute_ipv6_metric_rmap_cmd,
12499        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
12500        "Redistribute information from another routing protocol\n"
12501        FRR_IP6_REDIST_HELP_STR_BGPD
12502        "Metric for redistributed routes\n"
12503        "Default metric\n"
12504        "Route map reference\n"
12505        "Pointer to route-map entries\n")
12506 {
12507         VTY_DECLVAR_CONTEXT(bgp, bgp);
12508         int idx_protocol = 1;
12509         int idx_number = 3;
12510         int idx_word = 5;
12511         int type;
12512         uint32_t metric;
12513         struct bgp_redist *red;
12514         bool changed;
12515         struct route_map *route_map =
12516                 route_map_lookup_warn_noexist(vty, argv[idx_word]->arg);
12517
12518         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12519         if (type < 0) {
12520                 vty_out(vty, "%% Invalid route type\n");
12521                 return CMD_WARNING_CONFIG_FAILED;
12522         }
12523         metric = strtoul(argv[idx_number]->arg, NULL, 10);
12524
12525         red = bgp_redist_add(bgp, AFI_IP6, type, 0);
12526         changed = bgp_redistribute_metric_set(bgp, red, AFI_IP6, SAFI_UNICAST,
12527                                                 metric);
12528         changed |=
12529                 bgp_redistribute_rmap_set(red, argv[idx_word]->arg, route_map);
12530         return bgp_redistribute_set(bgp, AFI_IP6, type, 0, changed);
12531 }
12532
12533 DEFUN (no_bgp_redistribute_ipv6,
12534        no_bgp_redistribute_ipv6_cmd,
12535        "no redistribute " FRR_IP6_REDIST_STR_BGPD " [{metric (0-4294967295)|route-map WORD}]",
12536        NO_STR
12537        "Redistribute information from another routing protocol\n"
12538        FRR_IP6_REDIST_HELP_STR_BGPD
12539        "Metric for redistributed routes\n"
12540        "Default metric\n"
12541        "Route map reference\n"
12542        "Pointer to route-map entries\n")
12543 {
12544         VTY_DECLVAR_CONTEXT(bgp, bgp);
12545         int idx_protocol = 2;
12546         int type;
12547
12548         type = proto_redistnum(AFI_IP6, argv[idx_protocol]->text);
12549         if (type < 0) {
12550                 vty_out(vty, "%% Invalid route type\n");
12551                 return CMD_WARNING_CONFIG_FAILED;
12552         }
12553
12554         return bgp_redistribute_unset(bgp, AFI_IP6, type, 0);
12555 }
12556
12557 void bgp_config_write_redistribute(struct vty *vty, struct bgp *bgp, afi_t afi,
12558                                    safi_t safi)
12559 {
12560         int i;
12561
12562         /* Unicast redistribution only.  */
12563         if (safi != SAFI_UNICAST)
12564                 return;
12565
12566         for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
12567                 /* Redistribute BGP does not make sense.  */
12568                 if (i != ZEBRA_ROUTE_BGP) {
12569                         struct list *red_list;
12570                         struct listnode *node;
12571                         struct bgp_redist *red;
12572
12573                         red_list = bgp->redist[afi][i];
12574                         if (!red_list)
12575                                 continue;
12576
12577                         for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
12578                                 /* "redistribute" configuration.  */
12579                                 vty_out(vty, "  redistribute %s",
12580                                         zebra_route_string(i));
12581                                 if (red->instance)
12582                                         vty_out(vty, " %d", red->instance);
12583                                 if (red->redist_metric_flag)
12584                                         vty_out(vty, " metric %u",
12585                                                 red->redist_metric);
12586                                 if (red->rmap.name)
12587                                         vty_out(vty, " route-map %s",
12588                                                 red->rmap.name);
12589                                 vty_out(vty, "\n");
12590                         }
12591                 }
12592         }
12593 }
12594
12595 /* This is part of the address-family block (unicast only) */
12596 void bgp_vpn_policy_config_write_afi(struct vty *vty, struct bgp *bgp,
12597                                             afi_t afi)
12598 {
12599         int indent = 2;
12600
12601         if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]) {
12602                 if (listcount(bgp->vpn_policy[afi].import_vrf))
12603                         vty_out(vty, "%*simport vrf route-map %s\n", indent, "",
12604                                 bgp->vpn_policy[afi]
12605                                 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
12606                 else
12607                         vty_out(vty, "%*sroute-map vpn import %s\n", indent, "",
12608                                 bgp->vpn_policy[afi]
12609                                 .rmap_name[BGP_VPN_POLICY_DIR_FROMVPN]);
12610         }
12611         if (CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
12612                        BGP_CONFIG_VRF_TO_VRF_IMPORT)
12613             || CHECK_FLAG(bgp->af_flags[afi][SAFI_UNICAST],
12614                           BGP_CONFIG_VRF_TO_VRF_EXPORT))
12615                 return;
12616
12617         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12618                 BGP_VPN_POLICY_TOVPN_LABEL_AUTO)) {
12619
12620                 vty_out(vty, "%*slabel vpn export %s\n", indent, "", "auto");
12621
12622         } else {
12623                 if (bgp->vpn_policy[afi].tovpn_label != MPLS_LABEL_NONE) {
12624                         vty_out(vty, "%*slabel vpn export %u\n", indent, "",
12625                                 bgp->vpn_policy[afi].tovpn_label);
12626                 }
12627         }
12628         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12629                        BGP_VPN_POLICY_TOVPN_RD_SET)) {
12630                 char buf[RD_ADDRSTRLEN];
12631                 vty_out(vty, "%*srd vpn export %s\n", indent, "",
12632                         prefix_rd2str(&bgp->vpn_policy[afi].tovpn_rd, buf,
12633                                       sizeof(buf)));
12634         }
12635         if (CHECK_FLAG(bgp->vpn_policy[afi].flags,
12636                        BGP_VPN_POLICY_TOVPN_NEXTHOP_SET)) {
12637
12638                 char buf[PREFIX_STRLEN];
12639                 if (inet_ntop(bgp->vpn_policy[afi].tovpn_nexthop.family,
12640                               &bgp->vpn_policy[afi].tovpn_nexthop.u.prefix, buf,
12641                               sizeof(buf))) {
12642
12643                         vty_out(vty, "%*snexthop vpn export %s\n",
12644                                 indent, "", buf);
12645                 }
12646         }
12647         if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]
12648             && bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]
12649             && ecommunity_cmp(
12650                        bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
12651                        bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN])) {
12652
12653                 char *b = ecommunity_ecom2str(
12654                         bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN],
12655                         ECOMMUNITY_FORMAT_ROUTE_MAP, ECOMMUNITY_ROUTE_TARGET);
12656                 vty_out(vty, "%*srt vpn both %s\n", indent, "", b);
12657                 XFREE(MTYPE_ECOMMUNITY_STR, b);
12658         } else {
12659                 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_FROMVPN]) {
12660                         char *b = ecommunity_ecom2str(
12661                                 bgp->vpn_policy[afi]
12662                                         .rtlist[BGP_VPN_POLICY_DIR_FROMVPN],
12663                                 ECOMMUNITY_FORMAT_ROUTE_MAP,
12664                                 ECOMMUNITY_ROUTE_TARGET);
12665                         vty_out(vty, "%*srt vpn import %s\n", indent, "", b);
12666                         XFREE(MTYPE_ECOMMUNITY_STR, b);
12667                 }
12668                 if (bgp->vpn_policy[afi].rtlist[BGP_VPN_POLICY_DIR_TOVPN]) {
12669                         char *b = ecommunity_ecom2str(
12670                                 bgp->vpn_policy[afi]
12671                                         .rtlist[BGP_VPN_POLICY_DIR_TOVPN],
12672                                 ECOMMUNITY_FORMAT_ROUTE_MAP,
12673                                 ECOMMUNITY_ROUTE_TARGET);
12674                         vty_out(vty, "%*srt vpn export %s\n", indent, "", b);
12675                         XFREE(MTYPE_ECOMMUNITY_STR, b);
12676                 }
12677         }
12678
12679         if (bgp->vpn_policy[afi].rmap_name[BGP_VPN_POLICY_DIR_TOVPN])
12680                 vty_out(vty, "%*sroute-map vpn export %s\n", indent, "",
12681                         bgp->vpn_policy[afi]
12682                                 .rmap_name[BGP_VPN_POLICY_DIR_TOVPN]);
12683
12684         if (bgp->vpn_policy[afi].import_redirect_rtlist) {
12685                 char *b = ecommunity_ecom2str(
12686                                         bgp->vpn_policy[afi]
12687                                         .import_redirect_rtlist,
12688                                         ECOMMUNITY_FORMAT_ROUTE_MAP,
12689                                         ECOMMUNITY_ROUTE_TARGET);
12690
12691                 vty_out(vty, "%*srt redirect import %s\n", indent, "", b);
12692                 XFREE(MTYPE_ECOMMUNITY_STR, b);
12693         }
12694 }
12695
12696
12697 /* BGP node structure. */
12698 static struct cmd_node bgp_node = {
12699         BGP_NODE, "%s(config-router)# ", 1,
12700 };
12701
12702 static struct cmd_node bgp_ipv4_unicast_node = {
12703         BGP_IPV4_NODE, "%s(config-router-af)# ", 1,
12704 };
12705
12706 static struct cmd_node bgp_ipv4_multicast_node = {
12707         BGP_IPV4M_NODE, "%s(config-router-af)# ", 1,
12708 };
12709
12710 static struct cmd_node bgp_ipv4_labeled_unicast_node = {
12711         BGP_IPV4L_NODE, "%s(config-router-af)# ", 1,
12712 };
12713
12714 static struct cmd_node bgp_ipv6_unicast_node = {
12715         BGP_IPV6_NODE, "%s(config-router-af)# ", 1,
12716 };
12717
12718 static struct cmd_node bgp_ipv6_multicast_node = {
12719         BGP_IPV6M_NODE, "%s(config-router-af)# ", 1,
12720 };
12721
12722 static struct cmd_node bgp_ipv6_labeled_unicast_node = {
12723         BGP_IPV6L_NODE, "%s(config-router-af)# ", 1,
12724 };
12725
12726 static struct cmd_node bgp_vpnv4_node = {BGP_VPNV4_NODE,
12727                                          "%s(config-router-af)# ", 1};
12728
12729 static struct cmd_node bgp_vpnv6_node = {BGP_VPNV6_NODE,
12730                                          "%s(config-router-af-vpnv6)# ", 1};
12731
12732 static struct cmd_node bgp_evpn_node = {BGP_EVPN_NODE,
12733                                         "%s(config-router-evpn)# ", 1};
12734
12735 static struct cmd_node bgp_evpn_vni_node = {BGP_EVPN_VNI_NODE,
12736                                             "%s(config-router-af-vni)# ", 1};
12737
12738 static struct cmd_node bgp_flowspecv4_node = {BGP_FLOWSPECV4_NODE,
12739                                          "%s(config-router-af)# ", 1};
12740
12741 static struct cmd_node bgp_flowspecv6_node = {BGP_FLOWSPECV6_NODE,
12742                                          "%s(config-router-af-vpnv6)# ", 1};
12743
12744 static void community_list_vty(void);
12745
12746 static void bgp_ac_neighbor(vector comps, struct cmd_token *token)
12747 {
12748         struct bgp *bgp;
12749         struct peer *peer;
12750         struct listnode *lnbgp, *lnpeer;
12751
12752         for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
12753                 for (ALL_LIST_ELEMENTS_RO(bgp->peer, lnpeer, peer)) {
12754                         /* only provide suggestions on the appropriate input
12755                          * token type,
12756                          * they'll otherwise show up multiple times */
12757                         enum cmd_token_type match_type;
12758                         char *name = peer->host;
12759
12760                         if (peer->conf_if) {
12761                                 match_type = VARIABLE_TKN;
12762                                 name = peer->conf_if;
12763                         } else if (strchr(peer->host, ':'))
12764                                 match_type = IPV6_TKN;
12765                         else
12766                                 match_type = IPV4_TKN;
12767
12768                         if (token->type != match_type)
12769                                 continue;
12770
12771                         vector_set(comps, XSTRDUP(MTYPE_COMPLETION, name));
12772                 }
12773         }
12774 }
12775
12776 static const struct cmd_variable_handler bgp_var_neighbor[] = {
12777         {.varname = "neighbor", .completions = bgp_ac_neighbor},
12778         {.varname = "neighbors", .completions = bgp_ac_neighbor},
12779         {.varname = "peer", .completions = bgp_ac_neighbor},
12780         {.completions = NULL}};
12781
12782 static void bgp_ac_peergroup(vector comps, struct cmd_token *token)
12783 {
12784         struct bgp *bgp;
12785         struct peer_group *group;
12786         struct listnode *lnbgp, *lnpeer;
12787
12788         for (ALL_LIST_ELEMENTS_RO(bm->bgp, lnbgp, bgp)) {
12789                 for (ALL_LIST_ELEMENTS_RO(bgp->group, lnpeer, group))
12790                         vector_set(comps, XSTRDUP(MTYPE_COMPLETION,
12791                                                   group->name));
12792         }
12793 }
12794
12795 static const struct cmd_variable_handler bgp_var_peergroup[] = {
12796         {.tokenname = "PGNAME", .completions = bgp_ac_peergroup},
12797         {.completions = NULL} };
12798
12799 void bgp_vty_init(void)
12800 {
12801         cmd_variable_handler_register(bgp_var_neighbor);
12802         cmd_variable_handler_register(bgp_var_peergroup);
12803
12804         /* Install bgp top node. */
12805         install_node(&bgp_node, bgp_config_write);
12806         install_node(&bgp_ipv4_unicast_node, NULL);
12807         install_node(&bgp_ipv4_multicast_node, NULL);
12808         install_node(&bgp_ipv4_labeled_unicast_node, NULL);
12809         install_node(&bgp_ipv6_unicast_node, NULL);
12810         install_node(&bgp_ipv6_multicast_node, NULL);
12811         install_node(&bgp_ipv6_labeled_unicast_node, NULL);
12812         install_node(&bgp_vpnv4_node, NULL);
12813         install_node(&bgp_vpnv6_node, NULL);
12814         install_node(&bgp_evpn_node, NULL);
12815         install_node(&bgp_evpn_vni_node, NULL);
12816         install_node(&bgp_flowspecv4_node, NULL);
12817         install_node(&bgp_flowspecv6_node, NULL);
12818
12819         /* Install default VTY commands to new nodes.  */
12820         install_default(BGP_NODE);
12821         install_default(BGP_IPV4_NODE);
12822         install_default(BGP_IPV4M_NODE);
12823         install_default(BGP_IPV4L_NODE);
12824         install_default(BGP_IPV6_NODE);
12825         install_default(BGP_IPV6M_NODE);
12826         install_default(BGP_IPV6L_NODE);
12827         install_default(BGP_VPNV4_NODE);
12828         install_default(BGP_VPNV6_NODE);
12829         install_default(BGP_FLOWSPECV4_NODE);
12830         install_default(BGP_FLOWSPECV6_NODE);
12831         install_default(BGP_EVPN_NODE);
12832         install_default(BGP_EVPN_VNI_NODE);
12833
12834         /* "bgp local-mac" hidden commands. */
12835         install_element(CONFIG_NODE, &bgp_local_mac_cmd);
12836         install_element(CONFIG_NODE, &no_bgp_local_mac_cmd);
12837
12838         /* bgp route-map delay-timer commands. */
12839         install_element(CONFIG_NODE, &bgp_set_route_map_delay_timer_cmd);
12840         install_element(CONFIG_NODE, &no_bgp_set_route_map_delay_timer_cmd);
12841
12842         /* Dummy commands (Currently not supported) */
12843         install_element(BGP_NODE, &no_synchronization_cmd);
12844         install_element(BGP_NODE, &no_auto_summary_cmd);
12845
12846         /* "router bgp" commands. */
12847         install_element(CONFIG_NODE, &router_bgp_cmd);
12848
12849         /* "no router bgp" commands. */
12850         install_element(CONFIG_NODE, &no_router_bgp_cmd);
12851
12852         /* "bgp router-id" commands. */
12853         install_element(BGP_NODE, &bgp_router_id_cmd);
12854         install_element(BGP_NODE, &no_bgp_router_id_cmd);
12855
12856         /* "bgp cluster-id" commands. */
12857         install_element(BGP_NODE, &bgp_cluster_id_cmd);
12858         install_element(BGP_NODE, &no_bgp_cluster_id_cmd);
12859
12860         /* "bgp confederation" commands. */
12861         install_element(BGP_NODE, &bgp_confederation_identifier_cmd);
12862         install_element(BGP_NODE, &no_bgp_confederation_identifier_cmd);
12863
12864         /* "bgp confederation peers" commands. */
12865         install_element(BGP_NODE, &bgp_confederation_peers_cmd);
12866         install_element(BGP_NODE, &no_bgp_confederation_peers_cmd);
12867
12868         /* bgp max-med command */
12869         install_element(BGP_NODE, &bgp_maxmed_admin_cmd);
12870         install_element(BGP_NODE, &no_bgp_maxmed_admin_cmd);
12871         install_element(BGP_NODE, &bgp_maxmed_admin_medv_cmd);
12872         install_element(BGP_NODE, &bgp_maxmed_onstartup_cmd);
12873         install_element(BGP_NODE, &no_bgp_maxmed_onstartup_cmd);
12874
12875         /* bgp disable-ebgp-connected-nh-check */
12876         install_element(BGP_NODE, &bgp_disable_connected_route_check_cmd);
12877         install_element(BGP_NODE, &no_bgp_disable_connected_route_check_cmd);
12878
12879         /* bgp update-delay command */
12880         install_element(BGP_NODE, &bgp_update_delay_cmd);
12881         install_element(BGP_NODE, &no_bgp_update_delay_cmd);
12882         install_element(BGP_NODE, &bgp_update_delay_establish_wait_cmd);
12883
12884         install_element(BGP_NODE, &bgp_wpkt_quanta_cmd);
12885         install_element(BGP_NODE, &no_bgp_wpkt_quanta_cmd);
12886         install_element(BGP_NODE, &bgp_rpkt_quanta_cmd);
12887         install_element(BGP_NODE, &no_bgp_rpkt_quanta_cmd);
12888
12889         install_element(BGP_NODE, &bgp_coalesce_time_cmd);
12890         install_element(BGP_NODE, &no_bgp_coalesce_time_cmd);
12891
12892         /* "maximum-paths" commands. */
12893         install_element(BGP_NODE, &bgp_maxpaths_hidden_cmd);
12894         install_element(BGP_NODE, &no_bgp_maxpaths_hidden_cmd);
12895         install_element(BGP_IPV4_NODE, &bgp_maxpaths_cmd);
12896         install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_cmd);
12897         install_element(BGP_IPV6_NODE, &bgp_maxpaths_cmd);
12898         install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_cmd);
12899         install_element(BGP_NODE, &bgp_maxpaths_ibgp_hidden_cmd);
12900         install_element(BGP_NODE, &bgp_maxpaths_ibgp_cluster_hidden_cmd);
12901         install_element(BGP_NODE, &no_bgp_maxpaths_ibgp_hidden_cmd);
12902         install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cmd);
12903         install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12904         install_element(BGP_IPV4_NODE, &no_bgp_maxpaths_ibgp_cmd);
12905         install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cmd);
12906         install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12907         install_element(BGP_IPV6_NODE, &no_bgp_maxpaths_ibgp_cmd);
12908
12909         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_cmd);
12910         install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_cmd);
12911         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cmd);
12912         install_element(BGP_IPV6L_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
12913         install_element(BGP_IPV6L_NODE, &no_bgp_maxpaths_ibgp_cmd);
12914
12915         /* "timers bgp" commands. */
12916         install_element(BGP_NODE, &bgp_timers_cmd);
12917         install_element(BGP_NODE, &no_bgp_timers_cmd);
12918
12919         /* route-map delay-timer commands - per instance for backwards compat.
12920          */
12921         install_element(BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
12922         install_element(BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
12923
12924         /* "bgp client-to-client reflection" commands */
12925         install_element(BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
12926         install_element(BGP_NODE, &bgp_client_to_client_reflection_cmd);
12927
12928         /* "bgp always-compare-med" commands */
12929         install_element(BGP_NODE, &bgp_always_compare_med_cmd);
12930         install_element(BGP_NODE, &no_bgp_always_compare_med_cmd);
12931
12932         /* bgp ebgp-requires-policy */
12933         install_element(BGP_NODE, &bgp_ebgp_requires_policy_cmd);
12934         install_element(BGP_NODE, &no_bgp_ebgp_requires_policy_cmd);
12935
12936         /* "bgp deterministic-med" commands */
12937         install_element(BGP_NODE, &bgp_deterministic_med_cmd);
12938         install_element(BGP_NODE, &no_bgp_deterministic_med_cmd);
12939
12940         /* "bgp graceful-restart" commands */
12941         install_element(BGP_NODE, &bgp_graceful_restart_cmd);
12942         install_element(BGP_NODE, &no_bgp_graceful_restart_cmd);
12943         install_element(BGP_NODE, &bgp_graceful_restart_stalepath_time_cmd);
12944         install_element(BGP_NODE, &no_bgp_graceful_restart_stalepath_time_cmd);
12945         install_element(BGP_NODE, &bgp_graceful_restart_restart_time_cmd);
12946         install_element(BGP_NODE, &no_bgp_graceful_restart_restart_time_cmd);
12947
12948         install_element(BGP_NODE, &bgp_graceful_restart_preserve_fw_cmd);
12949         install_element(BGP_NODE, &no_bgp_graceful_restart_preserve_fw_cmd);
12950
12951         /* "bgp graceful-shutdown" commands */
12952         install_element(BGP_NODE, &bgp_graceful_shutdown_cmd);
12953         install_element(BGP_NODE, &no_bgp_graceful_shutdown_cmd);
12954
12955         /* "bgp fast-external-failover" commands */
12956         install_element(BGP_NODE, &bgp_fast_external_failover_cmd);
12957         install_element(BGP_NODE, &no_bgp_fast_external_failover_cmd);
12958
12959         /* "bgp bestpath compare-routerid" commands */
12960         install_element(BGP_NODE, &bgp_bestpath_compare_router_id_cmd);
12961         install_element(BGP_NODE, &no_bgp_bestpath_compare_router_id_cmd);
12962
12963         /* "bgp bestpath as-path ignore" commands */
12964         install_element(BGP_NODE, &bgp_bestpath_aspath_ignore_cmd);
12965         install_element(BGP_NODE, &no_bgp_bestpath_aspath_ignore_cmd);
12966
12967         /* "bgp bestpath as-path confed" commands */
12968         install_element(BGP_NODE, &bgp_bestpath_aspath_confed_cmd);
12969         install_element(BGP_NODE, &no_bgp_bestpath_aspath_confed_cmd);
12970
12971         /* "bgp bestpath as-path multipath-relax" commands */
12972         install_element(BGP_NODE, &bgp_bestpath_aspath_multipath_relax_cmd);
12973         install_element(BGP_NODE, &no_bgp_bestpath_aspath_multipath_relax_cmd);
12974
12975         /* "bgp log-neighbor-changes" commands */
12976         install_element(BGP_NODE, &bgp_log_neighbor_changes_cmd);
12977         install_element(BGP_NODE, &no_bgp_log_neighbor_changes_cmd);
12978
12979         /* "bgp bestpath med" commands */
12980         install_element(BGP_NODE, &bgp_bestpath_med_cmd);
12981         install_element(BGP_NODE, &no_bgp_bestpath_med_cmd);
12982
12983         /* "no bgp default ipv4-unicast" commands. */
12984         install_element(BGP_NODE, &no_bgp_default_ipv4_unicast_cmd);
12985         install_element(BGP_NODE, &bgp_default_ipv4_unicast_cmd);
12986
12987         /* "bgp network import-check" commands. */
12988         install_element(BGP_NODE, &bgp_network_import_check_cmd);
12989         install_element(BGP_NODE, &bgp_network_import_check_exact_cmd);
12990         install_element(BGP_NODE, &no_bgp_network_import_check_cmd);
12991
12992         /* "bgp default local-preference" commands. */
12993         install_element(BGP_NODE, &bgp_default_local_preference_cmd);
12994         install_element(BGP_NODE, &no_bgp_default_local_preference_cmd);
12995
12996         /* bgp default show-hostname */
12997         install_element(BGP_NODE, &bgp_default_show_hostname_cmd);
12998         install_element(BGP_NODE, &no_bgp_default_show_hostname_cmd);
12999
13000         /* "bgp default subgroup-pkt-queue-max" commands. */
13001         install_element(BGP_NODE, &bgp_default_subgroup_pkt_queue_max_cmd);
13002         install_element(BGP_NODE, &no_bgp_default_subgroup_pkt_queue_max_cmd);
13003
13004         /* bgp ibgp-allow-policy-mods command */
13005         install_element(BGP_NODE, &bgp_rr_allow_outbound_policy_cmd);
13006         install_element(BGP_NODE, &no_bgp_rr_allow_outbound_policy_cmd);
13007
13008         /* "bgp listen limit" commands. */
13009         install_element(BGP_NODE, &bgp_listen_limit_cmd);
13010         install_element(BGP_NODE, &no_bgp_listen_limit_cmd);
13011
13012         /* "bgp listen range" commands. */
13013         install_element(BGP_NODE, &bgp_listen_range_cmd);
13014         install_element(BGP_NODE, &no_bgp_listen_range_cmd);
13015
13016         /* "bgp default shutdown" command */
13017         install_element(BGP_NODE, &bgp_default_shutdown_cmd);
13018
13019         /* "neighbor remote-as" commands. */
13020         install_element(BGP_NODE, &neighbor_remote_as_cmd);
13021         install_element(BGP_NODE, &neighbor_interface_config_cmd);
13022         install_element(BGP_NODE, &neighbor_interface_config_v6only_cmd);
13023         install_element(BGP_NODE, &neighbor_interface_config_remote_as_cmd);
13024         install_element(BGP_NODE,
13025                         &neighbor_interface_v6only_config_remote_as_cmd);
13026         install_element(BGP_NODE, &no_neighbor_cmd);
13027         install_element(BGP_NODE, &no_neighbor_interface_config_cmd);
13028
13029         /* "neighbor peer-group" commands. */
13030         install_element(BGP_NODE, &neighbor_peer_group_cmd);
13031         install_element(BGP_NODE, &no_neighbor_peer_group_cmd);
13032         install_element(BGP_NODE,
13033                         &no_neighbor_interface_peer_group_remote_as_cmd);
13034
13035         /* "neighbor local-as" commands. */
13036         install_element(BGP_NODE, &neighbor_local_as_cmd);
13037         install_element(BGP_NODE, &neighbor_local_as_no_prepend_cmd);
13038         install_element(BGP_NODE, &neighbor_local_as_no_prepend_replace_as_cmd);
13039         install_element(BGP_NODE, &no_neighbor_local_as_cmd);
13040
13041         /* "neighbor solo" commands. */
13042         install_element(BGP_NODE, &neighbor_solo_cmd);
13043         install_element(BGP_NODE, &no_neighbor_solo_cmd);
13044
13045         /* "neighbor password" commands. */
13046         install_element(BGP_NODE, &neighbor_password_cmd);
13047         install_element(BGP_NODE, &no_neighbor_password_cmd);
13048
13049         /* "neighbor activate" commands. */
13050         install_element(BGP_NODE, &neighbor_activate_hidden_cmd);
13051         install_element(BGP_IPV4_NODE, &neighbor_activate_cmd);
13052         install_element(BGP_IPV4M_NODE, &neighbor_activate_cmd);
13053         install_element(BGP_IPV4L_NODE, &neighbor_activate_cmd);
13054         install_element(BGP_IPV6_NODE, &neighbor_activate_cmd);
13055         install_element(BGP_IPV6M_NODE, &neighbor_activate_cmd);
13056         install_element(BGP_IPV6L_NODE, &neighbor_activate_cmd);
13057         install_element(BGP_VPNV4_NODE, &neighbor_activate_cmd);
13058         install_element(BGP_VPNV6_NODE, &neighbor_activate_cmd);
13059         install_element(BGP_FLOWSPECV4_NODE, &neighbor_activate_cmd);
13060         install_element(BGP_FLOWSPECV6_NODE, &neighbor_activate_cmd);
13061         install_element(BGP_EVPN_NODE, &neighbor_activate_cmd);
13062
13063         /* "no neighbor activate" commands. */
13064         install_element(BGP_NODE, &no_neighbor_activate_hidden_cmd);
13065         install_element(BGP_IPV4_NODE, &no_neighbor_activate_cmd);
13066         install_element(BGP_IPV4M_NODE, &no_neighbor_activate_cmd);
13067         install_element(BGP_IPV4L_NODE, &no_neighbor_activate_cmd);
13068         install_element(BGP_IPV6_NODE, &no_neighbor_activate_cmd);
13069         install_element(BGP_IPV6M_NODE, &no_neighbor_activate_cmd);
13070         install_element(BGP_IPV6L_NODE, &no_neighbor_activate_cmd);
13071         install_element(BGP_VPNV4_NODE, &no_neighbor_activate_cmd);
13072         install_element(BGP_VPNV6_NODE, &no_neighbor_activate_cmd);
13073         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_activate_cmd);
13074         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_activate_cmd);
13075         install_element(BGP_EVPN_NODE, &no_neighbor_activate_cmd);
13076
13077         /* "neighbor peer-group" set commands. */
13078         install_element(BGP_NODE, &neighbor_set_peer_group_cmd);
13079         install_element(BGP_IPV4_NODE, &neighbor_set_peer_group_hidden_cmd);
13080         install_element(BGP_IPV4M_NODE, &neighbor_set_peer_group_hidden_cmd);
13081         install_element(BGP_IPV6_NODE, &neighbor_set_peer_group_hidden_cmd);
13082         install_element(BGP_IPV6M_NODE, &neighbor_set_peer_group_hidden_cmd);
13083         install_element(BGP_IPV6L_NODE, &neighbor_set_peer_group_hidden_cmd);
13084         install_element(BGP_VPNV4_NODE, &neighbor_set_peer_group_hidden_cmd);
13085         install_element(BGP_VPNV6_NODE, &neighbor_set_peer_group_hidden_cmd);
13086         install_element(BGP_FLOWSPECV4_NODE,
13087                         &neighbor_set_peer_group_hidden_cmd);
13088         install_element(BGP_FLOWSPECV6_NODE,
13089                         &neighbor_set_peer_group_hidden_cmd);
13090
13091         /* "no neighbor peer-group unset" commands. */
13092         install_element(BGP_NODE, &no_neighbor_set_peer_group_cmd);
13093         install_element(BGP_IPV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13094         install_element(BGP_IPV4M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13095         install_element(BGP_IPV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13096         install_element(BGP_IPV6M_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13097         install_element(BGP_IPV6L_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13098         install_element(BGP_VPNV4_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13099         install_element(BGP_VPNV6_NODE, &no_neighbor_set_peer_group_hidden_cmd);
13100         install_element(BGP_FLOWSPECV4_NODE,
13101                         &no_neighbor_set_peer_group_hidden_cmd);
13102         install_element(BGP_FLOWSPECV6_NODE,
13103                         &no_neighbor_set_peer_group_hidden_cmd);
13104
13105         /* "neighbor softreconfiguration inbound" commands.*/
13106         install_element(BGP_NODE, &neighbor_soft_reconfiguration_hidden_cmd);
13107         install_element(BGP_NODE, &no_neighbor_soft_reconfiguration_hidden_cmd);
13108         install_element(BGP_IPV4_NODE, &neighbor_soft_reconfiguration_cmd);
13109         install_element(BGP_IPV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
13110         install_element(BGP_IPV4L_NODE, &neighbor_soft_reconfiguration_cmd);
13111         install_element(BGP_IPV4L_NODE, &no_neighbor_soft_reconfiguration_cmd);
13112         install_element(BGP_IPV4M_NODE, &neighbor_soft_reconfiguration_cmd);
13113         install_element(BGP_IPV4M_NODE, &no_neighbor_soft_reconfiguration_cmd);
13114         install_element(BGP_IPV6_NODE, &neighbor_soft_reconfiguration_cmd);
13115         install_element(BGP_IPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
13116         install_element(BGP_IPV6M_NODE, &neighbor_soft_reconfiguration_cmd);
13117         install_element(BGP_IPV6M_NODE, &no_neighbor_soft_reconfiguration_cmd);
13118         install_element(BGP_IPV6L_NODE, &neighbor_soft_reconfiguration_cmd);
13119         install_element(BGP_IPV6L_NODE, &no_neighbor_soft_reconfiguration_cmd);
13120         install_element(BGP_VPNV4_NODE, &neighbor_soft_reconfiguration_cmd);
13121         install_element(BGP_VPNV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
13122         install_element(BGP_VPNV6_NODE, &neighbor_soft_reconfiguration_cmd);
13123         install_element(BGP_VPNV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
13124         install_element(BGP_FLOWSPECV4_NODE,
13125                         &neighbor_soft_reconfiguration_cmd);
13126         install_element(BGP_FLOWSPECV4_NODE,
13127                         &no_neighbor_soft_reconfiguration_cmd);
13128         install_element(BGP_FLOWSPECV6_NODE,
13129                         &neighbor_soft_reconfiguration_cmd);
13130         install_element(BGP_FLOWSPECV6_NODE,
13131                         &no_neighbor_soft_reconfiguration_cmd);
13132         install_element(BGP_EVPN_NODE, &neighbor_soft_reconfiguration_cmd);
13133         install_element(BGP_EVPN_NODE, &no_neighbor_soft_reconfiguration_cmd);
13134
13135         /* "neighbor attribute-unchanged" commands.  */
13136         install_element(BGP_NODE, &neighbor_attr_unchanged_hidden_cmd);
13137         install_element(BGP_NODE, &no_neighbor_attr_unchanged_hidden_cmd);
13138         install_element(BGP_IPV4_NODE, &neighbor_attr_unchanged_cmd);
13139         install_element(BGP_IPV4_NODE, &no_neighbor_attr_unchanged_cmd);
13140         install_element(BGP_IPV4M_NODE, &neighbor_attr_unchanged_cmd);
13141         install_element(BGP_IPV4M_NODE, &no_neighbor_attr_unchanged_cmd);
13142         install_element(BGP_IPV4L_NODE, &neighbor_attr_unchanged_cmd);
13143         install_element(BGP_IPV4L_NODE, &no_neighbor_attr_unchanged_cmd);
13144         install_element(BGP_IPV6_NODE, &neighbor_attr_unchanged_cmd);
13145         install_element(BGP_IPV6_NODE, &no_neighbor_attr_unchanged_cmd);
13146         install_element(BGP_IPV6M_NODE, &neighbor_attr_unchanged_cmd);
13147         install_element(BGP_IPV6M_NODE, &no_neighbor_attr_unchanged_cmd);
13148         install_element(BGP_IPV6L_NODE, &neighbor_attr_unchanged_cmd);
13149         install_element(BGP_IPV6L_NODE, &no_neighbor_attr_unchanged_cmd);
13150         install_element(BGP_VPNV4_NODE, &neighbor_attr_unchanged_cmd);
13151         install_element(BGP_VPNV4_NODE, &no_neighbor_attr_unchanged_cmd);
13152         install_element(BGP_VPNV6_NODE, &neighbor_attr_unchanged_cmd);
13153         install_element(BGP_VPNV6_NODE, &no_neighbor_attr_unchanged_cmd);
13154
13155         install_element(BGP_EVPN_NODE, &neighbor_attr_unchanged_cmd);
13156         install_element(BGP_EVPN_NODE, &no_neighbor_attr_unchanged_cmd);
13157
13158         /* "nexthop-local unchanged" commands */
13159         install_element(BGP_IPV6_NODE, &neighbor_nexthop_local_unchanged_cmd);
13160         install_element(BGP_IPV6_NODE,
13161                         &no_neighbor_nexthop_local_unchanged_cmd);
13162
13163         /* "neighbor next-hop-self" commands. */
13164         install_element(BGP_NODE, &neighbor_nexthop_self_hidden_cmd);
13165         install_element(BGP_NODE, &no_neighbor_nexthop_self_hidden_cmd);
13166         install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_cmd);
13167         install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_cmd);
13168         install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_cmd);
13169         install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_cmd);
13170         install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_cmd);
13171         install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_cmd);
13172         install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_cmd);
13173         install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_cmd);
13174         install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_cmd);
13175         install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_cmd);
13176         install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_cmd);
13177         install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_cmd);
13178         install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_cmd);
13179         install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_cmd);
13180         install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_cmd);
13181         install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_cmd);
13182         install_element(BGP_EVPN_NODE, &neighbor_nexthop_self_cmd);
13183         install_element(BGP_EVPN_NODE, &no_neighbor_nexthop_self_cmd);
13184
13185         /* "neighbor next-hop-self force" commands. */
13186         install_element(BGP_NODE, &neighbor_nexthop_self_force_hidden_cmd);
13187         install_element(BGP_NODE, &no_neighbor_nexthop_self_force_hidden_cmd);
13188         install_element(BGP_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13189         install_element(BGP_NODE, &no_neighbor_nexthop_self_all_hidden_cmd);
13190         install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_force_cmd);
13191         install_element(BGP_IPV4_NODE, &no_neighbor_nexthop_self_force_cmd);
13192         install_element(BGP_IPV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13193         install_element(BGP_IPV4_NODE,
13194                         &no_neighbor_nexthop_self_all_hidden_cmd);
13195         install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_force_cmd);
13196         install_element(BGP_IPV4M_NODE, &no_neighbor_nexthop_self_force_cmd);
13197         install_element(BGP_IPV4M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13198         install_element(BGP_IPV4M_NODE,
13199                         &no_neighbor_nexthop_self_all_hidden_cmd);
13200         install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_force_cmd);
13201         install_element(BGP_IPV4L_NODE, &no_neighbor_nexthop_self_force_cmd);
13202         install_element(BGP_IPV4L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13203         install_element(BGP_IPV4L_NODE,
13204                         &no_neighbor_nexthop_self_all_hidden_cmd);
13205         install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_force_cmd);
13206         install_element(BGP_IPV6_NODE, &no_neighbor_nexthop_self_force_cmd);
13207         install_element(BGP_IPV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13208         install_element(BGP_IPV6_NODE,
13209                         &no_neighbor_nexthop_self_all_hidden_cmd);
13210         install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_force_cmd);
13211         install_element(BGP_IPV6M_NODE, &no_neighbor_nexthop_self_force_cmd);
13212         install_element(BGP_IPV6M_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13213         install_element(BGP_IPV6M_NODE,
13214                         &no_neighbor_nexthop_self_all_hidden_cmd);
13215         install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_force_cmd);
13216         install_element(BGP_IPV6L_NODE, &no_neighbor_nexthop_self_force_cmd);
13217         install_element(BGP_IPV6L_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13218         install_element(BGP_IPV6L_NODE,
13219                         &no_neighbor_nexthop_self_all_hidden_cmd);
13220         install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_force_cmd);
13221         install_element(BGP_VPNV4_NODE, &no_neighbor_nexthop_self_force_cmd);
13222         install_element(BGP_VPNV4_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13223         install_element(BGP_VPNV4_NODE,
13224                         &no_neighbor_nexthop_self_all_hidden_cmd);
13225         install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_force_cmd);
13226         install_element(BGP_VPNV6_NODE, &no_neighbor_nexthop_self_force_cmd);
13227         install_element(BGP_VPNV6_NODE, &neighbor_nexthop_self_all_hidden_cmd);
13228         install_element(BGP_VPNV6_NODE,
13229                         &no_neighbor_nexthop_self_all_hidden_cmd);
13230
13231         /* "neighbor as-override" commands. */
13232         install_element(BGP_NODE, &neighbor_as_override_hidden_cmd);
13233         install_element(BGP_NODE, &no_neighbor_as_override_hidden_cmd);
13234         install_element(BGP_IPV4_NODE, &neighbor_as_override_cmd);
13235         install_element(BGP_IPV4_NODE, &no_neighbor_as_override_cmd);
13236         install_element(BGP_IPV4M_NODE, &neighbor_as_override_cmd);
13237         install_element(BGP_IPV4M_NODE, &no_neighbor_as_override_cmd);
13238         install_element(BGP_IPV4L_NODE, &neighbor_as_override_cmd);
13239         install_element(BGP_IPV4L_NODE, &no_neighbor_as_override_cmd);
13240         install_element(BGP_IPV6_NODE, &neighbor_as_override_cmd);
13241         install_element(BGP_IPV6_NODE, &no_neighbor_as_override_cmd);
13242         install_element(BGP_IPV6M_NODE, &neighbor_as_override_cmd);
13243         install_element(BGP_IPV6M_NODE, &no_neighbor_as_override_cmd);
13244         install_element(BGP_IPV6L_NODE, &neighbor_as_override_cmd);
13245         install_element(BGP_IPV6L_NODE, &no_neighbor_as_override_cmd);
13246         install_element(BGP_VPNV4_NODE, &neighbor_as_override_cmd);
13247         install_element(BGP_VPNV4_NODE, &no_neighbor_as_override_cmd);
13248         install_element(BGP_VPNV6_NODE, &neighbor_as_override_cmd);
13249         install_element(BGP_VPNV6_NODE, &no_neighbor_as_override_cmd);
13250
13251         /* "neighbor remove-private-AS" commands. */
13252         install_element(BGP_NODE, &neighbor_remove_private_as_hidden_cmd);
13253         install_element(BGP_NODE, &no_neighbor_remove_private_as_hidden_cmd);
13254         install_element(BGP_NODE, &neighbor_remove_private_as_all_hidden_cmd);
13255         install_element(BGP_NODE,
13256                         &no_neighbor_remove_private_as_all_hidden_cmd);
13257         install_element(BGP_NODE,
13258                         &neighbor_remove_private_as_replace_as_hidden_cmd);
13259         install_element(BGP_NODE,
13260                         &no_neighbor_remove_private_as_replace_as_hidden_cmd);
13261         install_element(BGP_NODE,
13262                         &neighbor_remove_private_as_all_replace_as_hidden_cmd);
13263         install_element(
13264                 BGP_NODE,
13265                 &no_neighbor_remove_private_as_all_replace_as_hidden_cmd);
13266         install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_cmd);
13267         install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_cmd);
13268         install_element(BGP_IPV4_NODE, &neighbor_remove_private_as_all_cmd);
13269         install_element(BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_cmd);
13270         install_element(BGP_IPV4_NODE,
13271                         &neighbor_remove_private_as_replace_as_cmd);
13272         install_element(BGP_IPV4_NODE,
13273                         &no_neighbor_remove_private_as_replace_as_cmd);
13274         install_element(BGP_IPV4_NODE,
13275                         &neighbor_remove_private_as_all_replace_as_cmd);
13276         install_element(BGP_IPV4_NODE,
13277                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13278         install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_cmd);
13279         install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_cmd);
13280         install_element(BGP_IPV4M_NODE, &neighbor_remove_private_as_all_cmd);
13281         install_element(BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_cmd);
13282         install_element(BGP_IPV4M_NODE,
13283                         &neighbor_remove_private_as_replace_as_cmd);
13284         install_element(BGP_IPV4M_NODE,
13285                         &no_neighbor_remove_private_as_replace_as_cmd);
13286         install_element(BGP_IPV4M_NODE,
13287                         &neighbor_remove_private_as_all_replace_as_cmd);
13288         install_element(BGP_IPV4M_NODE,
13289                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13290         install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_cmd);
13291         install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_cmd);
13292         install_element(BGP_IPV4L_NODE, &neighbor_remove_private_as_all_cmd);
13293         install_element(BGP_IPV4L_NODE, &no_neighbor_remove_private_as_all_cmd);
13294         install_element(BGP_IPV4L_NODE,
13295                         &neighbor_remove_private_as_replace_as_cmd);
13296         install_element(BGP_IPV4L_NODE,
13297                         &no_neighbor_remove_private_as_replace_as_cmd);
13298         install_element(BGP_IPV4L_NODE,
13299                         &neighbor_remove_private_as_all_replace_as_cmd);
13300         install_element(BGP_IPV4L_NODE,
13301                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13302         install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_cmd);
13303         install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_cmd);
13304         install_element(BGP_IPV6_NODE, &neighbor_remove_private_as_all_cmd);
13305         install_element(BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_cmd);
13306         install_element(BGP_IPV6_NODE,
13307                         &neighbor_remove_private_as_replace_as_cmd);
13308         install_element(BGP_IPV6_NODE,
13309                         &no_neighbor_remove_private_as_replace_as_cmd);
13310         install_element(BGP_IPV6_NODE,
13311                         &neighbor_remove_private_as_all_replace_as_cmd);
13312         install_element(BGP_IPV6_NODE,
13313                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13314         install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_cmd);
13315         install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_cmd);
13316         install_element(BGP_IPV6M_NODE, &neighbor_remove_private_as_all_cmd);
13317         install_element(BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_cmd);
13318         install_element(BGP_IPV6M_NODE,
13319                         &neighbor_remove_private_as_replace_as_cmd);
13320         install_element(BGP_IPV6M_NODE,
13321                         &no_neighbor_remove_private_as_replace_as_cmd);
13322         install_element(BGP_IPV6M_NODE,
13323                         &neighbor_remove_private_as_all_replace_as_cmd);
13324         install_element(BGP_IPV6M_NODE,
13325                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13326         install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_cmd);
13327         install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_cmd);
13328         install_element(BGP_IPV6L_NODE, &neighbor_remove_private_as_all_cmd);
13329         install_element(BGP_IPV6L_NODE, &no_neighbor_remove_private_as_all_cmd);
13330         install_element(BGP_IPV6L_NODE,
13331                         &neighbor_remove_private_as_replace_as_cmd);
13332         install_element(BGP_IPV6L_NODE,
13333                         &no_neighbor_remove_private_as_replace_as_cmd);
13334         install_element(BGP_IPV6L_NODE,
13335                         &neighbor_remove_private_as_all_replace_as_cmd);
13336         install_element(BGP_IPV6L_NODE,
13337                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13338         install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_cmd);
13339         install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_cmd);
13340         install_element(BGP_VPNV4_NODE, &neighbor_remove_private_as_all_cmd);
13341         install_element(BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_cmd);
13342         install_element(BGP_VPNV4_NODE,
13343                         &neighbor_remove_private_as_replace_as_cmd);
13344         install_element(BGP_VPNV4_NODE,
13345                         &no_neighbor_remove_private_as_replace_as_cmd);
13346         install_element(BGP_VPNV4_NODE,
13347                         &neighbor_remove_private_as_all_replace_as_cmd);
13348         install_element(BGP_VPNV4_NODE,
13349                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13350         install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_cmd);
13351         install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_cmd);
13352         install_element(BGP_VPNV6_NODE, &neighbor_remove_private_as_all_cmd);
13353         install_element(BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_cmd);
13354         install_element(BGP_VPNV6_NODE,
13355                         &neighbor_remove_private_as_replace_as_cmd);
13356         install_element(BGP_VPNV6_NODE,
13357                         &no_neighbor_remove_private_as_replace_as_cmd);
13358         install_element(BGP_VPNV6_NODE,
13359                         &neighbor_remove_private_as_all_replace_as_cmd);
13360         install_element(BGP_VPNV6_NODE,
13361                         &no_neighbor_remove_private_as_all_replace_as_cmd);
13362
13363         /* "neighbor send-community" commands.*/
13364         install_element(BGP_NODE, &neighbor_send_community_hidden_cmd);
13365         install_element(BGP_NODE, &neighbor_send_community_type_hidden_cmd);
13366         install_element(BGP_NODE, &no_neighbor_send_community_hidden_cmd);
13367         install_element(BGP_NODE, &no_neighbor_send_community_type_hidden_cmd);
13368         install_element(BGP_IPV4_NODE, &neighbor_send_community_cmd);
13369         install_element(BGP_IPV4_NODE, &neighbor_send_community_type_cmd);
13370         install_element(BGP_IPV4_NODE, &no_neighbor_send_community_cmd);
13371         install_element(BGP_IPV4_NODE, &no_neighbor_send_community_type_cmd);
13372         install_element(BGP_IPV4M_NODE, &neighbor_send_community_cmd);
13373         install_element(BGP_IPV4M_NODE, &neighbor_send_community_type_cmd);
13374         install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_cmd);
13375         install_element(BGP_IPV4M_NODE, &no_neighbor_send_community_type_cmd);
13376         install_element(BGP_IPV4L_NODE, &neighbor_send_community_cmd);
13377         install_element(BGP_IPV4L_NODE, &neighbor_send_community_type_cmd);
13378         install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_cmd);
13379         install_element(BGP_IPV4L_NODE, &no_neighbor_send_community_type_cmd);
13380         install_element(BGP_IPV6_NODE, &neighbor_send_community_cmd);
13381         install_element(BGP_IPV6_NODE, &neighbor_send_community_type_cmd);
13382         install_element(BGP_IPV6_NODE, &no_neighbor_send_community_cmd);
13383         install_element(BGP_IPV6_NODE, &no_neighbor_send_community_type_cmd);
13384         install_element(BGP_IPV6M_NODE, &neighbor_send_community_cmd);
13385         install_element(BGP_IPV6M_NODE, &neighbor_send_community_type_cmd);
13386         install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_cmd);
13387         install_element(BGP_IPV6M_NODE, &no_neighbor_send_community_type_cmd);
13388         install_element(BGP_IPV6L_NODE, &neighbor_send_community_cmd);
13389         install_element(BGP_IPV6L_NODE, &neighbor_send_community_type_cmd);
13390         install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_cmd);
13391         install_element(BGP_IPV6L_NODE, &no_neighbor_send_community_type_cmd);
13392         install_element(BGP_VPNV4_NODE, &neighbor_send_community_cmd);
13393         install_element(BGP_VPNV4_NODE, &neighbor_send_community_type_cmd);
13394         install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_cmd);
13395         install_element(BGP_VPNV4_NODE, &no_neighbor_send_community_type_cmd);
13396         install_element(BGP_VPNV6_NODE, &neighbor_send_community_cmd);
13397         install_element(BGP_VPNV6_NODE, &neighbor_send_community_type_cmd);
13398         install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_cmd);
13399         install_element(BGP_VPNV6_NODE, &no_neighbor_send_community_type_cmd);
13400
13401         /* "neighbor route-reflector" commands.*/
13402         install_element(BGP_NODE, &neighbor_route_reflector_client_hidden_cmd);
13403         install_element(BGP_NODE,
13404                         &no_neighbor_route_reflector_client_hidden_cmd);
13405         install_element(BGP_IPV4_NODE, &neighbor_route_reflector_client_cmd);
13406         install_element(BGP_IPV4_NODE, &no_neighbor_route_reflector_client_cmd);
13407         install_element(BGP_IPV4M_NODE, &neighbor_route_reflector_client_cmd);
13408         install_element(BGP_IPV4M_NODE,
13409                         &no_neighbor_route_reflector_client_cmd);
13410         install_element(BGP_IPV4L_NODE, &neighbor_route_reflector_client_cmd);
13411         install_element(BGP_IPV4L_NODE,
13412                         &no_neighbor_route_reflector_client_cmd);
13413         install_element(BGP_IPV6_NODE, &neighbor_route_reflector_client_cmd);
13414         install_element(BGP_IPV6_NODE, &no_neighbor_route_reflector_client_cmd);
13415         install_element(BGP_IPV6M_NODE, &neighbor_route_reflector_client_cmd);
13416         install_element(BGP_IPV6M_NODE,
13417                         &no_neighbor_route_reflector_client_cmd);
13418         install_element(BGP_IPV6L_NODE, &neighbor_route_reflector_client_cmd);
13419         install_element(BGP_IPV6L_NODE,
13420                         &no_neighbor_route_reflector_client_cmd);
13421         install_element(BGP_VPNV4_NODE, &neighbor_route_reflector_client_cmd);
13422         install_element(BGP_VPNV4_NODE,
13423                         &no_neighbor_route_reflector_client_cmd);
13424         install_element(BGP_VPNV6_NODE, &neighbor_route_reflector_client_cmd);
13425         install_element(BGP_VPNV6_NODE,
13426                         &no_neighbor_route_reflector_client_cmd);
13427         install_element(BGP_FLOWSPECV4_NODE,
13428                         &neighbor_route_reflector_client_cmd);
13429         install_element(BGP_FLOWSPECV4_NODE,
13430                         &no_neighbor_route_reflector_client_cmd);
13431         install_element(BGP_FLOWSPECV6_NODE,
13432                         &neighbor_route_reflector_client_cmd);
13433         install_element(BGP_FLOWSPECV6_NODE,
13434                         &no_neighbor_route_reflector_client_cmd);
13435         install_element(BGP_EVPN_NODE, &neighbor_route_reflector_client_cmd);
13436         install_element(BGP_EVPN_NODE, &no_neighbor_route_reflector_client_cmd);
13437
13438         /* "neighbor route-server" commands.*/
13439         install_element(BGP_NODE, &neighbor_route_server_client_hidden_cmd);
13440         install_element(BGP_NODE, &no_neighbor_route_server_client_hidden_cmd);
13441         install_element(BGP_IPV4_NODE, &neighbor_route_server_client_cmd);
13442         install_element(BGP_IPV4_NODE, &no_neighbor_route_server_client_cmd);
13443         install_element(BGP_IPV4M_NODE, &neighbor_route_server_client_cmd);
13444         install_element(BGP_IPV4M_NODE, &no_neighbor_route_server_client_cmd);
13445         install_element(BGP_IPV4L_NODE, &neighbor_route_server_client_cmd);
13446         install_element(BGP_IPV4L_NODE, &no_neighbor_route_server_client_cmd);
13447         install_element(BGP_IPV6_NODE, &neighbor_route_server_client_cmd);
13448         install_element(BGP_IPV6_NODE, &no_neighbor_route_server_client_cmd);
13449         install_element(BGP_IPV6M_NODE, &neighbor_route_server_client_cmd);
13450         install_element(BGP_IPV6M_NODE, &no_neighbor_route_server_client_cmd);
13451         install_element(BGP_IPV6L_NODE, &neighbor_route_server_client_cmd);
13452         install_element(BGP_IPV6L_NODE, &no_neighbor_route_server_client_cmd);
13453         install_element(BGP_VPNV4_NODE, &neighbor_route_server_client_cmd);
13454         install_element(BGP_VPNV4_NODE, &no_neighbor_route_server_client_cmd);
13455         install_element(BGP_VPNV6_NODE, &neighbor_route_server_client_cmd);
13456         install_element(BGP_VPNV6_NODE, &no_neighbor_route_server_client_cmd);
13457         install_element(BGP_EVPN_NODE, &neighbor_route_server_client_cmd);
13458         install_element(BGP_EVPN_NODE, &no_neighbor_route_server_client_cmd);
13459         install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_server_client_cmd);
13460         install_element(BGP_FLOWSPECV4_NODE,
13461                         &no_neighbor_route_server_client_cmd);
13462         install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_server_client_cmd);
13463         install_element(BGP_FLOWSPECV6_NODE,
13464                         &no_neighbor_route_server_client_cmd);
13465
13466         /* "neighbor addpath-tx-all-paths" commands.*/
13467         install_element(BGP_NODE, &neighbor_addpath_tx_all_paths_hidden_cmd);
13468         install_element(BGP_NODE, &no_neighbor_addpath_tx_all_paths_hidden_cmd);
13469         install_element(BGP_IPV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
13470         install_element(BGP_IPV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13471         install_element(BGP_IPV4M_NODE, &neighbor_addpath_tx_all_paths_cmd);
13472         install_element(BGP_IPV4M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13473         install_element(BGP_IPV4L_NODE, &neighbor_addpath_tx_all_paths_cmd);
13474         install_element(BGP_IPV4L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13475         install_element(BGP_IPV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
13476         install_element(BGP_IPV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13477         install_element(BGP_IPV6M_NODE, &neighbor_addpath_tx_all_paths_cmd);
13478         install_element(BGP_IPV6M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13479         install_element(BGP_IPV6L_NODE, &neighbor_addpath_tx_all_paths_cmd);
13480         install_element(BGP_IPV6L_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13481         install_element(BGP_VPNV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
13482         install_element(BGP_VPNV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13483         install_element(BGP_VPNV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
13484         install_element(BGP_VPNV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
13485
13486         /* "neighbor addpath-tx-bestpath-per-AS" commands.*/
13487         install_element(BGP_NODE,
13488                         &neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
13489         install_element(BGP_NODE,
13490                         &no_neighbor_addpath_tx_bestpath_per_as_hidden_cmd);
13491         install_element(BGP_IPV4_NODE,
13492                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13493         install_element(BGP_IPV4_NODE,
13494                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13495         install_element(BGP_IPV4M_NODE,
13496                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13497         install_element(BGP_IPV4M_NODE,
13498                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13499         install_element(BGP_IPV4L_NODE,
13500                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13501         install_element(BGP_IPV4L_NODE,
13502                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13503         install_element(BGP_IPV6_NODE,
13504                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13505         install_element(BGP_IPV6_NODE,
13506                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13507         install_element(BGP_IPV6M_NODE,
13508                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13509         install_element(BGP_IPV6M_NODE,
13510                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13511         install_element(BGP_IPV6L_NODE,
13512                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13513         install_element(BGP_IPV6L_NODE,
13514                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13515         install_element(BGP_VPNV4_NODE,
13516                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13517         install_element(BGP_VPNV4_NODE,
13518                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13519         install_element(BGP_VPNV6_NODE,
13520                         &neighbor_addpath_tx_bestpath_per_as_cmd);
13521         install_element(BGP_VPNV6_NODE,
13522                         &no_neighbor_addpath_tx_bestpath_per_as_cmd);
13523
13524         /* "neighbor passive" commands. */
13525         install_element(BGP_NODE, &neighbor_passive_cmd);
13526         install_element(BGP_NODE, &no_neighbor_passive_cmd);
13527
13528
13529         /* "neighbor shutdown" commands. */
13530         install_element(BGP_NODE, &neighbor_shutdown_cmd);
13531         install_element(BGP_NODE, &no_neighbor_shutdown_cmd);
13532         install_element(BGP_NODE, &neighbor_shutdown_msg_cmd);
13533         install_element(BGP_NODE, &no_neighbor_shutdown_msg_cmd);
13534
13535         /* "neighbor capability extended-nexthop" commands.*/
13536         install_element(BGP_NODE, &neighbor_capability_enhe_cmd);
13537         install_element(BGP_NODE, &no_neighbor_capability_enhe_cmd);
13538
13539         /* "neighbor capability orf prefix-list" commands.*/
13540         install_element(BGP_NODE, &neighbor_capability_orf_prefix_hidden_cmd);
13541         install_element(BGP_NODE,
13542                         &no_neighbor_capability_orf_prefix_hidden_cmd);
13543         install_element(BGP_IPV4_NODE, &neighbor_capability_orf_prefix_cmd);
13544         install_element(BGP_IPV4_NODE, &no_neighbor_capability_orf_prefix_cmd);
13545         install_element(BGP_IPV4M_NODE, &neighbor_capability_orf_prefix_cmd);
13546         install_element(BGP_IPV4M_NODE, &no_neighbor_capability_orf_prefix_cmd);
13547         install_element(BGP_IPV4L_NODE, &neighbor_capability_orf_prefix_cmd);
13548         install_element(BGP_IPV4L_NODE, &no_neighbor_capability_orf_prefix_cmd);
13549         install_element(BGP_IPV6_NODE, &neighbor_capability_orf_prefix_cmd);
13550         install_element(BGP_IPV6_NODE, &no_neighbor_capability_orf_prefix_cmd);
13551         install_element(BGP_IPV6M_NODE, &neighbor_capability_orf_prefix_cmd);
13552         install_element(BGP_IPV6M_NODE, &no_neighbor_capability_orf_prefix_cmd);
13553         install_element(BGP_IPV6L_NODE, &neighbor_capability_orf_prefix_cmd);
13554         install_element(BGP_IPV6L_NODE, &no_neighbor_capability_orf_prefix_cmd);
13555
13556         /* "neighbor capability dynamic" commands.*/
13557         install_element(BGP_NODE, &neighbor_capability_dynamic_cmd);
13558         install_element(BGP_NODE, &no_neighbor_capability_dynamic_cmd);
13559
13560         /* "neighbor dont-capability-negotiate" commands. */
13561         install_element(BGP_NODE, &neighbor_dont_capability_negotiate_cmd);
13562         install_element(BGP_NODE, &no_neighbor_dont_capability_negotiate_cmd);
13563
13564         /* "neighbor ebgp-multihop" commands. */
13565         install_element(BGP_NODE, &neighbor_ebgp_multihop_cmd);
13566         install_element(BGP_NODE, &neighbor_ebgp_multihop_ttl_cmd);
13567         install_element(BGP_NODE, &no_neighbor_ebgp_multihop_cmd);
13568
13569         /* "neighbor disable-connected-check" commands.  */
13570         install_element(BGP_NODE, &neighbor_disable_connected_check_cmd);
13571         install_element(BGP_NODE, &no_neighbor_disable_connected_check_cmd);
13572
13573         /* "neighbor enforce-first-as" commands. */
13574         install_element(BGP_NODE, &neighbor_enforce_first_as_cmd);
13575         install_element(BGP_NODE, &no_neighbor_enforce_first_as_cmd);
13576
13577         /* "neighbor description" commands. */
13578         install_element(BGP_NODE, &neighbor_description_cmd);
13579         install_element(BGP_NODE, &no_neighbor_description_cmd);
13580         install_element(BGP_NODE, &no_neighbor_description_comment_cmd);
13581
13582         /* "neighbor update-source" commands. "*/
13583         install_element(BGP_NODE, &neighbor_update_source_cmd);
13584         install_element(BGP_NODE, &no_neighbor_update_source_cmd);
13585
13586         /* "neighbor default-originate" commands. */
13587         install_element(BGP_NODE, &neighbor_default_originate_hidden_cmd);
13588         install_element(BGP_NODE, &neighbor_default_originate_rmap_hidden_cmd);
13589         install_element(BGP_NODE, &no_neighbor_default_originate_hidden_cmd);
13590         install_element(BGP_IPV4_NODE, &neighbor_default_originate_cmd);
13591         install_element(BGP_IPV4_NODE, &neighbor_default_originate_rmap_cmd);
13592         install_element(BGP_IPV4_NODE, &no_neighbor_default_originate_cmd);
13593         install_element(BGP_IPV4M_NODE, &neighbor_default_originate_cmd);
13594         install_element(BGP_IPV4M_NODE, &neighbor_default_originate_rmap_cmd);
13595         install_element(BGP_IPV4M_NODE, &no_neighbor_default_originate_cmd);
13596         install_element(BGP_IPV4L_NODE, &neighbor_default_originate_cmd);
13597         install_element(BGP_IPV4L_NODE, &neighbor_default_originate_rmap_cmd);
13598         install_element(BGP_IPV4L_NODE, &no_neighbor_default_originate_cmd);
13599         install_element(BGP_IPV6_NODE, &neighbor_default_originate_cmd);
13600         install_element(BGP_IPV6_NODE, &neighbor_default_originate_rmap_cmd);
13601         install_element(BGP_IPV6_NODE, &no_neighbor_default_originate_cmd);
13602         install_element(BGP_IPV6M_NODE, &neighbor_default_originate_cmd);
13603         install_element(BGP_IPV6M_NODE, &neighbor_default_originate_rmap_cmd);
13604         install_element(BGP_IPV6M_NODE, &no_neighbor_default_originate_cmd);
13605         install_element(BGP_IPV6L_NODE, &neighbor_default_originate_cmd);
13606         install_element(BGP_IPV6L_NODE, &neighbor_default_originate_rmap_cmd);
13607         install_element(BGP_IPV6L_NODE, &no_neighbor_default_originate_cmd);
13608
13609         /* "neighbor port" commands. */
13610         install_element(BGP_NODE, &neighbor_port_cmd);
13611         install_element(BGP_NODE, &no_neighbor_port_cmd);
13612
13613         /* "neighbor weight" commands. */
13614         install_element(BGP_NODE, &neighbor_weight_hidden_cmd);
13615         install_element(BGP_NODE, &no_neighbor_weight_hidden_cmd);
13616
13617         install_element(BGP_IPV4_NODE, &neighbor_weight_cmd);
13618         install_element(BGP_IPV4_NODE, &no_neighbor_weight_cmd);
13619         install_element(BGP_IPV4M_NODE, &neighbor_weight_cmd);
13620         install_element(BGP_IPV4M_NODE, &no_neighbor_weight_cmd);
13621         install_element(BGP_IPV4L_NODE, &neighbor_weight_cmd);
13622         install_element(BGP_IPV4L_NODE, &no_neighbor_weight_cmd);
13623         install_element(BGP_IPV6_NODE, &neighbor_weight_cmd);
13624         install_element(BGP_IPV6_NODE, &no_neighbor_weight_cmd);
13625         install_element(BGP_IPV6M_NODE, &neighbor_weight_cmd);
13626         install_element(BGP_IPV6M_NODE, &no_neighbor_weight_cmd);
13627         install_element(BGP_IPV6L_NODE, &neighbor_weight_cmd);
13628         install_element(BGP_IPV6L_NODE, &no_neighbor_weight_cmd);
13629         install_element(BGP_VPNV4_NODE, &neighbor_weight_cmd);
13630         install_element(BGP_VPNV4_NODE, &no_neighbor_weight_cmd);
13631         install_element(BGP_VPNV6_NODE, &neighbor_weight_cmd);
13632         install_element(BGP_VPNV6_NODE, &no_neighbor_weight_cmd);
13633
13634         /* "neighbor override-capability" commands. */
13635         install_element(BGP_NODE, &neighbor_override_capability_cmd);
13636         install_element(BGP_NODE, &no_neighbor_override_capability_cmd);
13637
13638         /* "neighbor strict-capability-match" commands. */
13639         install_element(BGP_NODE, &neighbor_strict_capability_cmd);
13640         install_element(BGP_NODE, &no_neighbor_strict_capability_cmd);
13641
13642         /* "neighbor timers" commands. */
13643         install_element(BGP_NODE, &neighbor_timers_cmd);
13644         install_element(BGP_NODE, &no_neighbor_timers_cmd);
13645
13646         /* "neighbor timers connect" commands. */
13647         install_element(BGP_NODE, &neighbor_timers_connect_cmd);
13648         install_element(BGP_NODE, &no_neighbor_timers_connect_cmd);
13649
13650         /* "neighbor advertisement-interval" commands. */
13651         install_element(BGP_NODE, &neighbor_advertise_interval_cmd);
13652         install_element(BGP_NODE, &no_neighbor_advertise_interval_cmd);
13653
13654         /* "neighbor interface" commands. */
13655         install_element(BGP_NODE, &neighbor_interface_cmd);
13656         install_element(BGP_NODE, &no_neighbor_interface_cmd);
13657
13658         /* "neighbor distribute" commands. */
13659         install_element(BGP_NODE, &neighbor_distribute_list_hidden_cmd);
13660         install_element(BGP_NODE, &no_neighbor_distribute_list_hidden_cmd);
13661         install_element(BGP_IPV4_NODE, &neighbor_distribute_list_cmd);
13662         install_element(BGP_IPV4_NODE, &no_neighbor_distribute_list_cmd);
13663         install_element(BGP_IPV4M_NODE, &neighbor_distribute_list_cmd);
13664         install_element(BGP_IPV4M_NODE, &no_neighbor_distribute_list_cmd);
13665         install_element(BGP_IPV4L_NODE, &neighbor_distribute_list_cmd);
13666         install_element(BGP_IPV4L_NODE, &no_neighbor_distribute_list_cmd);
13667         install_element(BGP_IPV6_NODE, &neighbor_distribute_list_cmd);
13668         install_element(BGP_IPV6_NODE, &no_neighbor_distribute_list_cmd);
13669         install_element(BGP_IPV6M_NODE, &neighbor_distribute_list_cmd);
13670         install_element(BGP_IPV6M_NODE, &no_neighbor_distribute_list_cmd);
13671         install_element(BGP_IPV6L_NODE, &neighbor_distribute_list_cmd);
13672         install_element(BGP_IPV6L_NODE, &no_neighbor_distribute_list_cmd);
13673         install_element(BGP_VPNV4_NODE, &neighbor_distribute_list_cmd);
13674         install_element(BGP_VPNV4_NODE, &no_neighbor_distribute_list_cmd);
13675         install_element(BGP_VPNV6_NODE, &neighbor_distribute_list_cmd);
13676         install_element(BGP_VPNV6_NODE, &no_neighbor_distribute_list_cmd);
13677
13678         /* "neighbor prefix-list" commands. */
13679         install_element(BGP_NODE, &neighbor_prefix_list_hidden_cmd);
13680         install_element(BGP_NODE, &no_neighbor_prefix_list_hidden_cmd);
13681         install_element(BGP_IPV4_NODE, &neighbor_prefix_list_cmd);
13682         install_element(BGP_IPV4_NODE, &no_neighbor_prefix_list_cmd);
13683         install_element(BGP_IPV4M_NODE, &neighbor_prefix_list_cmd);
13684         install_element(BGP_IPV4M_NODE, &no_neighbor_prefix_list_cmd);
13685         install_element(BGP_IPV4L_NODE, &neighbor_prefix_list_cmd);
13686         install_element(BGP_IPV4L_NODE, &no_neighbor_prefix_list_cmd);
13687         install_element(BGP_IPV6_NODE, &neighbor_prefix_list_cmd);
13688         install_element(BGP_IPV6_NODE, &no_neighbor_prefix_list_cmd);
13689         install_element(BGP_IPV6M_NODE, &neighbor_prefix_list_cmd);
13690         install_element(BGP_IPV6M_NODE, &no_neighbor_prefix_list_cmd);
13691         install_element(BGP_IPV6L_NODE, &neighbor_prefix_list_cmd);
13692         install_element(BGP_IPV6L_NODE, &no_neighbor_prefix_list_cmd);
13693         install_element(BGP_VPNV4_NODE, &neighbor_prefix_list_cmd);
13694         install_element(BGP_VPNV4_NODE, &no_neighbor_prefix_list_cmd);
13695         install_element(BGP_VPNV6_NODE, &neighbor_prefix_list_cmd);
13696         install_element(BGP_VPNV6_NODE, &no_neighbor_prefix_list_cmd);
13697         install_element(BGP_FLOWSPECV4_NODE, &neighbor_prefix_list_cmd);
13698         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_prefix_list_cmd);
13699         install_element(BGP_FLOWSPECV6_NODE, &neighbor_prefix_list_cmd);
13700         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_prefix_list_cmd);
13701
13702         /* "neighbor filter-list" commands. */
13703         install_element(BGP_NODE, &neighbor_filter_list_hidden_cmd);
13704         install_element(BGP_NODE, &no_neighbor_filter_list_hidden_cmd);
13705         install_element(BGP_IPV4_NODE, &neighbor_filter_list_cmd);
13706         install_element(BGP_IPV4_NODE, &no_neighbor_filter_list_cmd);
13707         install_element(BGP_IPV4M_NODE, &neighbor_filter_list_cmd);
13708         install_element(BGP_IPV4M_NODE, &no_neighbor_filter_list_cmd);
13709         install_element(BGP_IPV4L_NODE, &neighbor_filter_list_cmd);
13710         install_element(BGP_IPV4L_NODE, &no_neighbor_filter_list_cmd);
13711         install_element(BGP_IPV6_NODE, &neighbor_filter_list_cmd);
13712         install_element(BGP_IPV6_NODE, &no_neighbor_filter_list_cmd);
13713         install_element(BGP_IPV6M_NODE, &neighbor_filter_list_cmd);
13714         install_element(BGP_IPV6M_NODE, &no_neighbor_filter_list_cmd);
13715         install_element(BGP_IPV6L_NODE, &neighbor_filter_list_cmd);
13716         install_element(BGP_IPV6L_NODE, &no_neighbor_filter_list_cmd);
13717         install_element(BGP_VPNV4_NODE, &neighbor_filter_list_cmd);
13718         install_element(BGP_VPNV4_NODE, &no_neighbor_filter_list_cmd);
13719         install_element(BGP_VPNV6_NODE, &neighbor_filter_list_cmd);
13720         install_element(BGP_VPNV6_NODE, &no_neighbor_filter_list_cmd);
13721         install_element(BGP_FLOWSPECV4_NODE, &neighbor_filter_list_cmd);
13722         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_filter_list_cmd);
13723         install_element(BGP_FLOWSPECV6_NODE, &neighbor_filter_list_cmd);
13724         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_filter_list_cmd);
13725
13726         /* "neighbor route-map" commands. */
13727         install_element(BGP_NODE, &neighbor_route_map_hidden_cmd);
13728         install_element(BGP_NODE, &no_neighbor_route_map_hidden_cmd);
13729         install_element(BGP_IPV4_NODE, &neighbor_route_map_cmd);
13730         install_element(BGP_IPV4_NODE, &no_neighbor_route_map_cmd);
13731         install_element(BGP_IPV4M_NODE, &neighbor_route_map_cmd);
13732         install_element(BGP_IPV4M_NODE, &no_neighbor_route_map_cmd);
13733         install_element(BGP_IPV4L_NODE, &neighbor_route_map_cmd);
13734         install_element(BGP_IPV4L_NODE, &no_neighbor_route_map_cmd);
13735         install_element(BGP_IPV6_NODE, &neighbor_route_map_cmd);
13736         install_element(BGP_IPV6_NODE, &no_neighbor_route_map_cmd);
13737         install_element(BGP_IPV6M_NODE, &neighbor_route_map_cmd);
13738         install_element(BGP_IPV6M_NODE, &no_neighbor_route_map_cmd);
13739         install_element(BGP_IPV6L_NODE, &neighbor_route_map_cmd);
13740         install_element(BGP_IPV6L_NODE, &no_neighbor_route_map_cmd);
13741         install_element(BGP_VPNV4_NODE, &neighbor_route_map_cmd);
13742         install_element(BGP_VPNV4_NODE, &no_neighbor_route_map_cmd);
13743         install_element(BGP_VPNV6_NODE, &neighbor_route_map_cmd);
13744         install_element(BGP_VPNV6_NODE, &no_neighbor_route_map_cmd);
13745         install_element(BGP_FLOWSPECV4_NODE, &neighbor_route_map_cmd);
13746         install_element(BGP_FLOWSPECV4_NODE, &no_neighbor_route_map_cmd);
13747         install_element(BGP_FLOWSPECV6_NODE, &neighbor_route_map_cmd);
13748         install_element(BGP_FLOWSPECV6_NODE, &no_neighbor_route_map_cmd);
13749         install_element(BGP_EVPN_NODE, &neighbor_route_map_cmd);
13750         install_element(BGP_EVPN_NODE, &no_neighbor_route_map_cmd);
13751
13752         /* "neighbor unsuppress-map" commands. */
13753         install_element(BGP_NODE, &neighbor_unsuppress_map_hidden_cmd);
13754         install_element(BGP_NODE, &no_neighbor_unsuppress_map_hidden_cmd);
13755         install_element(BGP_IPV4_NODE, &neighbor_unsuppress_map_cmd);
13756         install_element(BGP_IPV4_NODE, &no_neighbor_unsuppress_map_cmd);
13757         install_element(BGP_IPV4M_NODE, &neighbor_unsuppress_map_cmd);
13758         install_element(BGP_IPV4M_NODE, &no_neighbor_unsuppress_map_cmd);
13759         install_element(BGP_IPV4L_NODE, &neighbor_unsuppress_map_cmd);
13760         install_element(BGP_IPV4L_NODE, &no_neighbor_unsuppress_map_cmd);
13761         install_element(BGP_IPV6_NODE, &neighbor_unsuppress_map_cmd);
13762         install_element(BGP_IPV6_NODE, &no_neighbor_unsuppress_map_cmd);
13763         install_element(BGP_IPV6M_NODE, &neighbor_unsuppress_map_cmd);
13764         install_element(BGP_IPV6M_NODE, &no_neighbor_unsuppress_map_cmd);
13765         install_element(BGP_IPV6L_NODE, &neighbor_unsuppress_map_cmd);
13766         install_element(BGP_IPV6L_NODE, &no_neighbor_unsuppress_map_cmd);
13767         install_element(BGP_VPNV4_NODE, &neighbor_unsuppress_map_cmd);
13768         install_element(BGP_VPNV4_NODE, &no_neighbor_unsuppress_map_cmd);
13769         install_element(BGP_VPNV6_NODE, &neighbor_unsuppress_map_cmd);
13770         install_element(BGP_VPNV6_NODE, &no_neighbor_unsuppress_map_cmd);
13771
13772         /* "neighbor maximum-prefix" commands. */
13773         install_element(BGP_NODE, &neighbor_maximum_prefix_hidden_cmd);
13774         install_element(BGP_NODE,
13775                         &neighbor_maximum_prefix_threshold_hidden_cmd);
13776         install_element(BGP_NODE, &neighbor_maximum_prefix_warning_hidden_cmd);
13777         install_element(BGP_NODE,
13778                         &neighbor_maximum_prefix_threshold_warning_hidden_cmd);
13779         install_element(BGP_NODE, &neighbor_maximum_prefix_restart_hidden_cmd);
13780         install_element(BGP_NODE,
13781                         &neighbor_maximum_prefix_threshold_restart_hidden_cmd);
13782         install_element(BGP_NODE, &no_neighbor_maximum_prefix_hidden_cmd);
13783         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_cmd);
13784         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
13785         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_warning_cmd);
13786         install_element(BGP_IPV4_NODE,
13787                         &neighbor_maximum_prefix_threshold_warning_cmd);
13788         install_element(BGP_IPV4_NODE, &neighbor_maximum_prefix_restart_cmd);
13789         install_element(BGP_IPV4_NODE,
13790                         &neighbor_maximum_prefix_threshold_restart_cmd);
13791         install_element(BGP_IPV4_NODE, &no_neighbor_maximum_prefix_cmd);
13792         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_cmd);
13793         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_cmd);
13794         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_warning_cmd);
13795         install_element(BGP_IPV4M_NODE,
13796                         &neighbor_maximum_prefix_threshold_warning_cmd);
13797         install_element(BGP_IPV4M_NODE, &neighbor_maximum_prefix_restart_cmd);
13798         install_element(BGP_IPV4M_NODE,
13799                         &neighbor_maximum_prefix_threshold_restart_cmd);
13800         install_element(BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_cmd);
13801         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_cmd);
13802         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_threshold_cmd);
13803         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_warning_cmd);
13804         install_element(BGP_IPV4L_NODE,
13805                         &neighbor_maximum_prefix_threshold_warning_cmd);
13806         install_element(BGP_IPV4L_NODE, &neighbor_maximum_prefix_restart_cmd);
13807         install_element(BGP_IPV4L_NODE,
13808                         &neighbor_maximum_prefix_threshold_restart_cmd);
13809         install_element(BGP_IPV4L_NODE, &no_neighbor_maximum_prefix_cmd);
13810         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_cmd);
13811         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
13812         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
13813         install_element(BGP_IPV6_NODE,
13814                         &neighbor_maximum_prefix_threshold_warning_cmd);
13815         install_element(BGP_IPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
13816         install_element(BGP_IPV6_NODE,
13817                         &neighbor_maximum_prefix_threshold_restart_cmd);
13818         install_element(BGP_IPV6_NODE, &no_neighbor_maximum_prefix_cmd);
13819         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_cmd);
13820         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_cmd);
13821         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_warning_cmd);
13822         install_element(BGP_IPV6M_NODE,
13823                         &neighbor_maximum_prefix_threshold_warning_cmd);
13824         install_element(BGP_IPV6M_NODE, &neighbor_maximum_prefix_restart_cmd);
13825         install_element(BGP_IPV6M_NODE,
13826                         &neighbor_maximum_prefix_threshold_restart_cmd);
13827         install_element(BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_cmd);
13828         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_cmd);
13829         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_threshold_cmd);
13830         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_warning_cmd);
13831         install_element(BGP_IPV6L_NODE,
13832                         &neighbor_maximum_prefix_threshold_warning_cmd);
13833         install_element(BGP_IPV6L_NODE, &neighbor_maximum_prefix_restart_cmd);
13834         install_element(BGP_IPV6L_NODE,
13835                         &neighbor_maximum_prefix_threshold_restart_cmd);
13836         install_element(BGP_IPV6L_NODE, &no_neighbor_maximum_prefix_cmd);
13837         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_cmd);
13838         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
13839         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_warning_cmd);
13840         install_element(BGP_VPNV4_NODE,
13841                         &neighbor_maximum_prefix_threshold_warning_cmd);
13842         install_element(BGP_VPNV4_NODE, &neighbor_maximum_prefix_restart_cmd);
13843         install_element(BGP_VPNV4_NODE,
13844                         &neighbor_maximum_prefix_threshold_restart_cmd);
13845         install_element(BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_cmd);
13846         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_cmd);
13847         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
13848         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_warning_cmd);
13849         install_element(BGP_VPNV6_NODE,
13850                         &neighbor_maximum_prefix_threshold_warning_cmd);
13851         install_element(BGP_VPNV6_NODE, &neighbor_maximum_prefix_restart_cmd);
13852         install_element(BGP_VPNV6_NODE,
13853                         &neighbor_maximum_prefix_threshold_restart_cmd);
13854         install_element(BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_cmd);
13855
13856         /* "neighbor allowas-in" */
13857         install_element(BGP_NODE, &neighbor_allowas_in_hidden_cmd);
13858         install_element(BGP_NODE, &no_neighbor_allowas_in_hidden_cmd);
13859         install_element(BGP_IPV4_NODE, &neighbor_allowas_in_cmd);
13860         install_element(BGP_IPV4_NODE, &no_neighbor_allowas_in_cmd);
13861         install_element(BGP_IPV4M_NODE, &neighbor_allowas_in_cmd);
13862         install_element(BGP_IPV4M_NODE, &no_neighbor_allowas_in_cmd);
13863         install_element(BGP_IPV4L_NODE, &neighbor_allowas_in_cmd);
13864         install_element(BGP_IPV4L_NODE, &no_neighbor_allowas_in_cmd);
13865         install_element(BGP_IPV6_NODE, &neighbor_allowas_in_cmd);
13866         install_element(BGP_IPV6_NODE, &no_neighbor_allowas_in_cmd);
13867         install_element(BGP_IPV6M_NODE, &neighbor_allowas_in_cmd);
13868         install_element(BGP_IPV6M_NODE, &no_neighbor_allowas_in_cmd);
13869         install_element(BGP_IPV6L_NODE, &neighbor_allowas_in_cmd);
13870         install_element(BGP_IPV6L_NODE, &no_neighbor_allowas_in_cmd);
13871         install_element(BGP_VPNV4_NODE, &neighbor_allowas_in_cmd);
13872         install_element(BGP_VPNV4_NODE, &no_neighbor_allowas_in_cmd);
13873         install_element(BGP_VPNV6_NODE, &neighbor_allowas_in_cmd);
13874         install_element(BGP_VPNV6_NODE, &no_neighbor_allowas_in_cmd);
13875         install_element(BGP_EVPN_NODE, &neighbor_allowas_in_cmd);
13876         install_element(BGP_EVPN_NODE, &no_neighbor_allowas_in_cmd);
13877
13878         /* address-family commands. */
13879         install_element(BGP_NODE, &address_family_ipv4_safi_cmd);
13880         install_element(BGP_NODE, &address_family_ipv6_safi_cmd);
13881 #ifdef KEEP_OLD_VPN_COMMANDS
13882         install_element(BGP_NODE, &address_family_vpnv4_cmd);
13883         install_element(BGP_NODE, &address_family_vpnv6_cmd);
13884 #endif /* KEEP_OLD_VPN_COMMANDS */
13885
13886         install_element(BGP_NODE, &address_family_evpn_cmd);
13887
13888         /* "exit-address-family" command. */
13889         install_element(BGP_IPV4_NODE, &exit_address_family_cmd);
13890         install_element(BGP_IPV4M_NODE, &exit_address_family_cmd);
13891         install_element(BGP_IPV4L_NODE, &exit_address_family_cmd);
13892         install_element(BGP_IPV6_NODE, &exit_address_family_cmd);
13893         install_element(BGP_IPV6M_NODE, &exit_address_family_cmd);
13894         install_element(BGP_IPV6L_NODE, &exit_address_family_cmd);
13895         install_element(BGP_VPNV4_NODE, &exit_address_family_cmd);
13896         install_element(BGP_VPNV6_NODE, &exit_address_family_cmd);
13897         install_element(BGP_FLOWSPECV4_NODE, &exit_address_family_cmd);
13898         install_element(BGP_FLOWSPECV6_NODE, &exit_address_family_cmd);
13899         install_element(BGP_EVPN_NODE, &exit_address_family_cmd);
13900
13901         /* "clear ip bgp commands" */
13902         install_element(ENABLE_NODE, &clear_ip_bgp_all_cmd);
13903
13904         /* clear ip bgp prefix  */
13905         install_element(ENABLE_NODE, &clear_ip_bgp_prefix_cmd);
13906         install_element(ENABLE_NODE, &clear_bgp_ipv6_safi_prefix_cmd);
13907         install_element(ENABLE_NODE, &clear_bgp_instance_ipv6_safi_prefix_cmd);
13908
13909         /* "show [ip] bgp summary" commands. */
13910         install_element(VIEW_NODE, &show_bgp_instance_all_ipv6_updgrps_cmd);
13911         install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_updgrps_cmd);
13912         install_element(VIEW_NODE, &show_bgp_instance_updgrps_stats_cmd);
13913         install_element(VIEW_NODE, &show_bgp_updgrps_stats_cmd);
13914         install_element(VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_s_cmd);
13915         install_element(VIEW_NODE, &show_ip_bgp_summary_cmd);
13916         install_element(VIEW_NODE, &show_ip_bgp_updgrps_cmd);
13917
13918         /* "show [ip] bgp neighbors" commands. */
13919         install_element(VIEW_NODE, &show_ip_bgp_neighbors_cmd);
13920
13921         /* "show [ip] bgp peer-group" commands. */
13922         install_element(VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
13923
13924         /* "show [ip] bgp paths" commands. */
13925         install_element(VIEW_NODE, &show_ip_bgp_paths_cmd);
13926
13927         /* "show [ip] bgp community" commands. */
13928         install_element(VIEW_NODE, &show_ip_bgp_community_info_cmd);
13929
13930         /* "show ip bgp large-community" commands. */
13931         install_element(VIEW_NODE, &show_ip_bgp_lcommunity_info_cmd);
13932         /* "show [ip] bgp attribute-info" commands. */
13933         install_element(VIEW_NODE, &show_ip_bgp_attr_info_cmd);
13934         /* "show [ip] bgp route-leak" command */
13935         install_element(VIEW_NODE, &show_ip_bgp_route_leak_cmd);
13936
13937         /* "redistribute" commands.  */
13938         install_element(BGP_NODE, &bgp_redistribute_ipv4_hidden_cmd);
13939         install_element(BGP_NODE, &no_bgp_redistribute_ipv4_hidden_cmd);
13940         install_element(BGP_NODE, &bgp_redistribute_ipv4_rmap_hidden_cmd);
13941         install_element(BGP_NODE, &bgp_redistribute_ipv4_metric_hidden_cmd);
13942         install_element(BGP_NODE,
13943                         &bgp_redistribute_ipv4_rmap_metric_hidden_cmd);
13944         install_element(BGP_NODE,
13945                         &bgp_redistribute_ipv4_metric_rmap_hidden_cmd);
13946         install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_hidden_cmd);
13947         install_element(BGP_NODE, &no_bgp_redistribute_ipv4_ospf_hidden_cmd);
13948         install_element(BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_hidden_cmd);
13949         install_element(BGP_NODE,
13950                         &bgp_redistribute_ipv4_ospf_metric_hidden_cmd);
13951         install_element(BGP_NODE,
13952                         &bgp_redistribute_ipv4_ospf_rmap_metric_hidden_cmd);
13953         install_element(BGP_NODE,
13954                         &bgp_redistribute_ipv4_ospf_metric_rmap_hidden_cmd);
13955         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_cmd);
13956         install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_cmd);
13957         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_cmd);
13958         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_cmd);
13959         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
13960         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
13961         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_cmd);
13962         install_element(BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
13963         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
13964         install_element(BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
13965         install_element(BGP_IPV4_NODE,
13966                         &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
13967         install_element(BGP_IPV4_NODE,
13968                         &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
13969         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_cmd);
13970         install_element(BGP_IPV6_NODE, &no_bgp_redistribute_ipv6_cmd);
13971         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_cmd);
13972         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_cmd);
13973         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_metric_cmd);
13974         install_element(BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_rmap_cmd);
13975
13976         /* import|export vpn [route-map WORD] */
13977         install_element(BGP_IPV4_NODE, &bgp_imexport_vpn_cmd);
13978         install_element(BGP_IPV6_NODE, &bgp_imexport_vpn_cmd);
13979
13980         install_element(BGP_IPV4_NODE, &bgp_imexport_vrf_cmd);
13981         install_element(BGP_IPV6_NODE, &bgp_imexport_vrf_cmd);
13982
13983         /* ttl_security commands */
13984         install_element(BGP_NODE, &neighbor_ttl_security_cmd);
13985         install_element(BGP_NODE, &no_neighbor_ttl_security_cmd);
13986
13987         /* "show [ip] bgp memory" commands. */
13988         install_element(VIEW_NODE, &show_bgp_memory_cmd);
13989
13990         /* "show bgp martian next-hop" */
13991         install_element(VIEW_NODE, &show_bgp_martian_nexthop_db_cmd);
13992
13993         install_element(VIEW_NODE, &show_bgp_mac_hash_cmd);
13994
13995         /* "show [ip] bgp views" commands. */
13996         install_element(VIEW_NODE, &show_bgp_views_cmd);
13997
13998         /* "show [ip] bgp vrfs" commands. */
13999         install_element(VIEW_NODE, &show_bgp_vrfs_cmd);
14000
14001         /* Community-list. */
14002         community_list_vty();
14003
14004         /* vpn-policy commands */
14005         install_element(BGP_IPV4_NODE, &af_rd_vpn_export_cmd);
14006         install_element(BGP_IPV6_NODE, &af_rd_vpn_export_cmd);
14007         install_element(BGP_IPV4_NODE, &af_label_vpn_export_cmd);
14008         install_element(BGP_IPV6_NODE, &af_label_vpn_export_cmd);
14009         install_element(BGP_IPV4_NODE, &af_nexthop_vpn_export_cmd);
14010         install_element(BGP_IPV6_NODE, &af_nexthop_vpn_export_cmd);
14011         install_element(BGP_IPV4_NODE, &af_rt_vpn_imexport_cmd);
14012         install_element(BGP_IPV6_NODE, &af_rt_vpn_imexport_cmd);
14013         install_element(BGP_IPV4_NODE, &af_route_map_vpn_imexport_cmd);
14014         install_element(BGP_IPV6_NODE, &af_route_map_vpn_imexport_cmd);
14015         install_element(BGP_IPV4_NODE, &af_import_vrf_route_map_cmd);
14016         install_element(BGP_IPV6_NODE, &af_import_vrf_route_map_cmd);
14017
14018         install_element(BGP_IPV4_NODE, &af_routetarget_import_cmd);
14019         install_element(BGP_IPV6_NODE, &af_routetarget_import_cmd);
14020
14021         install_element(BGP_IPV4_NODE, &af_no_rd_vpn_export_cmd);
14022         install_element(BGP_IPV6_NODE, &af_no_rd_vpn_export_cmd);
14023         install_element(BGP_IPV4_NODE, &af_no_label_vpn_export_cmd);
14024         install_element(BGP_IPV6_NODE, &af_no_label_vpn_export_cmd);
14025         install_element(BGP_IPV4_NODE, &af_no_nexthop_vpn_export_cmd);
14026         install_element(BGP_IPV6_NODE, &af_no_nexthop_vpn_export_cmd);
14027         install_element(BGP_IPV4_NODE, &af_no_rt_vpn_imexport_cmd);
14028         install_element(BGP_IPV6_NODE, &af_no_rt_vpn_imexport_cmd);
14029         install_element(BGP_IPV4_NODE, &af_no_route_map_vpn_imexport_cmd);
14030         install_element(BGP_IPV6_NODE, &af_no_route_map_vpn_imexport_cmd);
14031         install_element(BGP_IPV4_NODE, &af_no_import_vrf_route_map_cmd);
14032         install_element(BGP_IPV6_NODE, &af_no_import_vrf_route_map_cmd);
14033 }
14034
14035 #include "memory.h"
14036 #include "bgp_regex.h"
14037 #include "bgp_clist.h"
14038 #include "bgp_ecommunity.h"
14039
14040 /* VTY functions.  */
14041
14042 /* Direction value to string conversion.  */
14043 static const char *community_direct_str(int direct)
14044 {
14045         switch (direct) {
14046         case COMMUNITY_DENY:
14047                 return "deny";
14048         case COMMUNITY_PERMIT:
14049                 return "permit";
14050         default:
14051                 return "unknown";
14052         }
14053 }
14054
14055 /* Display error string.  */
14056 static void community_list_perror(struct vty *vty, int ret)
14057 {
14058         switch (ret) {
14059         case COMMUNITY_LIST_ERR_CANT_FIND_LIST:
14060                 vty_out(vty, "%% Can't find community-list\n");
14061                 break;
14062         case COMMUNITY_LIST_ERR_MALFORMED_VAL:
14063                 vty_out(vty, "%% Malformed community-list value\n");
14064                 break;
14065         case COMMUNITY_LIST_ERR_STANDARD_CONFLICT:
14066                 vty_out(vty,
14067                         "%% Community name conflict, previously defined as standard community\n");
14068                 break;
14069         case COMMUNITY_LIST_ERR_EXPANDED_CONFLICT:
14070                 vty_out(vty,
14071                         "%% Community name conflict, previously defined as expanded community\n");
14072                 break;
14073         }
14074 }
14075
14076 /* "community-list" keyword help string.  */
14077 #define COMMUNITY_LIST_STR "Add a community list entry\n"
14078
14079 /*community-list standard */
14080 DEFUN (community_list_standard,
14081        bgp_community_list_standard_cmd,
14082        "bgp community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14083        BGP_STR
14084        COMMUNITY_LIST_STR
14085        "Community list number (standard)\n"
14086        "Add an standard community-list entry\n"
14087        "Community list name\n"
14088        "Specify community to reject\n"
14089        "Specify community to accept\n"
14090        COMMUNITY_VAL_STR)
14091 {
14092         char *cl_name_or_number = NULL;
14093         int direct = 0;
14094         int style = COMMUNITY_LIST_STANDARD;
14095
14096         int idx = 0;
14097
14098         if (argv_find(argv, argc, "ip", &idx)) {
14099                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14100                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14101                 vty_out(vty, "'bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
14102                 zlog_warn("Deprecated option: 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
14103         }
14104
14105         argv_find(argv, argc, "(1-99)", &idx);
14106         argv_find(argv, argc, "WORD", &idx);
14107         cl_name_or_number = argv[idx]->arg;
14108         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14109                                                        : COMMUNITY_DENY;
14110         argv_find(argv, argc, "AA:NN", &idx);
14111         char *str = argv_concat(argv, argc, idx);
14112
14113         int ret = community_list_set(bgp_clist, cl_name_or_number, str, direct,
14114                                      style);
14115
14116         XFREE(MTYPE_TMP, str);
14117
14118         if (ret < 0) {
14119                 /* Display error string.  */
14120                 community_list_perror(vty, ret);
14121                 return CMD_WARNING_CONFIG_FAILED;
14122         }
14123
14124         return CMD_SUCCESS;
14125 }
14126
14127 #if CONFDATE > 20191005
14128 CPP_NOTICE("bgpd: remove deprecated 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' command")
14129 #endif
14130 ALIAS (community_list_standard,
14131        ip_community_list_standard_cmd,
14132        "ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14133        IP_STR
14134        COMMUNITY_LIST_STR
14135        "Community list number (standard)\n"
14136        "Add an standard community-list entry\n"
14137        "Community list name\n"
14138        "Specify community to reject\n"
14139        "Specify community to accept\n"
14140        COMMUNITY_VAL_STR)
14141
14142 DEFUN (no_community_list_standard_all,
14143        no_bgp_community_list_standard_all_cmd,
14144        "no bgp community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14145        NO_STR
14146        BGP_STR
14147        COMMUNITY_LIST_STR
14148        "Community list number (standard)\n"
14149        "Add an standard community-list entry\n"
14150        "Community list name\n"
14151        "Specify community to reject\n"
14152        "Specify community to accept\n"
14153        COMMUNITY_VAL_STR)
14154 {
14155         char *cl_name_or_number = NULL;
14156         char *str = NULL;
14157         int direct = 0;
14158         int style = COMMUNITY_LIST_STANDARD;
14159
14160         int idx = 0;
14161
14162         if (argv_find(argv, argc, "ip", &idx)) {
14163                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
14164                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14165                 vty_out(vty, "'no bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
14166                 zlog_warn("Deprecated option: 'no ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> |AA:NN' being used");
14167         }
14168
14169         argv_find(argv, argc, "permit", &idx);
14170         argv_find(argv, argc, "deny", &idx);
14171
14172         if (idx) {
14173                 direct = argv_find(argv, argc, "permit", &idx)
14174                                  ? COMMUNITY_PERMIT
14175                                  : COMMUNITY_DENY;
14176
14177                 idx = 0;
14178                 argv_find(argv, argc, "AA:NN", &idx);
14179                 str = argv_concat(argv, argc, idx);
14180         }
14181
14182         idx = 0;
14183         argv_find(argv, argc, "(1-99)", &idx);
14184         argv_find(argv, argc, "WORD", &idx);
14185         cl_name_or_number = argv[idx]->arg;
14186
14187         int ret = community_list_unset(bgp_clist, cl_name_or_number, str,
14188                                        direct, style);
14189
14190         XFREE(MTYPE_TMP, str);
14191
14192         if (ret < 0) {
14193                 community_list_perror(vty, ret);
14194                 return CMD_WARNING_CONFIG_FAILED;
14195         }
14196
14197         return CMD_SUCCESS;
14198 }
14199 ALIAS (no_community_list_standard_all,
14200        no_ip_community_list_standard_all_cmd,
14201        "no ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
14202        NO_STR
14203        IP_STR
14204        COMMUNITY_LIST_STR
14205        "Community list number (standard)\n"
14206        "Add an standard community-list entry\n"
14207        "Community list name\n"
14208        "Specify community to reject\n"
14209        "Specify community to accept\n"
14210        COMMUNITY_VAL_STR)
14211
14212 ALIAS(no_community_list_standard_all, no_bgp_community_list_standard_all_list_cmd,
14213       "no bgp community-list <(1-99)|standard WORD>",
14214       NO_STR BGP_STR COMMUNITY_LIST_STR
14215       "Community list number (standard)\n"
14216       "Add an standard community-list entry\n"
14217       "Community list name\n")
14218
14219 ALIAS(no_community_list_standard_all, no_ip_community_list_standard_all_list_cmd,
14220       "no ip community-list <(1-99)|standard WORD>",
14221       NO_STR BGP_STR COMMUNITY_LIST_STR
14222       "Community list number (standard)\n"
14223       "Add an standard community-list entry\n"
14224       "Community list name\n")
14225
14226 /*community-list expanded */
14227 DEFUN (community_list_expanded_all,
14228        bgp_community_list_expanded_all_cmd,
14229        "bgp community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
14230        BGP_STR
14231        COMMUNITY_LIST_STR
14232        "Community list number (expanded)\n"
14233        "Add an expanded community-list entry\n"
14234        "Community list name\n"
14235        "Specify community to reject\n"
14236        "Specify community to accept\n"
14237        COMMUNITY_VAL_STR)
14238 {
14239         char *cl_name_or_number = NULL;
14240         int direct = 0;
14241         int style = COMMUNITY_LIST_EXPANDED;
14242
14243         int idx = 0;
14244         if (argv_find(argv, argc, "ip", &idx)) {
14245                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14246                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14247                 vty_out(vty, "'bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
14248                 zlog_warn("Deprecated option: 'ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
14249         }
14250         argv_find(argv, argc, "(100-500)", &idx);
14251         argv_find(argv, argc, "WORD", &idx);
14252         cl_name_or_number = argv[idx]->arg;
14253         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14254                                                        : COMMUNITY_DENY;
14255         argv_find(argv, argc, "AA:NN", &idx);
14256         char *str = argv_concat(argv, argc, idx);
14257
14258         int ret = community_list_set(bgp_clist, cl_name_or_number, str, direct,
14259                                      style);
14260
14261         XFREE(MTYPE_TMP, str);
14262
14263         if (ret < 0) {
14264                 /* Display error string.  */
14265                 community_list_perror(vty, ret);
14266                 return CMD_WARNING_CONFIG_FAILED;
14267         }
14268
14269         return CMD_SUCCESS;
14270 }
14271
14272 ALIAS (community_list_expanded_all,
14273        ip_community_list_expanded_all_cmd,
14274        "ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
14275        IP_STR
14276        COMMUNITY_LIST_STR
14277        "Community list number (expanded)\n"
14278        "Add an expanded community-list entry\n"
14279        "Community list name\n"
14280        "Specify community to reject\n"
14281        "Specify community to accept\n"
14282        COMMUNITY_VAL_STR)
14283
14284 DEFUN (no_community_list_expanded_all,
14285        no_bgp_community_list_expanded_all_cmd,
14286        "no bgp community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
14287        NO_STR
14288        BGP_STR
14289        COMMUNITY_LIST_STR
14290        "Community list number (expanded)\n"
14291        "Add an expanded community-list entry\n"
14292        "Community list name\n"
14293        "Specify community to reject\n"
14294        "Specify community to accept\n"
14295        COMMUNITY_VAL_STR)
14296 {
14297         char *cl_name_or_number = NULL;
14298         char *str = NULL;
14299         int direct = 0;
14300         int style = COMMUNITY_LIST_EXPANDED;
14301
14302         int idx = 0;
14303         if (argv_find(argv, argc, "ip", &idx)) {
14304                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14305                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14306                 vty_out(vty, "'no bgp community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN'\n");
14307                 zlog_warn("Deprecated option: 'no ip community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> AA:NN' being used");
14308         }
14309
14310         idx = 0;
14311         argv_find(argv, argc, "permit", &idx);
14312         argv_find(argv, argc, "deny", &idx);
14313
14314         if (idx) {
14315                 direct = argv_find(argv, argc, "permit", &idx)
14316                                  ? COMMUNITY_PERMIT
14317                                  : COMMUNITY_DENY;
14318
14319                 idx = 0;
14320                 argv_find(argv, argc, "AA:NN", &idx);
14321                 str = argv_concat(argv, argc, idx);
14322         }
14323
14324         idx = 0;
14325         argv_find(argv, argc, "(100-500)", &idx);
14326         argv_find(argv, argc, "WORD", &idx);
14327         cl_name_or_number = argv[idx]->arg;
14328
14329         int ret = community_list_unset(bgp_clist, cl_name_or_number, str,
14330                                        direct, style);
14331
14332         XFREE(MTYPE_TMP, str);
14333
14334         if (ret < 0) {
14335                 community_list_perror(vty, ret);
14336                 return CMD_WARNING_CONFIG_FAILED;
14337         }
14338
14339         return CMD_SUCCESS;
14340 }
14341
14342 ALIAS (no_community_list_expanded_all,
14343        no_ip_community_list_expanded_all_cmd,
14344        "no ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
14345        NO_STR
14346        IP_STR
14347        COMMUNITY_LIST_STR
14348        "Community list number (expanded)\n"
14349        "Add an expanded community-list entry\n"
14350        "Community list name\n"
14351        "Specify community to reject\n"
14352        "Specify community to accept\n"
14353        COMMUNITY_VAL_STR)
14354
14355 ALIAS(no_community_list_expanded_all, no_bgp_community_list_expanded_all_list_cmd,
14356       "no bgp community-list <(100-500)|expanded WORD>",
14357       NO_STR IP_STR COMMUNITY_LIST_STR
14358       "Community list number (expanded)\n"
14359       "Add an expanded community-list entry\n"
14360       "Community list name\n")
14361
14362 ALIAS(no_community_list_expanded_all, no_ip_community_list_expanded_all_list_cmd,
14363       "no ip community-list <(100-500)|expanded WORD>",
14364       NO_STR IP_STR COMMUNITY_LIST_STR
14365       "Community list number (expanded)\n"
14366       "Add an expanded community-list entry\n"
14367       "Community list name\n")
14368
14369 /* Return configuration string of community-list entry.  */
14370 static const char *community_list_config_str(struct community_entry *entry)
14371 {
14372         const char *str;
14373
14374         if (entry->any)
14375                 str = "";
14376         else {
14377                 if (entry->style == COMMUNITY_LIST_STANDARD)
14378                         str = community_str(entry->u.com, false);
14379                 else if (entry->style == LARGE_COMMUNITY_LIST_STANDARD)
14380                         str = lcommunity_str(entry->u.lcom, false);
14381                 else
14382                         str = entry->config;
14383         }
14384         return str;
14385 }
14386
14387 static void community_list_show(struct vty *vty, struct community_list *list)
14388 {
14389         struct community_entry *entry;
14390
14391         for (entry = list->head; entry; entry = entry->next) {
14392                 if (entry == list->head) {
14393                         if (all_digit(list->name))
14394                                 vty_out(vty, "Community %s list %s\n",
14395                                         entry->style == COMMUNITY_LIST_STANDARD
14396                                                 ? "standard"
14397                                                 : "(expanded) access",
14398                                         list->name);
14399                         else
14400                                 vty_out(vty, "Named Community %s list %s\n",
14401                                         entry->style == COMMUNITY_LIST_STANDARD
14402                                                 ? "standard"
14403                                                 : "expanded",
14404                                         list->name);
14405                 }
14406                 if (entry->any)
14407                         vty_out(vty, "    %s\n",
14408                                 community_direct_str(entry->direct));
14409                 else
14410                         vty_out(vty, "    %s %s\n",
14411                                 community_direct_str(entry->direct),
14412                                 community_list_config_str(entry));
14413         }
14414 }
14415
14416 DEFUN (show_community_list,
14417        show_bgp_community_list_cmd,
14418        "show bgp community-list",
14419        SHOW_STR
14420        BGP_STR
14421        "List community-list\n")
14422 {
14423         struct community_list *list;
14424         struct community_list_master *cm;
14425
14426         int idx = 0;
14427         if (argv_find(argv, argc, "ip", &idx)) {
14428                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14429                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14430                 vty_out(vty, "'show bgp community-list <(1-500)|WORD>'\n");
14431                 zlog_warn("Deprecated option: 'ip show community-list <(1-500)|WORD>' being used");
14432         }
14433         cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
14434         if (!cm)
14435                 return CMD_SUCCESS;
14436
14437         for (list = cm->num.head; list; list = list->next)
14438                 community_list_show(vty, list);
14439
14440         for (list = cm->str.head; list; list = list->next)
14441                 community_list_show(vty, list);
14442
14443         return CMD_SUCCESS;
14444 }
14445
14446 ALIAS (show_community_list,
14447        show_ip_community_list_cmd,
14448        "show ip community-list",
14449        SHOW_STR
14450        IP_STR
14451        "List community-list\n")
14452
14453 DEFUN (show_community_list_arg,
14454        show_bgp_community_list_arg_cmd,
14455        "show bgp community-list <(1-500)|WORD>",
14456        SHOW_STR
14457        BGP_STR
14458        "List community-list\n"
14459        "Community-list number\n"
14460        "Community-list name\n")
14461 {
14462         int idx_comm_list = 3;
14463         struct community_list *list;
14464
14465         int idx = 0;
14466         if (argv_find(argv, argc, "ip", &idx)) {
14467                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14468                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14469                 vty_out(vty, "'show bgp community-list <(1-500)|WORD>'\n");
14470                 zlog_warn("Deprecated option: 'ip show community-list <(1-500)|WORD>' being used");
14471         }
14472         list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
14473                                      COMMUNITY_LIST_MASTER);
14474         if (!list) {
14475                 vty_out(vty, "%% Can't find community-list\n");
14476                 return CMD_WARNING;
14477         }
14478
14479         community_list_show(vty, list);
14480
14481         return CMD_SUCCESS;
14482 }
14483
14484 ALIAS (show_community_list_arg,
14485        show_ip_community_list_arg_cmd,
14486        "show ip community-list <(1-500)|WORD>",
14487        SHOW_STR
14488        IP_STR
14489        "List community-list\n"
14490        "Community-list number\n"
14491        "Community-list name\n")
14492
14493 /*
14494  * Large Community code.
14495  */
14496 static int lcommunity_list_set_vty(struct vty *vty, int argc,
14497                                    struct cmd_token **argv, int style,
14498                                    int reject_all_digit_name)
14499 {
14500         int ret;
14501         int direct;
14502         char *str;
14503         int idx = 0;
14504         char *cl_name;
14505
14506         if (argv_find(argv, argc, "ip", &idx)) {
14507                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14508                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14509                 vty_out(vty, "'bgp large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>'\n");
14510                 zlog_warn("Deprecated option: 'large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' being used");
14511         }
14512         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
14513                                                        : COMMUNITY_DENY;
14514
14515         /* All digit name check.  */
14516         idx = 0;
14517         argv_find(argv, argc, "WORD", &idx);
14518         argv_find(argv, argc, "(1-99)", &idx);
14519         argv_find(argv, argc, "(100-500)", &idx);
14520         cl_name = argv[idx]->arg;
14521         if (reject_all_digit_name && all_digit(cl_name)) {
14522                 vty_out(vty, "%% Community name cannot have all digits\n");
14523                 return CMD_WARNING_CONFIG_FAILED;
14524         }
14525
14526         idx = 0;
14527         argv_find(argv, argc, "AA:BB:CC", &idx);
14528         argv_find(argv, argc, "LINE", &idx);
14529         /* Concat community string argument. */
14530         if (idx)
14531                 str = argv_concat(argv, argc, idx);
14532         else
14533                 str = NULL;
14534
14535         ret = lcommunity_list_set(bgp_clist, cl_name, str, direct, style);
14536
14537         /* Free temporary community list string allocated by
14538            argv_concat().  */
14539         XFREE(MTYPE_TMP, str);
14540
14541         if (ret < 0) {
14542                 community_list_perror(vty, ret);
14543                 return CMD_WARNING_CONFIG_FAILED;
14544         }
14545         return CMD_SUCCESS;
14546 }
14547
14548 static int lcommunity_list_unset_vty(struct vty *vty, int argc,
14549                                      struct cmd_token **argv, int style)
14550 {
14551         int ret;
14552         int direct = 0;
14553         char *str = NULL;
14554         int idx = 0;
14555
14556         if (argv_find(argv, argc, "ip", &idx)) {
14557                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14558                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14559                 vty_out(vty, "'no bgp large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>'\n");
14560                 zlog_warn("Deprecated option: 'no ip large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' being used");
14561         }
14562         argv_find(argv, argc, "permit", &idx);
14563         argv_find(argv, argc, "deny", &idx);
14564
14565         if (idx) {
14566                 /* Check the list direct. */
14567                 if (strncmp(argv[idx]->arg, "p", 1) == 0)
14568                         direct = COMMUNITY_PERMIT;
14569                 else
14570                         direct = COMMUNITY_DENY;
14571
14572                 idx = 0;
14573                 argv_find(argv, argc, "LINE", &idx);
14574                 argv_find(argv, argc, "AA:AA:NN", &idx);
14575                 /* Concat community string argument.  */
14576                 str = argv_concat(argv, argc, idx);
14577         }
14578
14579         idx = 0;
14580         argv_find(argv, argc, "(1-99)", &idx);
14581         argv_find(argv, argc, "(100-500)", &idx);
14582         argv_find(argv, argc, "WORD", &idx);
14583
14584         /* Unset community list.  */
14585         ret = lcommunity_list_unset(bgp_clist, argv[idx]->arg, str, direct,
14586                                     style);
14587
14588         /* Free temporary community list string allocated by
14589            argv_concat().  */
14590         XFREE(MTYPE_TMP, str);
14591
14592         if (ret < 0) {
14593                 community_list_perror(vty, ret);
14594                 return CMD_WARNING_CONFIG_FAILED;
14595         }
14596
14597         return CMD_SUCCESS;
14598 }
14599
14600 /* "large-community-list" keyword help string.  */
14601 #define LCOMMUNITY_LIST_STR "Add a large community list entry\n"
14602 #define LCOMMUNITY_VAL_STR  "large community in 'aa:bb:cc' format\n"
14603
14604 #if CONFDATE > 20191005
14605 CPP_NOTICE("bgpd: remove deprecated 'ip large-community-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:BB:CC>' command")
14606 #endif
14607 DEFUN (lcommunity_list_standard,
14608        bgp_lcommunity_list_standard_cmd,
14609        "bgp large-community-list (1-99) <deny|permit>",
14610        BGP_STR
14611        LCOMMUNITY_LIST_STR
14612        "Large Community list number (standard)\n"
14613        "Specify large community to reject\n"
14614        "Specify large community to accept\n")
14615 {
14616         return lcommunity_list_set_vty(vty, argc, argv,
14617                                        LARGE_COMMUNITY_LIST_STANDARD, 0);
14618 }
14619
14620 ALIAS (lcommunity_list_standard,
14621        ip_lcommunity_list_standard_cmd,
14622        "ip large-community-list (1-99) <deny|permit>",
14623        IP_STR
14624        LCOMMUNITY_LIST_STR
14625        "Large Community list number (standard)\n"
14626        "Specify large community to reject\n"
14627        "Specify large community to accept\n")
14628
14629 DEFUN (lcommunity_list_standard1,
14630        bgp_lcommunity_list_standard1_cmd,
14631        "bgp large-community-list (1-99) <deny|permit> AA:BB:CC...",
14632        BGP_STR
14633        LCOMMUNITY_LIST_STR
14634        "Large Community list number (standard)\n"
14635        "Specify large community to reject\n"
14636        "Specify large community to accept\n"
14637        LCOMMUNITY_VAL_STR)
14638 {
14639         return lcommunity_list_set_vty(vty, argc, argv,
14640                                        LARGE_COMMUNITY_LIST_STANDARD, 0);
14641 }
14642
14643 ALIAS (lcommunity_list_standard1,
14644        ip_lcommunity_list_standard1_cmd,
14645        "ip large-community-list (1-99) <deny|permit> AA:BB:CC...",
14646        IP_STR
14647        LCOMMUNITY_LIST_STR
14648        "Large Community list number (standard)\n"
14649        "Specify large community to reject\n"
14650        "Specify large community to accept\n"
14651        LCOMMUNITY_VAL_STR)
14652
14653 DEFUN (lcommunity_list_expanded,
14654        bgp_lcommunity_list_expanded_cmd,
14655        "bgp large-community-list (100-500) <deny|permit> LINE...",
14656        BGP_STR
14657        LCOMMUNITY_LIST_STR
14658        "Large Community list number (expanded)\n"
14659        "Specify large community to reject\n"
14660        "Specify large community to accept\n"
14661        "An ordered list as a regular-expression\n")
14662 {
14663         return lcommunity_list_set_vty(vty, argc, argv,
14664                                        LARGE_COMMUNITY_LIST_EXPANDED, 0);
14665 }
14666
14667 ALIAS (lcommunity_list_expanded,
14668        ip_lcommunity_list_expanded_cmd,
14669        "ip large-community-list (100-500) <deny|permit> LINE...",
14670        IP_STR
14671        LCOMMUNITY_LIST_STR
14672        "Large Community list number (expanded)\n"
14673        "Specify large community to reject\n"
14674        "Specify large community to accept\n"
14675        "An ordered list as a regular-expression\n")
14676
14677 DEFUN (lcommunity_list_name_standard,
14678        bgp_lcommunity_list_name_standard_cmd,
14679        "bgp large-community-list standard WORD <deny|permit>",
14680        BGP_STR
14681        LCOMMUNITY_LIST_STR
14682        "Specify standard large-community-list\n"
14683        "Large Community list name\n"
14684        "Specify large community to reject\n"
14685        "Specify large community to accept\n")
14686 {
14687         return lcommunity_list_set_vty(vty, argc, argv,
14688                                        LARGE_COMMUNITY_LIST_STANDARD, 1);
14689 }
14690
14691 ALIAS (lcommunity_list_name_standard,
14692        ip_lcommunity_list_name_standard_cmd,
14693        "ip large-community-list standard WORD <deny|permit>",
14694        IP_STR
14695        LCOMMUNITY_LIST_STR
14696        "Specify standard large-community-list\n"
14697        "Large Community list name\n"
14698        "Specify large community to reject\n"
14699        "Specify large community to accept\n")
14700
14701 DEFUN (lcommunity_list_name_standard1,
14702        bgp_lcommunity_list_name_standard1_cmd,
14703        "bgp large-community-list standard WORD <deny|permit> AA:BB:CC...",
14704        BGP_STR
14705        LCOMMUNITY_LIST_STR
14706        "Specify standard large-community-list\n"
14707        "Large Community list name\n"
14708        "Specify large community to reject\n"
14709        "Specify large community to accept\n"
14710        LCOMMUNITY_VAL_STR)
14711 {
14712         return lcommunity_list_set_vty(vty, argc, argv,
14713                                        LARGE_COMMUNITY_LIST_STANDARD, 1);
14714 }
14715
14716 ALIAS (lcommunity_list_name_standard1,
14717        ip_lcommunity_list_name_standard1_cmd,
14718        "ip large-community-list standard WORD <deny|permit> AA:BB:CC...",
14719        IP_STR
14720        LCOMMUNITY_LIST_STR
14721        "Specify standard large-community-list\n"
14722        "Large Community list name\n"
14723        "Specify large community to reject\n"
14724        "Specify large community to accept\n"
14725        LCOMMUNITY_VAL_STR)
14726
14727 DEFUN (lcommunity_list_name_expanded,
14728        bgp_lcommunity_list_name_expanded_cmd,
14729        "bgp large-community-list expanded WORD <deny|permit> LINE...",
14730        BGP_STR
14731        LCOMMUNITY_LIST_STR
14732        "Specify expanded large-community-list\n"
14733        "Large Community list name\n"
14734        "Specify large community to reject\n"
14735        "Specify large community to accept\n"
14736        "An ordered list as a regular-expression\n")
14737 {
14738         return lcommunity_list_set_vty(vty, argc, argv,
14739                                        LARGE_COMMUNITY_LIST_EXPANDED, 1);
14740 }
14741
14742 ALIAS (lcommunity_list_name_expanded,
14743        ip_lcommunity_list_name_expanded_cmd,
14744        "ip large-community-list expanded WORD <deny|permit> LINE...",
14745        IP_STR
14746        LCOMMUNITY_LIST_STR
14747        "Specify expanded large-community-list\n"
14748        "Large Community list name\n"
14749        "Specify large community to reject\n"
14750        "Specify large community to accept\n"
14751        "An ordered list as a regular-expression\n")
14752
14753 DEFUN (no_lcommunity_list_standard_all,
14754        no_bgp_lcommunity_list_standard_all_cmd,
14755        "no bgp large-community-list <(1-99)|(100-500)|WORD>",
14756        NO_STR
14757        BGP_STR
14758        LCOMMUNITY_LIST_STR
14759        "Large Community list number (standard)\n"
14760        "Large Community list number (expanded)\n"
14761        "Large Community list name\n")
14762 {
14763         return lcommunity_list_unset_vty(vty, argc, argv,
14764                                          LARGE_COMMUNITY_LIST_STANDARD);
14765 }
14766
14767 ALIAS (no_lcommunity_list_standard_all,
14768        no_ip_lcommunity_list_standard_all_cmd,
14769        "no ip large-community-list <(1-99)|(100-500)|WORD>",
14770        NO_STR
14771        IP_STR
14772        LCOMMUNITY_LIST_STR
14773        "Large Community list number (standard)\n"
14774        "Large Community list number (expanded)\n"
14775        "Large Community list name\n")
14776
14777 DEFUN (no_lcommunity_list_name_expanded_all,
14778        no_bgp_lcommunity_list_name_expanded_all_cmd,
14779        "no bgp large-community-list expanded WORD",
14780        NO_STR
14781        BGP_STR
14782        LCOMMUNITY_LIST_STR
14783        "Specify expanded large-community-list\n"
14784        "Large Community list name\n")
14785 {
14786         return lcommunity_list_unset_vty(vty, argc, argv,
14787                                          LARGE_COMMUNITY_LIST_EXPANDED);
14788 }
14789
14790 ALIAS (no_lcommunity_list_name_expanded_all,
14791        no_ip_lcommunity_list_name_expanded_all_cmd,
14792        "no ip large-community-list expanded WORD",
14793        NO_STR
14794        IP_STR
14795        LCOMMUNITY_LIST_STR
14796        "Specify expanded large-community-list\n"
14797        "Large Community list name\n")
14798
14799 DEFUN (no_lcommunity_list_standard,
14800        no_bgp_lcommunity_list_standard_cmd,
14801        "no bgp large-community-list (1-99) <deny|permit> AA:AA:NN...",
14802        NO_STR
14803        BGP_STR
14804        LCOMMUNITY_LIST_STR
14805        "Large Community list number (standard)\n"
14806        "Specify large community to reject\n"
14807        "Specify large community to accept\n"
14808        LCOMMUNITY_VAL_STR)
14809 {
14810         return lcommunity_list_unset_vty(vty, argc, argv,
14811                                          LARGE_COMMUNITY_LIST_STANDARD);
14812 }
14813
14814 ALIAS (no_lcommunity_list_standard,
14815        no_ip_lcommunity_list_standard_cmd,
14816        "no ip large-community-list (1-99) <deny|permit> AA:AA:NN...",
14817        NO_STR
14818        IP_STR
14819        LCOMMUNITY_LIST_STR
14820        "Large Community list number (standard)\n"
14821        "Specify large community to reject\n"
14822        "Specify large community to accept\n"
14823        LCOMMUNITY_VAL_STR)
14824
14825 DEFUN (no_lcommunity_list_expanded,
14826        no_bgp_lcommunity_list_expanded_cmd,
14827        "no bgp large-community-list (100-500) <deny|permit> LINE...",
14828        NO_STR
14829        BGP_STR
14830        LCOMMUNITY_LIST_STR
14831        "Large Community list number (expanded)\n"
14832        "Specify large community to reject\n"
14833        "Specify large community to accept\n"
14834        "An ordered list as a regular-expression\n")
14835 {
14836         return lcommunity_list_unset_vty(vty, argc, argv,
14837                                          LARGE_COMMUNITY_LIST_EXPANDED);
14838 }
14839
14840 ALIAS (no_lcommunity_list_expanded,
14841        no_ip_lcommunity_list_expanded_cmd,
14842        "no ip large-community-list (100-500) <deny|permit> LINE...",
14843        NO_STR
14844        IP_STR
14845        LCOMMUNITY_LIST_STR
14846        "Large Community list number (expanded)\n"
14847        "Specify large community to reject\n"
14848        "Specify large community to accept\n"
14849        "An ordered list as a regular-expression\n")
14850
14851 DEFUN (no_lcommunity_list_name_standard,
14852        no_bgp_lcommunity_list_name_standard_cmd,
14853        "no bgp large-community-list standard WORD <deny|permit> AA:AA:NN...",
14854        NO_STR
14855        BGP_STR
14856        LCOMMUNITY_LIST_STR
14857        "Specify standard large-community-list\n"
14858        "Large Community list name\n"
14859        "Specify large community to reject\n"
14860        "Specify large community to accept\n"
14861        LCOMMUNITY_VAL_STR)
14862 {
14863         return lcommunity_list_unset_vty(vty, argc, argv,
14864                                          LARGE_COMMUNITY_LIST_STANDARD);
14865 }
14866
14867 ALIAS (no_lcommunity_list_name_standard,
14868        no_ip_lcommunity_list_name_standard_cmd,
14869        "no ip large-community-list standard WORD <deny|permit> AA:AA:NN...",
14870        NO_STR
14871        IP_STR
14872        LCOMMUNITY_LIST_STR
14873        "Specify standard large-community-list\n"
14874        "Large Community list name\n"
14875        "Specify large community to reject\n"
14876        "Specify large community to accept\n"
14877        LCOMMUNITY_VAL_STR)
14878
14879 DEFUN (no_lcommunity_list_name_expanded,
14880        no_bgp_lcommunity_list_name_expanded_cmd,
14881        "no bgp large-community-list expanded WORD <deny|permit> LINE...",
14882        NO_STR
14883        BGP_STR
14884        LCOMMUNITY_LIST_STR
14885        "Specify expanded large-community-list\n"
14886        "Large community list name\n"
14887        "Specify large community to reject\n"
14888        "Specify large community to accept\n"
14889        "An ordered list as a regular-expression\n")
14890 {
14891         return lcommunity_list_unset_vty(vty, argc, argv,
14892                                          LARGE_COMMUNITY_LIST_EXPANDED);
14893 }
14894
14895 ALIAS (no_lcommunity_list_name_expanded,
14896        no_ip_lcommunity_list_name_expanded_cmd,
14897        "no ip large-community-list expanded WORD <deny|permit> LINE...",
14898        NO_STR
14899        IP_STR
14900        LCOMMUNITY_LIST_STR
14901        "Specify expanded large-community-list\n"
14902        "Large community list name\n"
14903        "Specify large community to reject\n"
14904        "Specify large community to accept\n"
14905        "An ordered list as a regular-expression\n")
14906
14907 static void lcommunity_list_show(struct vty *vty, struct community_list *list)
14908 {
14909         struct community_entry *entry;
14910
14911         for (entry = list->head; entry; entry = entry->next) {
14912                 if (entry == list->head) {
14913                         if (all_digit(list->name))
14914                                 vty_out(vty, "Large community %s list %s\n",
14915                                         entry->style ==
14916                                                 LARGE_COMMUNITY_LIST_STANDARD
14917                                                 ? "standard"
14918                                                 : "(expanded) access",
14919                                         list->name);
14920                         else
14921                                 vty_out(vty,
14922                                         "Named large community %s list %s\n",
14923                                         entry->style ==
14924                                                 LARGE_COMMUNITY_LIST_STANDARD
14925                                                 ? "standard"
14926                                                 : "expanded",
14927                                         list->name);
14928                 }
14929                 if (entry->any)
14930                         vty_out(vty, "    %s\n",
14931                                 community_direct_str(entry->direct));
14932                 else
14933                         vty_out(vty, "    %s %s\n",
14934                                 community_direct_str(entry->direct),
14935                                 community_list_config_str(entry));
14936         }
14937 }
14938
14939 DEFUN (show_lcommunity_list,
14940        show_bgp_lcommunity_list_cmd,
14941        "show bgp large-community-list",
14942        SHOW_STR
14943        BGP_STR
14944        "List large-community list\n")
14945 {
14946         struct community_list *list;
14947         struct community_list_master *cm;
14948         int idx = 0;
14949
14950         if (argv_find(argv, argc, "ip", &idx)) {
14951                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14952                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14953                 vty_out(vty, "'show bgp large-community-list <(1-500)|WORD>'\n");
14954                 zlog_warn("Deprecated option: 'ip show large-community-list <(1-500)|WORD>' being used");
14955         }
14956
14957         cm = community_list_master_lookup(bgp_clist,
14958                                           LARGE_COMMUNITY_LIST_MASTER);
14959         if (!cm)
14960                 return CMD_SUCCESS;
14961
14962         for (list = cm->num.head; list; list = list->next)
14963                 lcommunity_list_show(vty, list);
14964
14965         for (list = cm->str.head; list; list = list->next)
14966                 lcommunity_list_show(vty, list);
14967
14968         return CMD_SUCCESS;
14969 }
14970
14971 ALIAS (show_lcommunity_list,
14972        show_ip_lcommunity_list_cmd,
14973        "show ip large-community-list",
14974        SHOW_STR
14975        IP_STR
14976        "List large-community list\n")
14977
14978 DEFUN (show_lcommunity_list_arg,
14979        show_bgp_lcommunity_list_arg_cmd,
14980        "show bgp large-community-list <(1-500)|WORD>",
14981        SHOW_STR
14982        BGP_STR
14983        "List large-community list\n"
14984        "large-community-list number\n"
14985        "large-community-list name\n")
14986 {
14987         struct community_list *list;
14988         int idx = 0;
14989
14990         if (argv_find(argv, argc, "ip", &idx)) {
14991                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
14992                 vty_out(vty, "if you are using this please migrate to the below command.\n");
14993                 vty_out(vty, "'show bgp large-community-list <(1-500)|WORD>'\n");
14994                 zlog_warn("Deprecated option: 'ip show large-community-list <(1-500)|WORD>' being used");
14995         }
14996
14997         list = community_list_lookup(bgp_clist, argv[3]->arg, 0,
14998                                      LARGE_COMMUNITY_LIST_MASTER);
14999         if (!list) {
15000                 vty_out(vty, "%% Can't find extcommunity-list\n");
15001                 return CMD_WARNING;
15002         }
15003
15004         lcommunity_list_show(vty, list);
15005
15006         return CMD_SUCCESS;
15007 }
15008
15009 ALIAS (show_lcommunity_list_arg,
15010        show_ip_lcommunity_list_arg_cmd,
15011        "show ip large-community-list <(1-500)|WORD>",
15012        SHOW_STR
15013        IP_STR
15014        "List large-community list\n"
15015        "large-community-list number\n"
15016        "large-community-list name\n")
15017
15018 /* "extcommunity-list" keyword help string.  */
15019 #define EXTCOMMUNITY_LIST_STR "Add a extended community list entry\n"
15020 #define EXTCOMMUNITY_VAL_STR  "Extended community attribute in 'rt aa:nn_or_IPaddr:nn' OR 'soo aa:nn_or_IPaddr:nn' format\n"
15021
15022 DEFUN (extcommunity_list_standard,
15023        bgp_extcommunity_list_standard_cmd,
15024        "bgp extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
15025        BGP_STR
15026        EXTCOMMUNITY_LIST_STR
15027        "Extended Community list number (standard)\n"
15028        "Specify standard extcommunity-list\n"
15029        "Community list name\n"
15030        "Specify community to reject\n"
15031        "Specify community to accept\n"
15032        EXTCOMMUNITY_VAL_STR)
15033 {
15034         int style = EXTCOMMUNITY_LIST_STANDARD;
15035         int direct = 0;
15036         char *cl_number_or_name = NULL;
15037
15038         int idx = 0;
15039         if (argv_find(argv, argc, "ip", &idx)) {
15040                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
15041                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15042                 vty_out(vty, "'bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
15043                 zlog_warn("Deprecated option: 'ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
15044         }
15045         argv_find(argv, argc, "(1-99)", &idx);
15046         argv_find(argv, argc, "WORD", &idx);
15047         cl_number_or_name = argv[idx]->arg;
15048         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
15049                                                        : COMMUNITY_DENY;
15050         argv_find(argv, argc, "AA:NN", &idx);
15051         char *str = argv_concat(argv, argc, idx);
15052
15053         int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str,
15054                                         direct, style);
15055
15056         XFREE(MTYPE_TMP, str);
15057
15058         if (ret < 0) {
15059                 community_list_perror(vty, ret);
15060                 return CMD_WARNING_CONFIG_FAILED;
15061         }
15062
15063         return CMD_SUCCESS;
15064 }
15065
15066 #if CONFDATE > 20191005
15067 CPP_NOTICE("bgpd: remove deprecated 'ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' command")
15068 #endif
15069 ALIAS (extcommunity_list_standard,
15070        ip_extcommunity_list_standard_cmd,
15071        "ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
15072        IP_STR
15073        EXTCOMMUNITY_LIST_STR
15074        "Extended Community list number (standard)\n"
15075        "Specify standard extcommunity-list\n"
15076        "Community list name\n"
15077        "Specify community to reject\n"
15078        "Specify community to accept\n"
15079        EXTCOMMUNITY_VAL_STR)
15080
15081 DEFUN (extcommunity_list_name_expanded,
15082        bgp_extcommunity_list_name_expanded_cmd,
15083        "bgp extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
15084        BGP_STR
15085        EXTCOMMUNITY_LIST_STR
15086        "Extended Community list number (expanded)\n"
15087        "Specify expanded extcommunity-list\n"
15088        "Extended Community list name\n"
15089        "Specify community to reject\n"
15090        "Specify community to accept\n"
15091        "An ordered list as a regular-expression\n")
15092 {
15093         int style = EXTCOMMUNITY_LIST_EXPANDED;
15094         int direct = 0;
15095         char *cl_number_or_name = NULL;
15096
15097         int idx = 0;
15098         if (argv_find(argv, argc, "ip", &idx)) {
15099                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
15100                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15101                 vty_out(vty, "'extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
15102                 zlog_warn("Deprecated option: ‘ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
15103         }
15104
15105         argv_find(argv, argc, "(100-500)", &idx);
15106         argv_find(argv, argc, "WORD", &idx);
15107         cl_number_or_name = argv[idx]->arg;
15108         direct = argv_find(argv, argc, "permit", &idx) ? COMMUNITY_PERMIT
15109                                                        : COMMUNITY_DENY;
15110         argv_find(argv, argc, "LINE", &idx);
15111         char *str = argv_concat(argv, argc, idx);
15112
15113         int ret = extcommunity_list_set(bgp_clist, cl_number_or_name, str,
15114                                         direct, style);
15115
15116         XFREE(MTYPE_TMP, str);
15117
15118         if (ret < 0) {
15119                 community_list_perror(vty, ret);
15120                 return CMD_WARNING_CONFIG_FAILED;
15121         }
15122
15123         return CMD_SUCCESS;
15124 }
15125
15126 ALIAS (extcommunity_list_name_expanded,
15127        ip_extcommunity_list_name_expanded_cmd,
15128        "ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
15129        IP_STR
15130        EXTCOMMUNITY_LIST_STR
15131        "Extended Community list number (expanded)\n"
15132        "Specify expanded extcommunity-list\n"
15133        "Extended Community list name\n"
15134        "Specify community to reject\n"
15135        "Specify community to accept\n"
15136        "An ordered list as a regular-expression\n")
15137
15138 DEFUN (no_extcommunity_list_standard_all,
15139        no_bgp_extcommunity_list_standard_all_cmd,
15140        "no bgp extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
15141        NO_STR
15142        BGP_STR
15143        EXTCOMMUNITY_LIST_STR
15144        "Extended Community list number (standard)\n"
15145        "Specify standard extcommunity-list\n"
15146        "Community list name\n"
15147        "Specify community to reject\n"
15148        "Specify community to accept\n"
15149        EXTCOMMUNITY_VAL_STR)
15150 {
15151         int style = EXTCOMMUNITY_LIST_STANDARD;
15152         int direct = 0;
15153         char *cl_number_or_name = NULL;
15154         char *str = NULL;
15155
15156         int idx = 0;
15157         if (argv_find(argv, argc, "ip", &idx)) {
15158                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
15159                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15160                 vty_out(vty, "'no bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
15161                 zlog_warn("Deprecated option: ‘no ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
15162         }
15163
15164         idx = 0;
15165         argv_find(argv, argc, "permit", &idx);
15166         argv_find(argv, argc, "deny", &idx);
15167
15168         if (idx) {
15169                 direct = argv_find(argv, argc, "permit", &idx)
15170                                  ? COMMUNITY_PERMIT
15171                                  : COMMUNITY_DENY;
15172
15173                 idx = 0;
15174                 argv_find(argv, argc, "AA:NN", &idx);
15175                 str = argv_concat(argv, argc, idx);
15176         }
15177
15178         idx = 0;
15179         argv_find(argv, argc, "(1-99)", &idx);
15180         argv_find(argv, argc, "WORD", &idx);
15181         cl_number_or_name = argv[idx]->arg;
15182
15183         int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
15184                                           direct, style);
15185
15186         XFREE(MTYPE_TMP, str);
15187
15188         if (ret < 0) {
15189                 community_list_perror(vty, ret);
15190                 return CMD_WARNING_CONFIG_FAILED;
15191         }
15192
15193         return CMD_SUCCESS;
15194 }
15195
15196 ALIAS (no_extcommunity_list_standard_all,
15197        no_ip_extcommunity_list_standard_all_cmd,
15198        "no ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
15199        NO_STR
15200        IP_STR
15201        EXTCOMMUNITY_LIST_STR
15202        "Extended Community list number (standard)\n"
15203        "Specify standard extcommunity-list\n"
15204        "Community list name\n"
15205        "Specify community to reject\n"
15206        "Specify community to accept\n"
15207        EXTCOMMUNITY_VAL_STR)
15208
15209 ALIAS(no_extcommunity_list_standard_all,
15210       no_bgp_extcommunity_list_standard_all_list_cmd,
15211       "no bgp extcommunity-list <(1-99)|standard WORD>",
15212       NO_STR IP_STR EXTCOMMUNITY_LIST_STR
15213       "Extended Community list number (standard)\n"
15214       "Specify standard extcommunity-list\n"
15215       "Community list name\n")
15216
15217 ALIAS(no_extcommunity_list_standard_all,
15218       no_ip_extcommunity_list_standard_all_list_cmd,
15219       "no ip extcommunity-list <(1-99)|standard WORD>",
15220       NO_STR IP_STR EXTCOMMUNITY_LIST_STR
15221       "Extended Community list number (standard)\n"
15222       "Specify standard extcommunity-list\n"
15223       "Community list name\n")
15224
15225 DEFUN (no_extcommunity_list_expanded_all,
15226        no_bgp_extcommunity_list_expanded_all_cmd,
15227        "no bgp extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
15228        NO_STR
15229        BGP_STR
15230        EXTCOMMUNITY_LIST_STR
15231        "Extended Community list number (expanded)\n"
15232        "Specify expanded extcommunity-list\n"
15233        "Extended Community list name\n"
15234        "Specify community to reject\n"
15235        "Specify community to accept\n"
15236        "An ordered list as a regular-expression\n")
15237 {
15238         int style = EXTCOMMUNITY_LIST_EXPANDED;
15239         int direct = 0;
15240         char *cl_number_or_name = NULL;
15241         char *str = NULL;
15242
15243         int idx = 0;
15244         if (argv_find(argv, argc, "ip", &idx)) {
15245                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
15246                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15247                 vty_out(vty, "'no bgp extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>'\n");
15248                 zlog_warn("Deprecated option: ‘no ip extcommunity-list <(1-99)|(100-500)|standard|expanded> <deny|permit> <LINE|AA:NN>' being used");
15249         }
15250
15251         idx = 0;
15252         argv_find(argv, argc, "permit", &idx);
15253         argv_find(argv, argc, "deny", &idx);
15254
15255         if (idx) {
15256                 direct = argv_find(argv, argc, "permit", &idx)
15257                                  ? COMMUNITY_PERMIT
15258                                  : COMMUNITY_DENY;
15259
15260                 idx = 0;
15261                 argv_find(argv, argc, "LINE", &idx);
15262                 str = argv_concat(argv, argc, idx);
15263         }
15264
15265         idx = 0;
15266         argv_find(argv, argc, "(100-500)", &idx);
15267         argv_find(argv, argc, "WORD", &idx);
15268         cl_number_or_name = argv[idx]->arg;
15269
15270         int ret = extcommunity_list_unset(bgp_clist, cl_number_or_name, str,
15271                                           direct, style);
15272
15273         XFREE(MTYPE_TMP, str);
15274
15275         if (ret < 0) {
15276                 community_list_perror(vty, ret);
15277                 return CMD_WARNING_CONFIG_FAILED;
15278         }
15279
15280         return CMD_SUCCESS;
15281 }
15282
15283 ALIAS (no_extcommunity_list_expanded_all,
15284        no_ip_extcommunity_list_expanded_all_cmd,
15285        "no ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
15286        NO_STR
15287        IP_STR
15288        EXTCOMMUNITY_LIST_STR
15289        "Extended Community list number (expanded)\n"
15290        "Specify expanded extcommunity-list\n"
15291        "Extended Community list name\n"
15292        "Specify community to reject\n"
15293        "Specify community to accept\n"
15294        "An ordered list as a regular-expression\n")
15295
15296 ALIAS(no_extcommunity_list_expanded_all,
15297       no_ip_extcommunity_list_expanded_all_list_cmd,
15298       "no ip extcommunity-list <(100-500)|expanded WORD>",
15299       NO_STR IP_STR EXTCOMMUNITY_LIST_STR
15300       "Extended Community list number (expanded)\n"
15301       "Specify expanded extcommunity-list\n"
15302       "Extended Community list name\n")
15303
15304 ALIAS(no_extcommunity_list_expanded_all,
15305       no_bgp_extcommunity_list_expanded_all_list_cmd,
15306       "no bgp extcommunity-list <(100-500)|expanded WORD>",
15307       NO_STR IP_STR EXTCOMMUNITY_LIST_STR
15308       "Extended Community list number (expanded)\n"
15309       "Specify expanded extcommunity-list\n"
15310       "Extended Community list name\n")
15311
15312 static void extcommunity_list_show(struct vty *vty, struct community_list *list)
15313 {
15314         struct community_entry *entry;
15315
15316         for (entry = list->head; entry; entry = entry->next) {
15317                 if (entry == list->head) {
15318                         if (all_digit(list->name))
15319                                 vty_out(vty, "Extended community %s list %s\n",
15320                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
15321                                                 ? "standard"
15322                                                 : "(expanded) access",
15323                                         list->name);
15324                         else
15325                                 vty_out(vty,
15326                                         "Named extended community %s list %s\n",
15327                                         entry->style == EXTCOMMUNITY_LIST_STANDARD
15328                                                 ? "standard"
15329                                                 : "expanded",
15330                                         list->name);
15331                 }
15332                 if (entry->any)
15333                         vty_out(vty, "    %s\n",
15334                                 community_direct_str(entry->direct));
15335                 else
15336                         vty_out(vty, "    %s %s\n",
15337                                 community_direct_str(entry->direct),
15338                                 community_list_config_str(entry));
15339         }
15340 }
15341
15342 DEFUN (show_extcommunity_list,
15343        show_bgp_extcommunity_list_cmd,
15344        "show bgp extcommunity-list",
15345        SHOW_STR
15346        BGP_STR
15347        "List extended-community list\n")
15348 {
15349         struct community_list *list;
15350         struct community_list_master *cm;
15351         int idx = 0;
15352
15353         if (argv_find(argv, argc, "ip", &idx)) {
15354                 vty_out(vty, "This config option is deprecated, and is scheduled for removal\n");
15355                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15356                 vty_out(vty, "'show bgp extcommunity-list <(1-500)|WORD>'\n");
15357                 zlog_warn("Deprecated option: 'ip show extcommunity-list <(1-500)|WORD>' being used");
15358         }
15359         cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
15360         if (!cm)
15361                 return CMD_SUCCESS;
15362
15363         for (list = cm->num.head; list; list = list->next)
15364                 extcommunity_list_show(vty, list);
15365
15366         for (list = cm->str.head; list; list = list->next)
15367                 extcommunity_list_show(vty, list);
15368
15369         return CMD_SUCCESS;
15370 }
15371
15372 ALIAS (show_extcommunity_list,
15373        show_ip_extcommunity_list_cmd,
15374        "show ip extcommunity-list",
15375        SHOW_STR
15376        IP_STR
15377        "List extended-community list\n")
15378
15379 DEFUN (show_extcommunity_list_arg,
15380        show_bgp_extcommunity_list_arg_cmd,
15381        "show bgp extcommunity-list <(1-500)|WORD>",
15382        SHOW_STR
15383        BGP_STR
15384        "List extended-community list\n"
15385        "Extcommunity-list number\n"
15386        "Extcommunity-list name\n")
15387 {
15388         int idx_comm_list = 3;
15389         struct community_list *list;
15390         int idx = 0;
15391
15392         if (argv_find(argv, argc, "ip", &idx)) {
15393                 vty_out(vty, "This config option is deprecated, and is scheduled for removal.\n");
15394                 vty_out(vty, "if you are using this please migrate to the below command.\n");
15395                 vty_out(vty, "'show bgp extcommunity-list <(1-500)|WORD>'\n");
15396                 zlog_warn("Deprecated option: 'ip show extcommunity-list <(1-500)|WORD>' being used");
15397         }
15398         list = community_list_lookup(bgp_clist, argv[idx_comm_list]->arg, 0,
15399                                      EXTCOMMUNITY_LIST_MASTER);
15400         if (!list) {
15401                 vty_out(vty, "%% Can't find extcommunity-list\n");
15402                 return CMD_WARNING;
15403         }
15404
15405         extcommunity_list_show(vty, list);
15406
15407         return CMD_SUCCESS;
15408 }
15409
15410 ALIAS (show_extcommunity_list_arg,
15411        show_ip_extcommunity_list_arg_cmd,
15412        "show ip extcommunity-list <(1-500)|WORD>",
15413        SHOW_STR
15414        IP_STR
15415        "List extended-community list\n"
15416        "Extcommunity-list number\n"
15417        "Extcommunity-list name\n")
15418
15419 /* Display community-list and extcommunity-list configuration.  */
15420 static int community_list_config_write(struct vty *vty)
15421 {
15422         struct community_list *list;
15423         struct community_entry *entry;
15424         struct community_list_master *cm;
15425         int write = 0;
15426
15427         /* Community-list.  */
15428         cm = community_list_master_lookup(bgp_clist, COMMUNITY_LIST_MASTER);
15429
15430         for (list = cm->num.head; list; list = list->next)
15431                 for (entry = list->head; entry; entry = entry->next) {
15432                         vty_out(vty, "bgp community-list %s %s %s\n", list->name,
15433                                 community_direct_str(entry->direct),
15434                                 community_list_config_str(entry));
15435                         write++;
15436                 }
15437         for (list = cm->str.head; list; list = list->next)
15438                 for (entry = list->head; entry; entry = entry->next) {
15439                         vty_out(vty, "bgp community-list %s %s %s %s\n",
15440                                 entry->style == COMMUNITY_LIST_STANDARD
15441                                         ? "standard"
15442                                         : "expanded",
15443                                 list->name, community_direct_str(entry->direct),
15444                                 community_list_config_str(entry));
15445                         write++;
15446                 }
15447
15448         /* Extcommunity-list.  */
15449         cm = community_list_master_lookup(bgp_clist, EXTCOMMUNITY_LIST_MASTER);
15450
15451         for (list = cm->num.head; list; list = list->next)
15452                 for (entry = list->head; entry; entry = entry->next) {
15453                         vty_out(vty, "bgp extcommunity-list %s %s %s\n",
15454                                 list->name, community_direct_str(entry->direct),
15455                                 community_list_config_str(entry));
15456                         write++;
15457                 }
15458         for (list = cm->str.head; list; list = list->next)
15459                 for (entry = list->head; entry; entry = entry->next) {
15460                         vty_out(vty, "bgp extcommunity-list %s %s %s %s\n",
15461                                 entry->style == EXTCOMMUNITY_LIST_STANDARD
15462                                         ? "standard"
15463                                         : "expanded",
15464                                 list->name, community_direct_str(entry->direct),
15465                                 community_list_config_str(entry));
15466                         write++;
15467                 }
15468
15469
15470         /* lcommunity-list.  */
15471         cm = community_list_master_lookup(bgp_clist,
15472                                           LARGE_COMMUNITY_LIST_MASTER);
15473
15474         for (list = cm->num.head; list; list = list->next)
15475                 for (entry = list->head; entry; entry = entry->next) {
15476                         vty_out(vty, "bgp large-community-list %s %s %s\n",
15477                                 list->name, community_direct_str(entry->direct),
15478                                 community_list_config_str(entry));
15479                         write++;
15480                 }
15481         for (list = cm->str.head; list; list = list->next)
15482                 for (entry = list->head; entry; entry = entry->next) {
15483                         vty_out(vty, "bgp large-community-list %s %s %s %s\n",
15484                                 entry->style == LARGE_COMMUNITY_LIST_STANDARD
15485                                         ? "standard"
15486                                         : "expanded",
15487                                 list->name, community_direct_str(entry->direct),
15488                                 community_list_config_str(entry));
15489                         write++;
15490                 }
15491
15492         return write;
15493 }
15494
15495 static struct cmd_node community_list_node = {
15496         COMMUNITY_LIST_NODE, "", 1 /* Export to vtysh.  */
15497 };
15498
15499 static void community_list_vty(void)
15500 {
15501         install_node(&community_list_node, community_list_config_write);
15502
15503         /* Community-list.  */
15504         install_element(CONFIG_NODE, &bgp_community_list_standard_cmd);
15505         install_element(CONFIG_NODE, &bgp_community_list_expanded_all_cmd);
15506         install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_cmd);
15507         install_element(CONFIG_NODE, &no_bgp_community_list_standard_all_list_cmd);
15508         install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_cmd);
15509         install_element(CONFIG_NODE, &no_bgp_community_list_expanded_all_list_cmd);
15510         install_element(VIEW_NODE, &show_bgp_community_list_cmd);
15511         install_element(VIEW_NODE, &show_bgp_community_list_arg_cmd);
15512         install_element(CONFIG_NODE, &ip_community_list_standard_cmd);
15513         install_element(CONFIG_NODE, &ip_community_list_expanded_all_cmd);
15514         install_element(CONFIG_NODE, &no_ip_community_list_standard_all_cmd);
15515         install_element(CONFIG_NODE, &no_ip_community_list_standard_all_list_cmd);
15516         install_element(CONFIG_NODE, &no_ip_community_list_expanded_all_cmd);
15517         install_element(CONFIG_NODE, &no_ip_community_list_expanded_all_list_cmd);
15518         install_element(VIEW_NODE, &show_ip_community_list_cmd);
15519         install_element(VIEW_NODE, &show_ip_community_list_arg_cmd);
15520
15521         /* Extcommunity-list.  */
15522         install_element(CONFIG_NODE, &bgp_extcommunity_list_standard_cmd);
15523         install_element(CONFIG_NODE, &bgp_extcommunity_list_name_expanded_cmd);
15524         install_element(CONFIG_NODE, &no_bgp_extcommunity_list_standard_all_cmd);
15525         install_element(CONFIG_NODE,
15526                         &no_bgp_extcommunity_list_standard_all_list_cmd);
15527         install_element(CONFIG_NODE, &no_bgp_extcommunity_list_expanded_all_cmd);
15528         install_element(CONFIG_NODE,
15529                         &no_bgp_extcommunity_list_expanded_all_list_cmd);
15530         install_element(VIEW_NODE, &show_bgp_extcommunity_list_cmd);
15531         install_element(VIEW_NODE, &show_bgp_extcommunity_list_arg_cmd);
15532         install_element(CONFIG_NODE, &ip_extcommunity_list_standard_cmd);
15533         install_element(CONFIG_NODE, &ip_extcommunity_list_name_expanded_cmd);
15534         install_element(CONFIG_NODE, &no_ip_extcommunity_list_standard_all_cmd);
15535         install_element(CONFIG_NODE, &no_ip_extcommunity_list_standard_all_list_cmd);
15536         install_element(CONFIG_NODE, &no_ip_extcommunity_list_expanded_all_cmd);
15537         install_element(CONFIG_NODE, &no_ip_extcommunity_list_expanded_all_list_cmd);
15538         install_element(VIEW_NODE, &show_ip_extcommunity_list_cmd);
15539         install_element(VIEW_NODE, &show_ip_extcommunity_list_arg_cmd);
15540
15541         /* Large Community List */
15542         install_element(CONFIG_NODE, &bgp_lcommunity_list_standard_cmd);
15543         install_element(CONFIG_NODE, &bgp_lcommunity_list_standard1_cmd);
15544         install_element(CONFIG_NODE, &bgp_lcommunity_list_expanded_cmd);
15545         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard_cmd);
15546         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_standard1_cmd);
15547         install_element(CONFIG_NODE, &bgp_lcommunity_list_name_expanded_cmd);
15548         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_all_cmd);
15549         install_element(CONFIG_NODE,
15550                         &no_bgp_lcommunity_list_name_expanded_all_cmd);
15551         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_standard_cmd);
15552         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_expanded_cmd);
15553         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_standard_cmd);
15554         install_element(CONFIG_NODE, &no_bgp_lcommunity_list_name_expanded_cmd);
15555         install_element(VIEW_NODE, &show_bgp_lcommunity_list_cmd);
15556         install_element(VIEW_NODE, &show_bgp_lcommunity_list_arg_cmd);
15557         install_element(CONFIG_NODE, &ip_lcommunity_list_standard_cmd);
15558         install_element(CONFIG_NODE, &ip_lcommunity_list_standard1_cmd);
15559         install_element(CONFIG_NODE, &ip_lcommunity_list_expanded_cmd);
15560         install_element(CONFIG_NODE, &ip_lcommunity_list_name_standard_cmd);
15561         install_element(CONFIG_NODE, &ip_lcommunity_list_name_standard1_cmd);
15562         install_element(CONFIG_NODE, &ip_lcommunity_list_name_expanded_cmd);
15563         install_element(CONFIG_NODE, &no_ip_lcommunity_list_standard_all_cmd);
15564         install_element(CONFIG_NODE,
15565                         &no_ip_lcommunity_list_name_expanded_all_cmd);
15566         install_element(CONFIG_NODE, &no_ip_lcommunity_list_standard_cmd);
15567         install_element(CONFIG_NODE, &no_ip_lcommunity_list_expanded_cmd);
15568         install_element(CONFIG_NODE, &no_ip_lcommunity_list_name_standard_cmd);
15569         install_element(CONFIG_NODE, &no_ip_lcommunity_list_name_expanded_cmd);
15570         install_element(VIEW_NODE, &show_ip_lcommunity_list_cmd);
15571         install_element(VIEW_NODE, &show_ip_lcommunity_list_arg_cmd);
15572 }