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
  17 along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #include <zebra.h>
  22
  23 #include "command.h"
  24 #include "lib/json.h"
  25 #include "prefix.h"
  26 #include "plist.h"
  27 #include "buffer.h"
  28 #include "linklist.h"
  29 #include "stream.h"
  30 #include "thread.h"
  31 #include "log.h"
  32 #include "memory.h"
  33 #include "memory_vty.h"
  34 #include "hash.h"
  35 #include "queue.h"
  36 #include "filter.h"
  37
  38 #include "bgpd/bgpd.h"
  39 #include "bgpd/bgp_advertise.h"
  40 #include "bgpd/bgp_attr.h"
  41 #include "bgpd/bgp_aspath.h"
  42 #include "bgpd/bgp_community.h"
  43 #include "bgpd/bgp_ecommunity.h"
  44 #include "bgpd/bgp_lcommunity.h"
  45 #include "bgpd/bgp_damp.h"
  46 #include "bgpd/bgp_debug.h"
  47 #include "bgpd/bgp_fsm.h"
  48 #include "bgpd/bgp_nexthop.h"
  49 #include "bgpd/bgp_open.h"
  50 #include "bgpd/bgp_regex.h"
  51 #include "bgpd/bgp_route.h"
  52 #include "bgpd/bgp_mplsvpn.h"
  53 #include "bgpd/bgp_zebra.h"
  54 #include "bgpd/bgp_table.h"
  55 #include "bgpd/bgp_vty.h"
  56 #include "bgpd/bgp_mpath.h"
  57 #include "bgpd/bgp_packet.h"
  58 #include "bgpd/bgp_updgrp.h"
  59 #include "bgpd/bgp_bfd.h"
  60
  61 static struct peer_group *
  62 listen_range_exists (struct bgp *bgp, struct prefix *range, int exact);
  63
  64 /* Utility function to get address family from current node.  */
  65 afi_t
  66 bgp_node_afi (struct vty *vty)
  67 {
  68   afi_t afi;
  69   switch (vty->node)
  70     {
  71     case BGP_IPV6_NODE:
  72     case BGP_IPV6M_NODE:
  73     case BGP_VPNV6_NODE:
  74     case BGP_ENCAPV6_NODE:
  75       afi = AFI_IP6;
  76       break;
  77     case BGP_EVPN_NODE:
  78       afi = AFI_L2VPN;
  79       break;
  80     default:
  81       afi = AFI_IP;
  82       break;
  83     }
  84   return afi;
  85 }
  86
  87 /* Utility function to get subsequent address family from current
  88    node.  */
  89 safi_t
  90 bgp_node_safi (struct vty *vty)
  91 {
  92   safi_t safi;
  93   switch (vty->node)
  94     {
  95     case BGP_ENCAP_NODE:
  96     case BGP_ENCAPV6_NODE:
  97       safi = SAFI_ENCAP;
  98       break;
  99     case BGP_VPNV4_NODE:
 100     case BGP_VPNV6_NODE:
 101       safi = SAFI_MPLS_VPN;
 102       break;
 103     case BGP_IPV4M_NODE:
 104     case BGP_IPV6M_NODE:
 105       safi = SAFI_MULTICAST;
 106       break;
 107     case BGP_EVPN_NODE:
 108       safi = SAFI_EVPN;
 109       break;
 110     default:
 111       safi = SAFI_UNICAST;
 112       break;
 113   }
 114   return safi;
 115 }
 116
 117 /* supports <ipv4|ipv6> */
 118 afi_t
 119 bgp_vty_afi_from_arg(const char *afi_str)
 120 {
 121   afi_t afi = AFI_MAX;       /* unknown */
 122   if (!strcmp(afi_str, "ipv4")) {
 123     afi = AFI_IP;
 124     }
 125   else if (!strcmp(afi_str, "ipv6")) {
 126     afi = AFI_IP6;
 127   }
 128   else if (!strcmp(afi_str, "l2vpn")) {
 129     afi = AFI_L2VPN;
 130   }
 131   return afi;
 132 }
 133
 134 int
 135 bgp_parse_afi(const char *str, afi_t *afi)
 136 {
 137   *afi = bgp_vty_afi_from_arg(str);
 138   if (*afi != AFI_MAX)
 139     return 0;
 140   else
 141     return -1;
 142 }
 143
 144 int
 145 argv_find_and_parse_afi(struct cmd_token **argv, int argc, int *index, afi_t *afi)
 146 {
 147   int ret = 0;
 148   if (argv_find (argv, argc, "ipv4", index))
 149     {
 150       ret = 1;
 151       if (afi)
 152         *afi = AFI_IP;
 153     }
 154   else if (argv_find (argv, argc, "ipv6", index))
 155     {
 156       ret = 1;
 157       if (afi)
 158         *afi = AFI_IP6;
 159     }
 160   return ret;
 161 }
 162
 163 /* supports <unicast|multicast|vpn|encap> */
 164 safi_t
 165 bgp_vty_safi_from_arg(const char *safi_str)
 166 {
 167   safi_t safi = SAFI_MAX;       /* unknown */
 168   if (strncmp (safi_str, "m", 1) == 0)
 169     safi = SAFI_MULTICAST;
 170   else if (strncmp (safi_str, "u", 1) == 0)
 171     safi = SAFI_UNICAST;
 172   else if (strncmp (safi_str, "e", 1) == 0)
 173     safi = SAFI_ENCAP;
 174   else if (strncmp (safi_str, "v", 1) == 0)
 175     safi = SAFI_MPLS_VPN;
 176   return safi;
 177 }
 178
 179 int
 180 argv_find_and_parse_safi (struct cmd_token **argv, int argc, int *index, safi_t *safi)
 181 {
 182   int ret = 0;
 183   if (argv_find (argv, argc, "unicast", index))
 184     {
 185       ret = 1;
 186       if (safi)
 187         *safi = SAFI_UNICAST;
 188     }
 189   else if (argv_find (argv, argc, "multicast", index))
 190     {
 191       ret = 1;
 192       if (safi)
 193         *safi = SAFI_MULTICAST;
 194     }
 195   else if (argv_find (argv, argc, "vpn", index))
 196     {
 197       ret = 1;
 198       if (safi)
 199         *safi = SAFI_MPLS_VPN;
 200     }
 201   else if (argv_find (argv, argc, "encap", index))
 202     {
 203       ret = 1;
 204       if (safi)
 205         *safi = SAFI_ENCAP;
 206     }
 207   else if (argv_find (argv, argc, "evpn", index))
 208     {
 209       ret = 1;
 210       if (safi)
 211         *safi = SAFI_EVPN;
 212     }
 213   return ret;
 214 }
 215
 216 /*
 217  * bgp_vty_find_and_parse_afi_safi_bgp
 218  *
 219  * For a given 'show ...' command, correctly parse the afi/safi/bgp out from it
 220  * This function *assumes* that the calling function pre-sets the afi/safi/bgp
 221  * to appropriate values for the calling function.  This is to allow the
 222  * calling function to make decisions appropriate for the show command
 223  * that is being parsed.
 224  *
 225  * The show commands are generally of the form:
 226  * "show [ip] bgp [<view|vrf> WORD] [<ipv4|ipv6> [<unicast|multicast|vpn|encap>]] ..."
 227  *
 228  * Since we use argv_find if the show command in particular doesn't have:
 229  * [ip]
 230  * [<view|vrf> WORD]
 231  * [<ipv4|ipv6> [<unicast|multicast|vpn|encap>]]
 232  * The command parsing should still be ok.
 233  *
 234  * vty  -> The vty for the command so we can output some useful data in
 235  *         the event of a parse error in the vrf.
 236  * argv -> The command tokens
 237  * argc -> How many command tokens we have
 238  * idx  -> The current place in the command, generally should be 0 for this function
 239  * afi  -> The parsed afi if it was included in the show command, returned here
 240  * safi -> The parsed safi if it was included in the show command, returned here
 241  * bgp  -> Pointer to the bgp data structure we need to fill in.
 242  *
 243  * The function returns the correct location in the parse tree for the
 244  * last token found.
 245  *
 246  * Returns 0 for failure to parse correctly, else the idx position of where
 247  * it found the last token.
 248  */
 249 int
 250 bgp_vty_find_and_parse_afi_safi_bgp (struct vty *vty, struct cmd_token **argv, int argc, int *idx,
 251                                      afi_t *afi, safi_t *safi, struct bgp **bgp)
 252 {
 253   char *vrf_name = NULL;
 254
 255   assert (afi);
 256   assert (safi);
 257   assert (bgp);
 258
 259   if (argv_find (argv, argc, "ip", idx))
 260       *afi = AFI_IP;
 261
 262   if (argv_find (argv, argc, "view", idx) || argv_find (argv, argc, "vrf", idx))
 263     {
 264       vrf_name = argv[*idx + 1]->arg;
 265       *idx += 2;
 266
 267       if (strmatch (vrf_name, "all"))
 268         *bgp = NULL;
 269       else
 270         {
 271           *bgp = bgp_lookup_by_name (vrf_name);
 272           if (!*bgp)
 273             {
 274               vty_out (vty, "View/Vrf specified is unknown: %s%s", vrf_name, VTY_NEWLINE);
 275               *idx = 0;
 276               return 0;
 277             }
 278         }
 279     }
 280   else
 281     {
 282       *bgp = bgp_get_default ();
 283       if (!*bgp)
 284         {
 285           vty_out (vty, "Unable to find default BGP instance%s", VTY_NEWLINE);
 286           *idx = 0;
 287           return 0;
 288         }
 289     }
 290
 291   if (argv_find_and_parse_afi (argv, argc, idx, afi))
 292     argv_find_and_parse_safi (argv, argc, idx, safi);
 293
 294   *idx += 1;
 295   return *idx;
 296 }
 297
 298 static int
 299 peer_address_self_check (struct bgp *bgp, union sockunion *su)
 300 {
 301   struct interface *ifp = NULL;
 302
 303   if (su->sa.sa_family == AF_INET)
 304     ifp = if_lookup_by_ipv4_exact (&su->sin.sin_addr, bgp->vrf_id);
 305   else if (su->sa.sa_family == AF_INET6)
 306     ifp = if_lookup_by_ipv6_exact (&su->sin6.sin6_addr,
 307                                    su->sin6.sin6_scope_id, bgp->vrf_id);
 308
 309   if (ifp)
 310     return 1;
 311
 312   return 0;
 313 }
 314
 315 /* Utility function for looking up peer from VTY.  */
 316 /* This is used only for configuration, so disallow if attempted on
 317  * a dynamic neighbor.
 318  */
 319 static struct peer *
 320 peer_lookup_vty (struct vty *vty, const char *ip_str)
 321 {
 322   struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 323   int ret;
 324   union sockunion su;
 325   struct peer *peer;
 326
 327   if (!bgp) {
 328       return NULL;
 329   }
 330
 331   ret = str2sockunion (ip_str, &su);
 332   if (ret < 0)
 333     {
 334       peer = peer_lookup_by_conf_if (bgp, ip_str);
 335       if (!peer)
 336         {
 337           if ((peer = peer_lookup_by_hostname(bgp, ip_str)) == NULL)
 338             {
 339               vty_out (vty, "%% Malformed address or name: %s%s", ip_str, VTY_NEWLINE);
 340               return NULL;
 341             }
 342         }
 343     }
 344   else
 345     {
 346       peer = peer_lookup (bgp, &su);
 347       if (! peer)
 348         {
 349           vty_out (vty, "%% Specify remote-as or peer-group commands first%s",
 350                    VTY_NEWLINE);
 351           return NULL;
 352         }
 353       if (peer_dynamic_neighbor (peer))
 354         {
 355           vty_out (vty, "%% Operation not allowed on a dynamic neighbor%s",
 356                    VTY_NEWLINE);
 357           return NULL;
 358         }
 359
 360     }
 361   return peer;
 362 }
 363
 364 /* Utility function for looking up peer or peer group.  */
 365 /* This is used only for configuration, so disallow if attempted on
 366  * a dynamic neighbor.
 367  */
 368 struct peer *
 369 peer_and_group_lookup_vty (struct vty *vty, const char *peer_str)
 370 {
 371   struct bgp *bgp = VTY_GET_CONTEXT(bgp);
 372   int ret;
 373   union sockunion su;
 374   struct peer *peer = NULL;
 375   struct peer_group *group = NULL;
 376
 377   if (!bgp) {
 378       return NULL;
 379   }
 380
 381   ret = str2sockunion (peer_str, &su);
 382   if (ret == 0)
 383     {
 384       /* IP address, locate peer. */
 385       peer = peer_lookup (bgp, &su);
 386     }
 387   else
 388     {
 389       /* Not IP, could match either peer configured on interface or a group. */
 390       peer = peer_lookup_by_conf_if (bgp, peer_str);
 391       if (!peer)
 392         group = peer_group_lookup (bgp, peer_str);
 393     }
 394
 395   if (peer)
 396     {
 397       if (peer_dynamic_neighbor (peer))
 398         {
 399           vty_out (vty, "%% Operation not allowed on a dynamic neighbor%s",
 400                    VTY_NEWLINE);
 401           return NULL;
 402         }
 403
 404       return peer;
 405     }
 406
 407   if (group)
 408     return group->conf;
 409
 410   vty_out (vty, "%% Specify remote-as or peer-group commands first%s",
 411            VTY_NEWLINE);
 412
 413   return NULL;
 414 }
 415
 416 int
 417 bgp_vty_return (struct vty *vty, int ret)
 418 {
 419   const char *str = NULL;
 420
 421   switch (ret)
 422     {
 423     case BGP_ERR_INVALID_VALUE:
 424       str = "Invalid value";
 425       break;
 426     case BGP_ERR_INVALID_FLAG:
 427       str = "Invalid flag";
 428       break;
 429     case BGP_ERR_PEER_GROUP_SHUTDOWN:
 430       str = "Peer-group has been shutdown. Activate the peer-group first";
 431       break;
 432     case BGP_ERR_PEER_FLAG_CONFLICT:
 433       str = "Can't set override-capability and strict-capability-match at the same time";
 434       break;
 435     case BGP_ERR_PEER_GROUP_NO_REMOTE_AS:
 436       str = "Specify remote-as or peer-group remote AS first";
 437       break;
 438     case BGP_ERR_PEER_GROUP_CANT_CHANGE:
 439       str = "Cannot change the peer-group. Deconfigure first";
 440       break;
 441     case BGP_ERR_PEER_GROUP_MISMATCH:
 442       str = "Peer is not a member of this peer-group";
 443       break;
 444     case BGP_ERR_PEER_FILTER_CONFLICT:
 445       str = "Prefix/distribute list can not co-exist";
 446       break;
 447     case BGP_ERR_NOT_INTERNAL_PEER:
 448       str = "Invalid command. Not an internal neighbor";
 449       break;
 450     case BGP_ERR_REMOVE_PRIVATE_AS:
 451       str = "remove-private-AS cannot be configured for IBGP peers";
 452       break;
 453     case BGP_ERR_LOCAL_AS_ALLOWED_ONLY_FOR_EBGP:
 454       str = "Local-AS allowed only for EBGP peers";
 455       break;
 456     case BGP_ERR_CANNOT_HAVE_LOCAL_AS_SAME_AS:
 457       str = "Cannot have local-as same as BGP AS number";
 458       break;
 459     case BGP_ERR_TCPSIG_FAILED:
 460       str = "Error while applying TCP-Sig to session(s)";
 461       break;
 462     case BGP_ERR_NO_EBGP_MULTIHOP_WITH_TTLHACK:
 463       str = "ebgp-multihop and ttl-security cannot be configured together";
 464       break;
 465     case BGP_ERR_NO_IBGP_WITH_TTLHACK:
 466       str = "ttl-security only allowed for EBGP peers";
 467       break;
 468     case BGP_ERR_AS_OVERRIDE:
 469       str = "as-override cannot be configured for IBGP peers";
 470       break;
 471     case BGP_ERR_INVALID_DYNAMIC_NEIGHBORS_LIMIT:
 472       str = "Invalid limit for number of dynamic neighbors";
 473       break;
 474     case BGP_ERR_DYNAMIC_NEIGHBORS_RANGE_EXISTS:
 475       str = "Dynamic neighbor listen range already exists";
 476       break;
 477     case BGP_ERR_INVALID_FOR_DYNAMIC_PEER:
 478       str = "Operation not allowed on a dynamic neighbor";
 479       break;
 480     case BGP_ERR_INVALID_FOR_DIRECT_PEER:
 481       str = "Operation not allowed on a directly connected neighbor";
 482       break;
 483     }
 484   if (str)
 485     {
 486       vty_out (vty, "%% %s%s", str, VTY_NEWLINE);
 487       return CMD_WARNING;
 488     }
 489   return CMD_SUCCESS;
 490 }
 491
 492 /* BGP clear sort. */
 493 enum clear_sort
 494 {
 495   clear_all,
 496   clear_peer,
 497   clear_group,
 498   clear_external,
 499   clear_as
 500 };
 501
 502 static void
 503 bgp_clear_vty_error (struct vty *vty, struct peer *peer, afi_t afi,
 504                      safi_t safi, int error)
 505 {
 506   switch (error)
 507     {
 508     case BGP_ERR_AF_UNCONFIGURED:
 509       vty_out (vty,
 510                "%%BGP: Enable %s address family for the neighbor %s%s",
 511                afi_safi_print(afi, safi), peer->host, VTY_NEWLINE);
 512       break;
 513     case BGP_ERR_SOFT_RECONFIG_UNCONFIGURED:
 514       vty_out (vty, "%%BGP: Inbound soft reconfig for %s not possible as it%s      has neither refresh capability, nor inbound soft reconfig%s", peer->host, VTY_NEWLINE, VTY_NEWLINE);
 515       break;
 516     default:
 517       break;
 518     }
 519 }
 520
 521 /* `clear ip bgp' functions. */
 522 static int
 523 bgp_clear (struct vty *vty, struct bgp *bgp,  afi_t afi, safi_t safi,
 524            enum clear_sort sort,enum bgp_clear_type stype, const char *arg)
 525 {
 526   int ret;
 527   struct peer *peer;
 528   struct listnode *node, *nnode;
 529
 530   /* Clear all neighbors. */
 531   /*
 532    * Pass along pointer to next node to peer_clear() when walking all nodes
 533    * on the BGP instance as that may get freed if it is a doppelganger
 534    */
 535   if (sort == clear_all)
 536     {
 537       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
 538         {
 539           if (stype == BGP_CLEAR_SOFT_NONE)
 540             ret = peer_clear (peer, &nnode);
 541           else if (peer->afc[afi][safi])
 542             ret = peer_clear_soft (peer, afi, safi, stype);
 543           else
 544             ret = 0;
 545
 546           if (ret < 0)
 547             bgp_clear_vty_error (vty, peer, afi, safi, ret);
 548         }
 549
 550       /* This is to apply read-only mode on this clear. */
 551       if (stype == BGP_CLEAR_SOFT_NONE)
 552         bgp->update_delay_over = 0;
 553
 554       return CMD_SUCCESS;
 555     }
 556
 557   /* Clear specified neighbors. */
 558   if (sort == clear_peer)
 559     {
 560       union sockunion su;
 561       int ret;
 562
 563       /* Make sockunion for lookup. */
 564       ret = str2sockunion (arg, &su);
 565       if (ret < 0)
 566         {
 567           peer = peer_lookup_by_conf_if (bgp, arg);
 568           if (!peer)
 569             {
 570               peer = peer_lookup_by_hostname(bgp, arg);
 571               if (!peer)
 572                 {
 573                   vty_out (vty, "Malformed address or name: %s%s", arg, VTY_NEWLINE);
 574                   return CMD_WARNING;
 575                 }
 576             }
 577         }
 578       else
 579         {
 580           peer = peer_lookup (bgp, &su);
 581           if (! peer)
 582             {
 583               vty_out (vty, "%%BGP: Unknown neighbor - \"%s\"%s", arg, VTY_NEWLINE);
 584               return CMD_WARNING;
 585             }
 586         }
 587
 588       if (stype == BGP_CLEAR_SOFT_NONE)
 589         ret = peer_clear (peer, NULL);
 590       else
 591         ret = peer_clear_soft (peer, afi, safi, stype);
 592
 593       if (ret < 0)
 594         bgp_clear_vty_error (vty, peer, afi, safi, ret);
 595
 596       return CMD_SUCCESS;
 597     }
 598
 599   /* Clear all peer-group members. */
 600   if (sort == clear_group)
 601     {
 602       struct peer_group *group;
 603
 604       group = peer_group_lookup (bgp, arg);
 605       if (! group)
 606         {
 607           vty_out (vty, "%%BGP: No such peer-group %s%s", arg, VTY_NEWLINE);
 608           return CMD_WARNING;
 609         }
 610
 611       for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
 612         {
 613           if (stype == BGP_CLEAR_SOFT_NONE)
 614             {
 615               peer_clear (peer, NULL);
 616               continue;
 617             }
 618
 619           if (! peer->afc[afi][safi])
 620             continue;
 621
 622           ret = peer_clear_soft (peer, afi, safi, stype);
 623
 624           if (ret < 0)
 625             bgp_clear_vty_error (vty, peer, afi, safi, ret);
 626         }
 627       return CMD_SUCCESS;
 628     }
 629
 630   if (sort == clear_external)
 631     {
 632       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
 633         {
 634           if (peer->sort == BGP_PEER_IBGP)
 635             continue;
 636
 637           if (stype == BGP_CLEAR_SOFT_NONE)
 638             ret = peer_clear (peer, &nnode);
 639           else
 640             ret = peer_clear_soft (peer, afi, safi, stype);
 641
 642           if (ret < 0)
 643             bgp_clear_vty_error (vty, peer, afi, safi, ret);
 644         }
 645       return CMD_SUCCESS;
 646     }
 647
 648   if (sort == clear_as)
 649     {
 650       as_t as;
 651       int find = 0;
 652
 653       VTY_GET_INTEGER_RANGE ("AS", as, arg, 1, BGP_AS4_MAX);
 654
 655       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
 656         {
 657           if (peer->as != as)
 658             continue;
 659
 660           find = 1;
 661           if (stype == BGP_CLEAR_SOFT_NONE)
 662             ret = peer_clear (peer, &nnode);
 663           else
 664             ret = peer_clear_soft (peer, afi, safi, stype);
 665
 666           if (ret < 0)
 667             bgp_clear_vty_error (vty, peer, afi, safi, ret);
 668         }
 669       if (! find)
 670         vty_out (vty, "%%BGP: No peer is configured with AS %s%s", arg,
 671                  VTY_NEWLINE);
 672       return CMD_SUCCESS;
 673     }
 674
 675   return CMD_SUCCESS;
 676 }
 677
 678 static int
 679 bgp_clear_vty (struct vty *vty, const char *name, afi_t afi, safi_t safi,
 680                enum clear_sort sort, enum bgp_clear_type stype,
 681                const char *arg)
 682 {
 683   struct bgp *bgp;
 684
 685   /* BGP structure lookup. */
 686   if (name)
 687     {
 688       bgp = bgp_lookup_by_name (name);
 689       if (bgp == NULL)
 690         {
 691           vty_out (vty, "Can't find BGP instance %s%s", name, VTY_NEWLINE);
 692           return CMD_WARNING;
 693         }
 694     }
 695   else
 696     {
 697       bgp = bgp_get_default ();
 698       if (bgp == NULL)
 699         {
 700           vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE);
 701           return CMD_WARNING;
 702         }
 703     }
 704
 705   return bgp_clear (vty, bgp, afi, safi, sort, stype, arg);
 706 }
 707
 708 /* clear soft inbound */
 709 static void
 710 bgp_clear_star_soft_in (struct vty *vty, const char *name)
 711 {
 712   bgp_clear_vty (vty, name, AFI_IP, SAFI_UNICAST, clear_all,
 713                  BGP_CLEAR_SOFT_IN, NULL);
 714   bgp_clear_vty (vty, name, AFI_IP6, SAFI_UNICAST, clear_all,
 715                  BGP_CLEAR_SOFT_IN, NULL);
 716 }
 717
 718 /* clear soft outbound */
 719 static void
 720 bgp_clear_star_soft_out (struct vty *vty, const char *name)
 721 {
 722   bgp_clear_vty (vty, name, AFI_IP, SAFI_UNICAST, clear_all,
 723                  BGP_CLEAR_SOFT_OUT, NULL);
 724   bgp_clear_vty (vty, name, AFI_IP6, SAFI_UNICAST, clear_all,
 725                  BGP_CLEAR_SOFT_OUT, NULL);
 726 }
 727
 728
 729 /* BGP global configuration.  */
 730
 731 DEFUN (bgp_multiple_instance_func,
 732        bgp_multiple_instance_cmd,
 733        "bgp multiple-instance",
 734        BGP_STR
 735        "Enable bgp multiple instance\n")
 736 {
 737   bgp_option_set (BGP_OPT_MULTIPLE_INSTANCE);
 738   return CMD_SUCCESS;
 739 }
 740
 741 DEFUN (no_bgp_multiple_instance,
 742        no_bgp_multiple_instance_cmd,
 743        "no bgp multiple-instance",
 744        NO_STR
 745        BGP_STR
 746        "BGP multiple instance\n")
 747 {
 748   int ret;
 749
 750   ret = bgp_option_unset (BGP_OPT_MULTIPLE_INSTANCE);
 751   if (ret < 0)
 752     {
 753       vty_out (vty, "%% There are more than two BGP instances%s", VTY_NEWLINE);
 754       return CMD_WARNING;
 755     }
 756   return CMD_SUCCESS;
 757 }
 758
 759 DEFUN (bgp_config_type,
 760        bgp_config_type_cmd,
 761        "bgp config-type <cisco|zebra>",
 762        BGP_STR
 763        "Configuration type\n"
 764        "cisco\n"
 765        "zebra\n")
 766 {
 767   int idx_vendor = 2;
 768   if (strncmp (argv[idx_vendor]->arg, "c", 1) == 0)
 769     bgp_option_set (BGP_OPT_CONFIG_CISCO);
 770   else
 771     bgp_option_unset (BGP_OPT_CONFIG_CISCO);
 772
 773   return CMD_SUCCESS;
 774 }
 775
 776 DEFUN (no_bgp_config_type,
 777        no_bgp_config_type_cmd,
 778        "no bgp config-type [<cisco|zebra>]",
 779        NO_STR
 780        BGP_STR
 781        "Display configuration type\n"
 782        "cisco\n"
 783        "zebra\n")
 784 {
 785   bgp_option_unset (BGP_OPT_CONFIG_CISCO);
 786   return CMD_SUCCESS;
 787 }
 788
 789
 790 DEFUN (no_synchronization,
 791        no_synchronization_cmd,
 792        "no synchronization",
 793        NO_STR
 794        "Perform IGP synchronization\n")
 795 {
 796   return CMD_SUCCESS;
 797 }
 798
 799 DEFUN (no_auto_summary,
 800        no_auto_summary_cmd,
 801        "no auto-summary",
 802        NO_STR
 803        "Enable automatic network number summarization\n")
 804 {
 805   return CMD_SUCCESS;
 806 }
 807
 808 /* "router bgp" commands. */
 809 DEFUN_NOSH (router_bgp,
 810        router_bgp_cmd,
 811        "router bgp [(1-4294967295) [<view|vrf> WORD]]",
 812        ROUTER_STR
 813        BGP_STR
 814        AS_STR
 815        BGP_INSTANCE_HELP_STR)
 816 {
 817   int idx_asn = 2;
 818   int idx_view_vrf = 3;
 819   int idx_vrf = 4;
 820   int ret;
 821   as_t as;
 822   struct bgp *bgp;
 823   const char *name = NULL;
 824   enum bgp_instance_type inst_type;
 825
 826   // "router bgp" without an ASN
 827   if (argc == 2)
 828     {
 829       //Pending: Make VRF option available for ASN less config
 830       bgp = bgp_get_default();
 831
 832       if (bgp == NULL)
 833         {
 834           vty_out (vty, "%% No BGP process is configured%s", VTY_NEWLINE);
 835           return CMD_WARNING;
 836         }
 837
 838       if (listcount(bm->bgp) > 1)
 839         {
 840           vty_out (vty, "%% Multiple BGP processes are configured%s", VTY_NEWLINE);
 841           return CMD_WARNING;
 842         }
 843     }
 844
 845   // "router bgp X"
 846   else
 847     {
 848       VTY_GET_INTEGER_RANGE ("AS", as, argv[idx_asn]->arg, 1, BGP_AS4_MAX);
 849
 850       inst_type = BGP_INSTANCE_TYPE_DEFAULT;
 851       if (argc > 3)
 852         {
 853           name = argv[idx_vrf]->arg;
 854
 855           if (!strcmp(argv[idx_view_vrf]->text, "vrf"))
 856             inst_type = BGP_INSTANCE_TYPE_VRF;
 857           else if (!strcmp(argv[idx_view_vrf]->text, "view"))
 858             inst_type = BGP_INSTANCE_TYPE_VIEW;
 859         }
 860
 861       ret = bgp_get (&bgp, &as, name, inst_type);
 862       switch (ret)
 863         {
 864         case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET:
 865           vty_out (vty, "Please specify 'bgp multiple-instance' first%s",
 866                    VTY_NEWLINE);
 867           return CMD_WARNING;
 868         case BGP_ERR_AS_MISMATCH:
 869           vty_out (vty, "BGP is already running; AS is %u%s", as, VTY_NEWLINE);
 870           return CMD_WARNING;
 871         case BGP_ERR_INSTANCE_MISMATCH:
 872           vty_out (vty, "BGP instance name and AS number mismatch%s", VTY_NEWLINE);
 873           vty_out (vty, "BGP instance is already running; AS is %u%s",
 874                    as, VTY_NEWLINE);
 875           return CMD_WARNING;
 876         }
 877
 878       /* Pending: handle when user tries to change a view to vrf n vv. */
 879     }
 880
 881   VTY_PUSH_CONTEXT(BGP_NODE, bgp);
 882
 883   return CMD_SUCCESS;
 884 }
 885
 886 /* "no router bgp" commands. */
 887 DEFUN (no_router_bgp,
 888        no_router_bgp_cmd,
 889        "no router bgp [(1-4294967295) [<view|vrf> WORD]]",
 890        NO_STR
 891        ROUTER_STR
 892        BGP_STR
 893        AS_STR
 894        BGP_INSTANCE_HELP_STR)
 895 {
 896   int idx_asn = 3;
 897   int idx_vrf = 5;
 898   as_t as;
 899   struct bgp *bgp;
 900   const char *name = NULL;
 901
 902   // "no router bgp" without an ASN
 903   if (argc == 3)
 904     {
 905       //Pending: Make VRF option available for ASN less config
 906       bgp = bgp_get_default();
 907
 908       if (bgp == NULL)
 909         {
 910           vty_out (vty, "%% No BGP process is configured%s", VTY_NEWLINE);
 911           return CMD_WARNING;
 912         }
 913
 914       if (listcount(bm->bgp) > 1)
 915         {
 916           vty_out (vty, "%% Multiple BGP processes are configured%s", VTY_NEWLINE);
 917           return CMD_WARNING;
 918         }
 919     }
 920   else
 921     {
 922       VTY_GET_INTEGER_RANGE ("AS", as, argv[idx_asn]->arg, 1, BGP_AS4_MAX);
 923
 924       if (argc > 4)
 925         name = argv[idx_vrf]->arg;
 926
 927       /* Lookup bgp structure. */
 928       bgp = bgp_lookup (as, name);
 929       if (! bgp)
 930         {
 931           vty_out (vty, "%% Can't find BGP instance%s", VTY_NEWLINE);
 932           return CMD_WARNING;
 933         }
 934     }
 935
 936   bgp_delete (bgp);
 937
 938   return CMD_SUCCESS;
 939 }
 940
 941
 942
 943 /* BGP router-id.  */
 944
 945 DEFUN (bgp_router_id,
 946        bgp_router_id_cmd,
 947        "bgp router-id A.B.C.D",
 948        BGP_STR
 949        "Override configured router identifier\n"
 950        "Manually configured router identifier\n")
 951 {
 952   VTY_DECLVAR_CONTEXT(bgp, bgp);
 953   int idx_ipv4 = 2;
 954   int ret;
 955   struct in_addr id;
 956
 957   ret = inet_aton (argv[idx_ipv4]->arg, &id);
 958   if (! ret)
 959     {
 960       vty_out (vty, "%% Malformed bgp router identifier%s", VTY_NEWLINE);
 961       return CMD_WARNING;
 962     }
 963
 964   bgp_router_id_static_set (bgp, id);
 965
 966   return CMD_SUCCESS;
 967 }
 968
 969 DEFUN (no_bgp_router_id,
 970        no_bgp_router_id_cmd,
 971        "no bgp router-id [A.B.C.D]",
 972        NO_STR
 973        BGP_STR
 974        "Override configured router identifier\n"
 975        "Manually configured router identifier\n")
 976 {
 977   VTY_DECLVAR_CONTEXT(bgp, bgp);
 978   int idx_router_id = 3;
 979   int ret;
 980   struct in_addr id;
 981
 982   if (argc > idx_router_id)
 983     {
 984       ret = inet_aton (argv[idx_router_id]->arg, &id);
 985       if (! ret)
 986         {
 987           vty_out (vty, "%% Malformed BGP router identifier%s", VTY_NEWLINE);
 988           return CMD_WARNING;
 989         }
 990
 991       if (! IPV4_ADDR_SAME (&bgp->router_id_static, &id))
 992         {
 993           vty_out (vty, "%% BGP router-id doesn't match%s", VTY_NEWLINE);
 994           return CMD_WARNING;
 995         }
 996     }
 997
 998   id.s_addr = 0;
 999   bgp_router_id_static_set (bgp, id);
1000
1001   return CMD_SUCCESS;
1002 }
1003
1004
1005 /* BGP Cluster ID.  */
1006 DEFUN (bgp_cluster_id,
1007        bgp_cluster_id_cmd,
1008        "bgp cluster-id <A.B.C.D|(1-4294967295)>",
1009        BGP_STR
1010        "Configure Route-Reflector Cluster-id\n"
1011        "Route-Reflector Cluster-id in IP address format\n"
1012        "Route-Reflector Cluster-id as 32 bit quantity\n")
1013 {
1014   VTY_DECLVAR_CONTEXT(bgp, bgp);
1015   int idx_ipv4 = 2;
1016   int ret;
1017   struct in_addr cluster;
1018
1019   ret = inet_aton (argv[idx_ipv4]->arg, &cluster);
1020   if (! ret)
1021     {
1022       vty_out (vty, "%% Malformed bgp cluster identifier%s", VTY_NEWLINE);
1023       return CMD_WARNING;
1024     }
1025
1026   bgp_cluster_id_set (bgp, &cluster);
1027   bgp_clear_star_soft_out (vty, bgp->name);
1028
1029   return CMD_SUCCESS;
1030 }
1031
1032 DEFUN (no_bgp_cluster_id,
1033        no_bgp_cluster_id_cmd,
1034        "no bgp cluster-id [<A.B.C.D|(1-4294967295)>]",
1035        NO_STR
1036        BGP_STR
1037        "Configure Route-Reflector Cluster-id\n"
1038        "Route-Reflector Cluster-id in IP address format\n"
1039        "Route-Reflector Cluster-id as 32 bit quantity\n")
1040 {
1041   VTY_DECLVAR_CONTEXT(bgp, bgp);
1042   bgp_cluster_id_unset (bgp);
1043   bgp_clear_star_soft_out (vty, bgp->name);
1044
1045   return CMD_SUCCESS;
1046 }
1047
1048 DEFUN (bgp_confederation_identifier,
1049        bgp_confederation_identifier_cmd,
1050        "bgp confederation identifier (1-4294967295)",
1051        "BGP specific commands\n"
1052        "AS confederation parameters\n"
1053        "AS number\n"
1054        "Set routing domain confederation AS\n")
1055 {
1056   VTY_DECLVAR_CONTEXT(bgp, bgp);
1057   int idx_number = 3;
1058   as_t as;
1059
1060   VTY_GET_INTEGER_RANGE ("AS", as, argv[idx_number]->arg, 1, BGP_AS4_MAX);
1061
1062   bgp_confederation_id_set (bgp, as);
1063
1064   return CMD_SUCCESS;
1065 }
1066
1067 DEFUN (no_bgp_confederation_identifier,
1068        no_bgp_confederation_identifier_cmd,
1069        "no bgp confederation identifier [(1-4294967295)]",
1070        NO_STR
1071        "BGP specific commands\n"
1072        "AS confederation parameters\n"
1073        "AS number\n"
1074        "Set routing domain confederation AS\n")
1075 {
1076   VTY_DECLVAR_CONTEXT(bgp, bgp);
1077   bgp_confederation_id_unset (bgp);
1078
1079   return CMD_SUCCESS;
1080 }
1081
1082 DEFUN (bgp_confederation_peers,
1083        bgp_confederation_peers_cmd,
1084        "bgp confederation peers (1-4294967295)...",
1085        "BGP specific commands\n"
1086        "AS confederation parameters\n"
1087        "Peer ASs in BGP confederation\n"
1088        AS_STR)
1089 {
1090   VTY_DECLVAR_CONTEXT(bgp, bgp);
1091   int idx_asn = 3;
1092   as_t as;
1093   int i;
1094
1095   for (i = idx_asn; i < argc; i++)
1096     {
1097       VTY_GET_INTEGER_RANGE ("AS", as, argv[i]->arg, 1, BGP_AS4_MAX);
1098
1099       if (bgp->as == as)
1100         {
1101           vty_out (vty, "%% Local member-AS not allowed in confed peer list%s",
1102                    VTY_NEWLINE);
1103           continue;
1104         }
1105
1106       bgp_confederation_peers_add (bgp, as);
1107     }
1108   return CMD_SUCCESS;
1109 }
1110
1111 DEFUN (no_bgp_confederation_peers,
1112        no_bgp_confederation_peers_cmd,
1113        "no bgp confederation peers (1-4294967295)...",
1114        NO_STR
1115        "BGP specific commands\n"
1116        "AS confederation parameters\n"
1117        "Peer ASs in BGP confederation\n"
1118        AS_STR)
1119 {
1120   VTY_DECLVAR_CONTEXT(bgp, bgp);
1121   int idx_asn = 4;
1122   as_t as;
1123   int i;
1124
1125   for (i = idx_asn; i < argc; i++)
1126     {
1127       VTY_GET_INTEGER_RANGE ("AS", as, argv[i]->arg, 1, BGP_AS4_MAX);
1128
1129       bgp_confederation_peers_remove (bgp, as);
1130     }
1131   return CMD_SUCCESS;
1132 }
1133
1134 /**
1135  * Central routine for maximum-paths configuration.
1136  * @peer_type: BGP_PEER_EBGP or BGP_PEER_IBGP
1137  * @set: 1 for setting values, 0 for removing the max-paths config.
1138  */
1139 static int
1140 bgp_maxpaths_config_vty (struct vty *vty, int peer_type, const char *mpaths,
1141                          u_int16_t options, int set)
1142 {
1143   VTY_DECLVAR_CONTEXT(bgp, bgp);
1144   u_int16_t maxpaths = 0;
1145   int ret;
1146   afi_t afi;
1147   safi_t safi;
1148
1149   afi = bgp_node_afi (vty);
1150   safi = bgp_node_safi (vty);
1151
1152   if (set)
1153   {
1154     maxpaths = strtol(mpaths, NULL, 10);
1155     if (maxpaths > multipath_num)
1156       {
1157         vty_out (vty,
1158                  "%% Maxpaths Specified: %d is > than multipath num specified on bgp command line %d",
1159                  maxpaths, multipath_num);
1160         return CMD_WARNING;
1161       }
1162     ret = bgp_maximum_paths_set (bgp, afi, safi, peer_type, maxpaths, options);
1163   }
1164   else
1165     ret = bgp_maximum_paths_unset (bgp, afi, safi, peer_type);
1166
1167   if (ret < 0)
1168     {
1169       vty_out (vty,
1170                "%% Failed to %sset maximum-paths %s %u for afi %u, safi %u%s",
1171                (set == 1) ? "" : "un",
1172                (peer_type == BGP_PEER_EBGP) ? "ebgp" : "ibgp",
1173                maxpaths, afi, safi, VTY_NEWLINE);
1174       return CMD_WARNING;
1175     }
1176
1177   bgp_recalculate_all_bestpaths (bgp);
1178
1179   return CMD_SUCCESS;
1180 }
1181
1182 DEFUN (bgp_maxmed_admin,
1183        bgp_maxmed_admin_cmd,
1184        "bgp max-med administrative ",
1185        BGP_STR
1186        "Advertise routes with max-med\n"
1187        "Administratively applied, for an indefinite period\n")
1188 {
1189   VTY_DECLVAR_CONTEXT(bgp, bgp);
1190
1191   bgp->v_maxmed_admin = 1;
1192   bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1193
1194   bgp_maxmed_update(bgp);
1195
1196   return CMD_SUCCESS;
1197 }
1198
1199 DEFUN (bgp_maxmed_admin_medv,
1200        bgp_maxmed_admin_medv_cmd,
1201        "bgp max-med administrative (0-4294967294)",
1202        BGP_STR
1203        "Advertise routes with max-med\n"
1204        "Administratively applied, for an indefinite period\n"
1205        "Max MED value to be used\n")
1206 {
1207   VTY_DECLVAR_CONTEXT(bgp, bgp);
1208   int idx_number = 3;
1209
1210   bgp->v_maxmed_admin = 1;
1211   VTY_GET_INTEGER ("max-med admin med-value", bgp->maxmed_admin_value, argv[idx_number]->arg);
1212
1213   bgp_maxmed_update(bgp);
1214
1215   return CMD_SUCCESS;
1216 }
1217
1218 DEFUN (no_bgp_maxmed_admin,
1219        no_bgp_maxmed_admin_cmd,
1220        "no bgp max-med administrative [(0-4294967294)]",
1221        NO_STR
1222        BGP_STR
1223        "Advertise routes with max-med\n"
1224        "Administratively applied, for an indefinite period\n"
1225        "Max MED value to be used\n")
1226 {
1227   VTY_DECLVAR_CONTEXT(bgp, bgp);
1228   bgp->v_maxmed_admin = BGP_MAXMED_ADMIN_UNCONFIGURED;
1229   bgp->maxmed_admin_value = BGP_MAXMED_VALUE_DEFAULT;
1230   bgp_maxmed_update(bgp);
1231
1232   return CMD_SUCCESS;
1233 }
1234
1235 DEFUN (bgp_maxmed_onstartup,
1236        bgp_maxmed_onstartup_cmd,
1237        "bgp max-med on-startup (5-86400)",
1238        BGP_STR
1239        "Advertise routes with max-med\n"
1240        "Effective on a startup\n"
1241        "Time (seconds) period for max-med\n")
1242 {
1243   VTY_DECLVAR_CONTEXT(bgp, bgp);
1244   int idx_number = 3;
1245   VTY_GET_INTEGER ("max-med on-startup period", bgp->v_maxmed_onstartup, argv[idx_number]->arg);
1246   bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1247   bgp_maxmed_update(bgp);
1248
1249   return CMD_SUCCESS;
1250 }
1251
1252 DEFUN (bgp_maxmed_onstartup_medv,
1253        bgp_maxmed_onstartup_medv_cmd,
1254        "bgp max-med on-startup (5-86400) (0-4294967294)",
1255        BGP_STR
1256        "Advertise routes with max-med\n"
1257        "Effective on a startup\n"
1258        "Time (seconds) period for max-med\n"
1259        "Max MED value to be used\n")
1260 {
1261   VTY_DECLVAR_CONTEXT(bgp, bgp);
1262   int idx_number = 3;
1263   int idx_number_2 = 4;
1264   VTY_GET_INTEGER ("max-med on-startup period", bgp->v_maxmed_onstartup, argv[idx_number]->arg);
1265   VTY_GET_INTEGER ("max-med on-startup med-value", bgp->maxmed_onstartup_value, argv[idx_number_2]->arg);
1266   bgp_maxmed_update(bgp);
1267
1268   return CMD_SUCCESS;
1269 }
1270
1271 DEFUN (no_bgp_maxmed_onstartup,
1272        no_bgp_maxmed_onstartup_cmd,
1273        "no bgp max-med on-startup [(5-86400) [(0-4294967294)]]",
1274        NO_STR
1275        BGP_STR
1276        "Advertise routes with max-med\n"
1277        "Effective on a startup\n"
1278        "Time (seconds) period for max-med\n"
1279        "Max MED value to be used\n")
1280 {
1281   VTY_DECLVAR_CONTEXT(bgp, bgp);
1282
1283   /* Cancel max-med onstartup if its on */
1284   if (bgp->t_maxmed_onstartup)
1285     {
1286       THREAD_TIMER_OFF (bgp->t_maxmed_onstartup);
1287       bgp->maxmed_onstartup_over = 1;
1288     }
1289
1290   bgp->v_maxmed_onstartup = BGP_MAXMED_ONSTARTUP_UNCONFIGURED;
1291   bgp->maxmed_onstartup_value = BGP_MAXMED_VALUE_DEFAULT;
1292
1293   bgp_maxmed_update(bgp);
1294
1295   return CMD_SUCCESS;
1296 }
1297
1298 static int
1299 bgp_update_delay_config_vty (struct vty *vty, const char *delay,
1300                              const char *wait)
1301 {
1302   VTY_DECLVAR_CONTEXT(bgp, bgp);
1303   u_int16_t update_delay;
1304   u_int16_t establish_wait;
1305
1306   VTY_GET_INTEGER_RANGE ("update-delay", update_delay, delay,
1307                          BGP_UPDATE_DELAY_MIN, BGP_UPDATE_DELAY_MAX);
1308
1309   if (!wait) /* update-delay <delay> */
1310     {
1311       bgp->v_update_delay = update_delay;
1312       bgp->v_establish_wait = bgp->v_update_delay;
1313       return CMD_SUCCESS;
1314     }
1315
1316   /* update-delay <delay> <establish-wait> */
1317   establish_wait = atoi (wait);
1318   if (update_delay < establish_wait)
1319     {
1320       vty_out (vty, "%%Failed: update-delay less than the establish-wait!%s",
1321                VTY_NEWLINE);
1322       return CMD_WARNING;
1323     }
1324
1325   bgp->v_update_delay = update_delay;
1326   bgp->v_establish_wait = establish_wait;
1327
1328   return CMD_SUCCESS;
1329 }
1330
1331 static int
1332 bgp_update_delay_deconfig_vty (struct vty *vty)
1333 {
1334   VTY_DECLVAR_CONTEXT(bgp, bgp);
1335
1336   bgp->v_update_delay = BGP_UPDATE_DELAY_DEF;
1337   bgp->v_establish_wait = bgp->v_update_delay;
1338
1339   return CMD_SUCCESS;
1340 }
1341
1342 int
1343 bgp_config_write_update_delay (struct vty *vty, struct bgp *bgp)
1344 {
1345   if (bgp->v_update_delay != BGP_UPDATE_DELAY_DEF)
1346     {
1347       vty_out (vty, " update-delay %d", bgp->v_update_delay);
1348       if (bgp->v_update_delay != bgp->v_establish_wait)
1349         vty_out (vty, " %d", bgp->v_establish_wait);
1350       vty_out (vty, "%s", VTY_NEWLINE);
1351     }
1352
1353   return 0;
1354 }
1355
1356
1357 /* Update-delay configuration */
1358 DEFUN (bgp_update_delay,
1359        bgp_update_delay_cmd,
1360        "update-delay (0-3600)",
1361        "Force initial delay for best-path and updates\n"
1362        "Seconds\n")
1363 {
1364   int idx_number = 1;
1365   return bgp_update_delay_config_vty(vty, argv[idx_number]->arg, NULL);
1366 }
1367
1368 DEFUN (bgp_update_delay_establish_wait,
1369        bgp_update_delay_establish_wait_cmd,
1370        "update-delay (0-3600) (1-3600)",
1371        "Force initial delay for best-path and updates\n"
1372        "Seconds\n"
1373        "Wait for peers to be established\n"
1374        "Seconds\n")
1375 {
1376   int idx_number = 1;
1377   int idx_number_2 = 2;
1378   return bgp_update_delay_config_vty(vty, argv[idx_number]->arg, argv[idx_number_2]->arg);
1379 }
1380
1381 /* Update-delay deconfiguration */
1382 DEFUN (no_bgp_update_delay,
1383        no_bgp_update_delay_cmd,
1384        "no update-delay [(0-3600) [(1-3600)]]",
1385        NO_STR
1386        "Force initial delay for best-path and updates\n"
1387        "Seconds\n"
1388        "Wait for peers to be established\n")
1389 {
1390   return bgp_update_delay_deconfig_vty(vty);
1391 }
1392
1393
1394 static int
1395 bgp_wpkt_quanta_config_vty (struct vty *vty, const char *num, char set)
1396 {
1397   VTY_DECLVAR_CONTEXT(bgp, bgp);
1398
1399   if (set)
1400     VTY_GET_INTEGER_RANGE ("write-quanta", bgp->wpkt_quanta, num,
1401                            1, 10000);
1402   else
1403     bgp->wpkt_quanta = BGP_WRITE_PACKET_MAX;
1404
1405   return CMD_SUCCESS;
1406 }
1407
1408 int
1409 bgp_config_write_wpkt_quanta (struct vty *vty, struct bgp *bgp)
1410 {
1411   if (bgp->wpkt_quanta != BGP_WRITE_PACKET_MAX)
1412       vty_out (vty, " write-quanta %d%s",
1413                bgp->wpkt_quanta, VTY_NEWLINE);
1414
1415   return 0;
1416 }
1417
1418
1419 /* Update-delay configuration */
1420 DEFUN (bgp_wpkt_quanta,
1421        bgp_wpkt_quanta_cmd,
1422        "write-quanta (1-10000)",
1423        "How many packets to write to peer socket per run\n"
1424        "Number of packets\n")
1425 {
1426   int idx_number = 1;
1427   return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 1);
1428 }
1429
1430 /* Update-delay deconfiguration */
1431 DEFUN (no_bgp_wpkt_quanta,
1432        no_bgp_wpkt_quanta_cmd,
1433        "no write-quanta (1-10000)",
1434        NO_STR
1435        "How many packets to write to peer socket per run\n"
1436        "Number of packets\n")
1437 {
1438   int idx_number = 2;
1439   return bgp_wpkt_quanta_config_vty(vty, argv[idx_number]->arg, 0);
1440 }
1441
1442 static int
1443 bgp_coalesce_config_vty (struct vty *vty, const char *num, char set)
1444 {
1445   VTY_DECLVAR_CONTEXT(bgp, bgp);
1446
1447   if (set)
1448     VTY_GET_INTEGER_RANGE ("coalesce-time", bgp->coalesce_time, num,
1449                            0, 4294967295);
1450   else
1451     bgp->coalesce_time = BGP_DEFAULT_SUBGROUP_COALESCE_TIME;
1452
1453   return CMD_SUCCESS;
1454 }
1455
1456 int
1457 bgp_config_write_coalesce_time (struct vty *vty, struct bgp *bgp)
1458 {
1459   if (bgp->coalesce_time != BGP_DEFAULT_SUBGROUP_COALESCE_TIME)
1460       vty_out (vty, " coalesce-time %d%s",
1461                bgp->coalesce_time, VTY_NEWLINE);
1462
1463   return 0;
1464 }
1465
1466
1467 DEFUN (bgp_coalesce_time,
1468        bgp_coalesce_time_cmd,
1469        "coalesce-time (0-4294967295)",
1470        "Subgroup coalesce timer\n"
1471        "Subgroup coalesce timer value (in ms)\n")
1472 {
1473   int idx_number = 1;
1474   return bgp_coalesce_config_vty(vty, argv[idx_number]->arg, 1);
1475 }
1476
1477 DEFUN (no_bgp_coalesce_time,
1478        no_bgp_coalesce_time_cmd,
1479        "no coalesce-time (0-4294967295)",
1480        NO_STR
1481        "Subgroup coalesce timer\n"
1482        "Subgroup coalesce timer value (in ms)\n")
1483 {
1484   int idx_number = 2;
1485   return bgp_coalesce_config_vty(vty, argv[idx_number]->arg, 0);
1486 }
1487
1488 /* Maximum-paths configuration */
1489 DEFUN (bgp_maxpaths,
1490        bgp_maxpaths_cmd,
1491        "maximum-paths (1-255)",
1492        "Forward packets over multiple paths\n"
1493        "Number of paths\n")
1494 {
1495   int idx_number = 1;
1496   return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, argv[idx_number]->arg, 0, 1);
1497 }
1498
1499 DEFUN (bgp_maxpaths_ibgp,
1500        bgp_maxpaths_ibgp_cmd,
1501        "maximum-paths ibgp (1-255)",
1502        "Forward packets over multiple paths\n"
1503        "iBGP-multipath\n"
1504        "Number of paths\n")
1505 {
1506   int idx_number = 2;
1507   return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, argv[idx_number]->arg, 0, 1);
1508 }
1509
1510 DEFUN (bgp_maxpaths_ibgp_cluster,
1511        bgp_maxpaths_ibgp_cluster_cmd,
1512        "maximum-paths ibgp (1-255) equal-cluster-length",
1513        "Forward packets over multiple paths\n"
1514        "iBGP-multipath\n"
1515        "Number of paths\n"
1516        "Match the cluster length\n")
1517 {
1518   int idx_number = 2;
1519   return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, argv[idx_number]->arg,
1520                                  BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN, 1);
1521 }
1522
1523 DEFUN (no_bgp_maxpaths,
1524        no_bgp_maxpaths_cmd,
1525        "no maximum-paths [(1-255)]",
1526        NO_STR
1527        "Forward packets over multiple paths\n"
1528        "Number of paths\n")
1529 {
1530   return bgp_maxpaths_config_vty(vty, BGP_PEER_EBGP, NULL, 0, 0);
1531 }
1532
1533 DEFUN (no_bgp_maxpaths_ibgp,
1534        no_bgp_maxpaths_ibgp_cmd,
1535        "no maximum-paths ibgp [(1-255) [equal-cluster-length]]",
1536        NO_STR
1537        "Forward packets over multiple paths\n"
1538        "iBGP-multipath\n"
1539        "Number of paths\n"
1540        "Match the cluster length\n")
1541 {
1542   return bgp_maxpaths_config_vty(vty, BGP_PEER_IBGP, NULL, 0, 0);
1543 }
1544
1545 int
1546 bgp_config_write_maxpaths (struct vty *vty, struct bgp *bgp, afi_t afi,
1547                            safi_t safi, int *write)
1548 {
1549   if (bgp->maxpaths[afi][safi].maxpaths_ebgp != MULTIPATH_NUM)
1550     {
1551       bgp_config_write_family_header (vty, afi, safi, write);
1552       vty_out (vty, "  maximum-paths %d%s",
1553                bgp->maxpaths[afi][safi].maxpaths_ebgp, VTY_NEWLINE);
1554     }
1555
1556   if (bgp->maxpaths[afi][safi].maxpaths_ibgp != MULTIPATH_NUM)
1557     {
1558       bgp_config_write_family_header (vty, afi, safi, write);
1559       vty_out (vty, "  maximum-paths ibgp %d",
1560                bgp->maxpaths[afi][safi].maxpaths_ibgp);
1561       if (CHECK_FLAG (bgp->maxpaths[afi][safi].ibgp_flags,
1562                       BGP_FLAG_IBGP_MULTIPATH_SAME_CLUSTERLEN))
1563         vty_out (vty, " equal-cluster-length");
1564       vty_out (vty, "%s", VTY_NEWLINE);
1565     }
1566
1567   return 0;
1568 }
1569
1570 /* BGP timers.  */
1571
1572 DEFUN (bgp_timers,
1573        bgp_timers_cmd,
1574        "timers bgp (0-65535) (0-65535)",
1575        "Adjust routing timers\n"
1576        "BGP timers\n"
1577        "Keepalive interval\n"
1578        "Holdtime\n")
1579 {
1580   VTY_DECLVAR_CONTEXT(bgp, bgp);
1581   int idx_number = 2;
1582   int idx_number_2 = 3;
1583   unsigned long keepalive = 0;
1584   unsigned long holdtime = 0;
1585
1586   VTY_GET_INTEGER ("keepalive", keepalive, argv[idx_number]->arg);
1587   VTY_GET_INTEGER ("holdtime", holdtime, argv[idx_number_2]->arg);
1588
1589   /* Holdtime value check. */
1590   if (holdtime < 3 && holdtime != 0)
1591     {
1592       vty_out (vty, "%% hold time value must be either 0 or greater than 3%s",
1593                VTY_NEWLINE);
1594       return CMD_WARNING;
1595     }
1596
1597   bgp_timers_set (bgp, keepalive, holdtime);
1598
1599   return CMD_SUCCESS;
1600 }
1601
1602 DEFUN (no_bgp_timers,
1603        no_bgp_timers_cmd,
1604        "no timers bgp [(0-65535) (0-65535)]",
1605        NO_STR
1606        "Adjust routing timers\n"
1607        "BGP timers\n"
1608        "Keepalive interval\n"
1609        "Holdtime\n")
1610 {
1611   VTY_DECLVAR_CONTEXT(bgp, bgp);
1612   bgp_timers_unset (bgp);
1613
1614   return CMD_SUCCESS;
1615 }
1616
1617
1618 DEFUN (bgp_client_to_client_reflection,
1619        bgp_client_to_client_reflection_cmd,
1620        "bgp client-to-client reflection",
1621        "BGP specific commands\n"
1622        "Configure client to client route reflection\n"
1623        "reflection of routes allowed\n")
1624 {
1625   VTY_DECLVAR_CONTEXT(bgp, bgp);
1626   bgp_flag_unset (bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1627   bgp_clear_star_soft_out (vty, bgp->name);
1628
1629   return CMD_SUCCESS;
1630 }
1631
1632 DEFUN (no_bgp_client_to_client_reflection,
1633        no_bgp_client_to_client_reflection_cmd,
1634        "no bgp client-to-client reflection",
1635        NO_STR
1636        "BGP specific commands\n"
1637        "Configure client to client route reflection\n"
1638        "reflection of routes allowed\n")
1639 {
1640   VTY_DECLVAR_CONTEXT(bgp, bgp);
1641   bgp_flag_set (bgp, BGP_FLAG_NO_CLIENT_TO_CLIENT);
1642   bgp_clear_star_soft_out (vty, bgp->name);
1643
1644   return CMD_SUCCESS;
1645 }
1646
1647 /* "bgp always-compare-med" configuration. */
1648 DEFUN (bgp_always_compare_med,
1649        bgp_always_compare_med_cmd,
1650        "bgp always-compare-med",
1651        "BGP specific commands\n"
1652        "Allow comparing MED from different neighbors\n")
1653 {
1654   VTY_DECLVAR_CONTEXT(bgp, bgp);
1655   bgp_flag_set (bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1656   bgp_recalculate_all_bestpaths (bgp);
1657
1658   return CMD_SUCCESS;
1659 }
1660
1661 DEFUN (no_bgp_always_compare_med,
1662        no_bgp_always_compare_med_cmd,
1663        "no bgp always-compare-med",
1664        NO_STR
1665        "BGP specific commands\n"
1666        "Allow comparing MED from different neighbors\n")
1667 {
1668   VTY_DECLVAR_CONTEXT(bgp, bgp);
1669   bgp_flag_unset (bgp, BGP_FLAG_ALWAYS_COMPARE_MED);
1670   bgp_recalculate_all_bestpaths (bgp);
1671
1672   return CMD_SUCCESS;
1673 }
1674
1675 /* "bgp deterministic-med" configuration. */
1676 DEFUN (bgp_deterministic_med,
1677        bgp_deterministic_med_cmd,
1678        "bgp deterministic-med",
1679        "BGP specific commands\n"
1680        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1681 {
1682   VTY_DECLVAR_CONTEXT(bgp, bgp);
1683
1684   if (!bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED))
1685     {
1686       bgp_flag_set (bgp, BGP_FLAG_DETERMINISTIC_MED);
1687       bgp_recalculate_all_bestpaths (bgp);
1688     }
1689
1690   return CMD_SUCCESS;
1691 }
1692
1693 DEFUN (no_bgp_deterministic_med,
1694        no_bgp_deterministic_med_cmd,
1695        "no bgp deterministic-med",
1696        NO_STR
1697        "BGP specific commands\n"
1698        "Pick the best-MED path among paths advertised from the neighboring AS\n")
1699 {
1700   VTY_DECLVAR_CONTEXT(bgp, bgp);
1701   int bestpath_per_as_used;
1702   afi_t afi;
1703   safi_t safi;
1704   struct peer *peer;
1705   struct listnode *node, *nnode;
1706
1707   if (bgp_flag_check(bgp, BGP_FLAG_DETERMINISTIC_MED))
1708     {
1709       bestpath_per_as_used = 0;
1710
1711       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
1712         {
1713           for (afi = AFI_IP; afi < AFI_MAX; afi++)
1714             for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
1715               if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS))
1716                 {
1717                   bestpath_per_as_used = 1;
1718                   break;
1719                 }
1720
1721           if (bestpath_per_as_used)
1722             break;
1723         }
1724
1725       if (bestpath_per_as_used)
1726         {
1727           vty_out (vty, "bgp deterministic-med cannot be disabled while addpath-tx-bestpath-per-AS is in use%s",
1728                    VTY_NEWLINE);
1729           return CMD_WARNING;
1730         }
1731       else
1732         {
1733           bgp_flag_unset (bgp, BGP_FLAG_DETERMINISTIC_MED);
1734           bgp_recalculate_all_bestpaths (bgp);
1735         }
1736     }
1737
1738   return CMD_SUCCESS;
1739 }
1740
1741 /* "bgp graceful-restart" configuration. */
1742 DEFUN (bgp_graceful_restart,
1743        bgp_graceful_restart_cmd,
1744        "bgp graceful-restart",
1745        "BGP specific commands\n"
1746        "Graceful restart capability parameters\n")
1747 {
1748   VTY_DECLVAR_CONTEXT(bgp, bgp);
1749   bgp_flag_set (bgp, BGP_FLAG_GRACEFUL_RESTART);
1750   return CMD_SUCCESS;
1751 }
1752
1753 DEFUN (no_bgp_graceful_restart,
1754        no_bgp_graceful_restart_cmd,
1755        "no bgp graceful-restart",
1756        NO_STR
1757        "BGP specific commands\n"
1758        "Graceful restart capability parameters\n")
1759 {
1760   VTY_DECLVAR_CONTEXT(bgp, bgp);
1761   bgp_flag_unset (bgp, BGP_FLAG_GRACEFUL_RESTART);
1762   return CMD_SUCCESS;
1763 }
1764
1765 DEFUN (bgp_graceful_restart_stalepath_time,
1766        bgp_graceful_restart_stalepath_time_cmd,
1767        "bgp graceful-restart stalepath-time (1-3600)",
1768        "BGP specific commands\n"
1769        "Graceful restart capability parameters\n"
1770        "Set the max time to hold onto restarting peer's stale paths\n"
1771        "Delay value (seconds)\n")
1772 {
1773   VTY_DECLVAR_CONTEXT(bgp, bgp);
1774   int idx_number = 3;
1775   u_int32_t stalepath;
1776
1777   VTY_GET_INTEGER_RANGE ("stalepath-time", stalepath, argv[idx_number]->arg, 1, 3600);
1778   bgp->stalepath_time = stalepath;
1779   return CMD_SUCCESS;
1780 }
1781
1782 DEFUN (bgp_graceful_restart_restart_time,
1783        bgp_graceful_restart_restart_time_cmd,
1784        "bgp graceful-restart restart-time (1-3600)",
1785        "BGP specific commands\n"
1786        "Graceful restart capability parameters\n"
1787        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1788        "Delay value (seconds)\n")
1789 {
1790   VTY_DECLVAR_CONTEXT(bgp, bgp);
1791   int idx_number = 3;
1792   u_int32_t restart;
1793
1794   VTY_GET_INTEGER_RANGE ("restart-time", restart, argv[idx_number]->arg, 1, 3600);
1795   bgp->restart_time = restart;
1796   return CMD_SUCCESS;
1797 }
1798
1799 DEFUN (no_bgp_graceful_restart_stalepath_time,
1800        no_bgp_graceful_restart_stalepath_time_cmd,
1801        "no bgp graceful-restart stalepath-time [(1-3600)]",
1802        NO_STR
1803        "BGP specific commands\n"
1804        "Graceful restart capability parameters\n"
1805        "Set the max time to hold onto restarting peer's stale paths\n"
1806        "Delay value (seconds)\n")
1807 {
1808   VTY_DECLVAR_CONTEXT(bgp, bgp);
1809
1810   bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
1811   return CMD_SUCCESS;
1812 }
1813
1814 DEFUN (no_bgp_graceful_restart_restart_time,
1815        no_bgp_graceful_restart_restart_time_cmd,
1816        "no bgp graceful-restart restart-time [(1-3600)]",
1817        NO_STR
1818        "BGP specific commands\n"
1819        "Graceful restart capability parameters\n"
1820        "Set the time to wait to delete stale routes before a BGP open message is received\n"
1821        "Delay value (seconds)\n")
1822 {
1823   VTY_DECLVAR_CONTEXT(bgp, bgp);
1824
1825   bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
1826   return CMD_SUCCESS;
1827 }
1828
1829 DEFUN (bgp_graceful_restart_preserve_fw,
1830        bgp_graceful_restart_preserve_fw_cmd,
1831        "bgp graceful-restart preserve-fw-state",
1832        "BGP specific commands\n"
1833        "Graceful restart capability parameters\n"
1834        "Sets F-bit indication that fib is preserved while doing Graceful Restart\n")
1835 {
1836   VTY_DECLVAR_CONTEXT(bgp, bgp);
1837   bgp_flag_set(bgp, BGP_FLAG_GR_PRESERVE_FWD);
1838   return CMD_SUCCESS;
1839 }
1840
1841 DEFUN (no_bgp_graceful_restart_preserve_fw,
1842        no_bgp_graceful_restart_preserve_fw_cmd,
1843        "no bgp graceful-restart preserve-fw-state",
1844        NO_STR
1845        "BGP specific commands\n"
1846        "Graceful restart capability parameters\n"
1847        "Unsets F-bit indication that fib is preserved while doing Graceful Restart\n")
1848 {
1849   VTY_DECLVAR_CONTEXT(bgp, bgp);
1850   bgp_flag_unset(bgp, BGP_FLAG_GR_PRESERVE_FWD);
1851   return CMD_SUCCESS;
1852 }
1853
1854 /* "bgp fast-external-failover" configuration. */
1855 DEFUN (bgp_fast_external_failover,
1856        bgp_fast_external_failover_cmd,
1857        "bgp fast-external-failover",
1858        BGP_STR
1859        "Immediately reset session if a link to a directly connected external peer goes down\n")
1860 {
1861   VTY_DECLVAR_CONTEXT(bgp, bgp);
1862   bgp_flag_unset (bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
1863   return CMD_SUCCESS;
1864 }
1865
1866 DEFUN (no_bgp_fast_external_failover,
1867        no_bgp_fast_external_failover_cmd,
1868        "no bgp fast-external-failover",
1869        NO_STR
1870        BGP_STR
1871        "Immediately reset session if a link to a directly connected external peer goes down\n")
1872 {
1873   VTY_DECLVAR_CONTEXT(bgp, bgp);
1874   bgp_flag_set (bgp, BGP_FLAG_NO_FAST_EXT_FAILOVER);
1875   return CMD_SUCCESS;
1876 }
1877
1878 /* "bgp enforce-first-as" configuration. */
1879 DEFUN (bgp_enforce_first_as,
1880        bgp_enforce_first_as_cmd,
1881        "bgp enforce-first-as",
1882        BGP_STR
1883        "Enforce the first AS for EBGP routes\n")
1884 {
1885   VTY_DECLVAR_CONTEXT(bgp, bgp);
1886   bgp_flag_set (bgp, BGP_FLAG_ENFORCE_FIRST_AS);
1887   bgp_clear_star_soft_in (vty, bgp->name);
1888
1889   return CMD_SUCCESS;
1890 }
1891
1892 DEFUN (no_bgp_enforce_first_as,
1893        no_bgp_enforce_first_as_cmd,
1894        "no bgp enforce-first-as",
1895        NO_STR
1896        BGP_STR
1897        "Enforce the first AS for EBGP routes\n")
1898 {
1899   VTY_DECLVAR_CONTEXT(bgp, bgp);
1900   bgp_flag_unset (bgp, BGP_FLAG_ENFORCE_FIRST_AS);
1901   bgp_clear_star_soft_in (vty, bgp->name);
1902
1903   return CMD_SUCCESS;
1904 }
1905
1906 /* "bgp bestpath compare-routerid" configuration.  */
1907 DEFUN (bgp_bestpath_compare_router_id,
1908        bgp_bestpath_compare_router_id_cmd,
1909        "bgp bestpath compare-routerid",
1910        "BGP specific commands\n"
1911        "Change the default bestpath selection\n"
1912        "Compare router-id for identical EBGP paths\n")
1913 {
1914   VTY_DECLVAR_CONTEXT(bgp, bgp);
1915   bgp_flag_set (bgp, BGP_FLAG_COMPARE_ROUTER_ID);
1916   bgp_recalculate_all_bestpaths (bgp);
1917
1918   return CMD_SUCCESS;
1919 }
1920
1921 DEFUN (no_bgp_bestpath_compare_router_id,
1922        no_bgp_bestpath_compare_router_id_cmd,
1923        "no bgp bestpath compare-routerid",
1924        NO_STR
1925        "BGP specific commands\n"
1926        "Change the default bestpath selection\n"
1927        "Compare router-id for identical EBGP paths\n")
1928 {
1929   VTY_DECLVAR_CONTEXT(bgp, bgp);
1930   bgp_flag_unset (bgp, BGP_FLAG_COMPARE_ROUTER_ID);
1931   bgp_recalculate_all_bestpaths (bgp);
1932
1933   return CMD_SUCCESS;
1934 }
1935
1936 /* "bgp bestpath as-path ignore" configuration.  */
1937 DEFUN (bgp_bestpath_aspath_ignore,
1938        bgp_bestpath_aspath_ignore_cmd,
1939        "bgp bestpath as-path ignore",
1940        "BGP specific commands\n"
1941        "Change the default bestpath selection\n"
1942        "AS-path attribute\n"
1943        "Ignore as-path length in selecting a route\n")
1944 {
1945   VTY_DECLVAR_CONTEXT(bgp, bgp);
1946   bgp_flag_set (bgp, BGP_FLAG_ASPATH_IGNORE);
1947   bgp_recalculate_all_bestpaths (bgp);
1948
1949   return CMD_SUCCESS;
1950 }
1951
1952 DEFUN (no_bgp_bestpath_aspath_ignore,
1953        no_bgp_bestpath_aspath_ignore_cmd,
1954        "no bgp bestpath as-path ignore",
1955        NO_STR
1956        "BGP specific commands\n"
1957        "Change the default bestpath selection\n"
1958        "AS-path attribute\n"
1959        "Ignore as-path length in selecting a route\n")
1960 {
1961   VTY_DECLVAR_CONTEXT(bgp, bgp);
1962   bgp_flag_unset (bgp, BGP_FLAG_ASPATH_IGNORE);
1963   bgp_recalculate_all_bestpaths (bgp);
1964
1965   return CMD_SUCCESS;
1966 }
1967
1968 /* "bgp bestpath as-path confed" configuration.  */
1969 DEFUN (bgp_bestpath_aspath_confed,
1970        bgp_bestpath_aspath_confed_cmd,
1971        "bgp bestpath as-path confed",
1972        "BGP specific commands\n"
1973        "Change the default bestpath selection\n"
1974        "AS-path attribute\n"
1975        "Compare path lengths including confederation sets & sequences in selecting a route\n")
1976 {
1977   VTY_DECLVAR_CONTEXT(bgp, bgp);
1978   bgp_flag_set (bgp, BGP_FLAG_ASPATH_CONFED);
1979   bgp_recalculate_all_bestpaths (bgp);
1980
1981   return CMD_SUCCESS;
1982 }
1983
1984 DEFUN (no_bgp_bestpath_aspath_confed,
1985        no_bgp_bestpath_aspath_confed_cmd,
1986        "no bgp bestpath as-path confed",
1987        NO_STR
1988        "BGP specific commands\n"
1989        "Change the default bestpath selection\n"
1990        "AS-path attribute\n"
1991        "Compare path lengths including confederation sets & sequences in selecting a route\n")
1992 {
1993   VTY_DECLVAR_CONTEXT(bgp, bgp);
1994   bgp_flag_unset (bgp, BGP_FLAG_ASPATH_CONFED);
1995   bgp_recalculate_all_bestpaths (bgp);
1996
1997   return CMD_SUCCESS;
1998 }
1999
2000 /* "bgp bestpath as-path multipath-relax" configuration.  */
2001 DEFUN (bgp_bestpath_aspath_multipath_relax,
2002        bgp_bestpath_aspath_multipath_relax_cmd,
2003        "bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2004        "BGP specific commands\n"
2005        "Change the default bestpath selection\n"
2006        "AS-path attribute\n"
2007        "Allow load sharing across routes that have different AS paths (but same length)\n"
2008        "Generate an AS_SET\n"
2009        "Do not generate an AS_SET\n")
2010 {
2011   VTY_DECLVAR_CONTEXT(bgp, bgp);
2012   int idx = 0;
2013   bgp_flag_set (bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2014
2015   /* no-as-set is now the default behavior so we can silently
2016    * ignore it */
2017   if (argv_find (argv, argc, "as-set", &idx))
2018     bgp_flag_set (bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2019   else
2020     bgp_flag_unset (bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET) ;
2021
2022   bgp_recalculate_all_bestpaths (bgp);
2023
2024   return CMD_SUCCESS;
2025 }
2026
2027 DEFUN (no_bgp_bestpath_aspath_multipath_relax,
2028        no_bgp_bestpath_aspath_multipath_relax_cmd,
2029        "no bgp bestpath as-path multipath-relax [<as-set|no-as-set>]",
2030        NO_STR
2031        "BGP specific commands\n"
2032        "Change the default bestpath selection\n"
2033        "AS-path attribute\n"
2034        "Allow load sharing across routes that have different AS paths (but same length)\n"
2035        "Generate an AS_SET\n"
2036        "Do not generate an AS_SET\n")
2037 {
2038   VTY_DECLVAR_CONTEXT(bgp, bgp);
2039   bgp_flag_unset (bgp, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
2040   bgp_flag_unset (bgp, BGP_FLAG_MULTIPATH_RELAX_AS_SET);
2041   bgp_recalculate_all_bestpaths (bgp);
2042
2043   return CMD_SUCCESS;
2044 }
2045
2046 /* "bgp log-neighbor-changes" configuration.  */
2047 DEFUN (bgp_log_neighbor_changes,
2048        bgp_log_neighbor_changes_cmd,
2049        "bgp log-neighbor-changes",
2050        "BGP specific commands\n"
2051        "Log neighbor up/down and reset reason\n")
2052 {
2053   VTY_DECLVAR_CONTEXT(bgp, bgp);
2054   bgp_flag_set (bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2055   return CMD_SUCCESS;
2056 }
2057
2058 DEFUN (no_bgp_log_neighbor_changes,
2059        no_bgp_log_neighbor_changes_cmd,
2060        "no bgp log-neighbor-changes",
2061        NO_STR
2062        "BGP specific commands\n"
2063        "Log neighbor up/down and reset reason\n")
2064 {
2065   VTY_DECLVAR_CONTEXT(bgp, bgp);
2066   bgp_flag_unset (bgp, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
2067   return CMD_SUCCESS;
2068 }
2069
2070 /* "bgp bestpath med" configuration. */
2071 DEFUN (bgp_bestpath_med,
2072        bgp_bestpath_med_cmd,
2073        "bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2074        "BGP specific commands\n"
2075        "Change the default bestpath selection\n"
2076        "MED attribute\n"
2077        "Compare MED among confederation paths\n"
2078        "Treat missing MED as the least preferred one\n"
2079        "Treat missing MED as the least preferred one\n"
2080        "Compare MED among confederation paths\n")
2081 {
2082   VTY_DECLVAR_CONTEXT(bgp, bgp);
2083
2084   int idx = 0;
2085   if (argv_find (argv, argc, "confed", &idx))
2086     bgp_flag_set (bgp, BGP_FLAG_MED_CONFED);
2087   idx = 0;
2088   if (argv_find (argv, argc, "missing-as-worst", &idx))
2089     bgp_flag_set (bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2090
2091   bgp_recalculate_all_bestpaths (bgp);
2092
2093   return CMD_SUCCESS;
2094 }
2095
2096 DEFUN (no_bgp_bestpath_med,
2097        no_bgp_bestpath_med_cmd,
2098        "no bgp bestpath med <confed [missing-as-worst]|missing-as-worst [confed]>",
2099        NO_STR
2100        "BGP specific commands\n"
2101        "Change the default bestpath selection\n"
2102        "MED attribute\n"
2103        "Compare MED among confederation paths\n"
2104        "Treat missing MED as the least preferred one\n"
2105        "Treat missing MED as the least preferred one\n"
2106        "Compare MED among confederation paths\n")
2107 {
2108   VTY_DECLVAR_CONTEXT(bgp, bgp);
2109
2110   int idx = 0;
2111   if (argv_find (argv, argc, "confed", &idx))
2112     bgp_flag_unset (bgp, BGP_FLAG_MED_CONFED);
2113   idx = 0;
2114   if (argv_find (argv, argc, "missing-as-worst", &idx))
2115     bgp_flag_unset (bgp, BGP_FLAG_MED_MISSING_AS_WORST);
2116
2117   bgp_recalculate_all_bestpaths (bgp);
2118
2119   return CMD_SUCCESS;
2120 }
2121
2122 /* "no bgp default ipv4-unicast". */
2123 DEFUN (no_bgp_default_ipv4_unicast,
2124        no_bgp_default_ipv4_unicast_cmd,
2125        "no bgp default ipv4-unicast",
2126        NO_STR
2127        "BGP specific commands\n"
2128        "Configure BGP defaults\n"
2129        "Activate ipv4-unicast for a peer by default\n")
2130 {
2131   VTY_DECLVAR_CONTEXT(bgp, bgp);
2132   bgp_flag_set (bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2133   return CMD_SUCCESS;
2134 }
2135
2136 DEFUN (bgp_default_ipv4_unicast,
2137        bgp_default_ipv4_unicast_cmd,
2138        "bgp default ipv4-unicast",
2139        "BGP specific commands\n"
2140        "Configure BGP defaults\n"
2141        "Activate ipv4-unicast for a peer by default\n")
2142 {
2143   VTY_DECLVAR_CONTEXT(bgp, bgp);
2144   bgp_flag_unset (bgp, BGP_FLAG_NO_DEFAULT_IPV4);
2145   return CMD_SUCCESS;
2146 }
2147
2148 /* Display hostname in certain command outputs */
2149 DEFUN (bgp_default_show_hostname,
2150        bgp_default_show_hostname_cmd,
2151        "bgp default show-hostname",
2152        "BGP specific commands\n"
2153        "Configure BGP defaults\n"
2154        "Show hostname in certain command ouputs\n")
2155 {
2156   VTY_DECLVAR_CONTEXT(bgp, bgp);
2157   bgp_flag_set (bgp, BGP_FLAG_SHOW_HOSTNAME);
2158   return CMD_SUCCESS;
2159 }
2160
2161 DEFUN (no_bgp_default_show_hostname,
2162        no_bgp_default_show_hostname_cmd,
2163        "no bgp default show-hostname",
2164        NO_STR
2165        "BGP specific commands\n"
2166        "Configure BGP defaults\n"
2167        "Show hostname in certain command ouputs\n")
2168 {
2169   VTY_DECLVAR_CONTEXT(bgp, bgp);
2170   bgp_flag_unset (bgp, BGP_FLAG_SHOW_HOSTNAME);
2171   return CMD_SUCCESS;
2172 }
2173
2174 /* "bgp network import-check" configuration.  */
2175 DEFUN (bgp_network_import_check,
2176        bgp_network_import_check_cmd,
2177        "bgp network import-check",
2178        "BGP specific commands\n"
2179        "BGP network command\n"
2180        "Check BGP network route exists in IGP\n")
2181 {
2182   VTY_DECLVAR_CONTEXT(bgp, bgp);
2183   if (!bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK))
2184     {
2185       bgp_flag_set (bgp, BGP_FLAG_IMPORT_CHECK);
2186       bgp_static_redo_import_check(bgp);
2187     }
2188
2189   return CMD_SUCCESS;
2190 }
2191
2192 ALIAS_HIDDEN (bgp_network_import_check,
2193               bgp_network_import_check_exact_cmd,
2194               "bgp network import-check exact",
2195               "BGP specific commands\n"
2196               "BGP network command\n"
2197               "Check BGP network route exists in IGP\n"
2198               "Match route precisely\n")
2199
2200 DEFUN (no_bgp_network_import_check,
2201        no_bgp_network_import_check_cmd,
2202        "no bgp network import-check",
2203        NO_STR
2204        "BGP specific commands\n"
2205        "BGP network command\n"
2206        "Check BGP network route exists in IGP\n")
2207 {
2208   VTY_DECLVAR_CONTEXT(bgp, bgp);
2209   if (bgp_flag_check(bgp, BGP_FLAG_IMPORT_CHECK))
2210     {
2211       bgp_flag_unset (bgp, BGP_FLAG_IMPORT_CHECK);
2212       bgp_static_redo_import_check(bgp);
2213     }
2214
2215   return CMD_SUCCESS;
2216 }
2217
2218 DEFUN (bgp_default_local_preference,
2219        bgp_default_local_preference_cmd,
2220        "bgp default local-preference (0-4294967295)",
2221        "BGP specific commands\n"
2222        "Configure BGP defaults\n"
2223        "local preference (higher=more preferred)\n"
2224        "Configure default local preference value\n")
2225 {
2226   VTY_DECLVAR_CONTEXT(bgp, bgp);
2227   int idx_number = 3;
2228   u_int32_t local_pref;
2229
2230   VTY_GET_INTEGER ("local preference", local_pref, argv[idx_number]->arg);
2231
2232   bgp_default_local_preference_set (bgp, local_pref);
2233   bgp_clear_star_soft_in (vty, bgp->name);
2234
2235   return CMD_SUCCESS;
2236 }
2237
2238 DEFUN (no_bgp_default_local_preference,
2239        no_bgp_default_local_preference_cmd,
2240        "no bgp default local-preference [(0-4294967295)]",
2241        NO_STR
2242        "BGP specific commands\n"
2243        "Configure BGP defaults\n"
2244        "local preference (higher=more preferred)\n"
2245        "Configure default local preference value\n")
2246 {
2247   VTY_DECLVAR_CONTEXT(bgp, bgp);
2248   bgp_default_local_preference_unset (bgp);
2249   bgp_clear_star_soft_in (vty, bgp->name);
2250
2251   return CMD_SUCCESS;
2252 }
2253
2254
2255 DEFUN (bgp_default_subgroup_pkt_queue_max,
2256        bgp_default_subgroup_pkt_queue_max_cmd,
2257        "bgp default subgroup-pkt-queue-max (20-100)",
2258        "BGP specific commands\n"
2259        "Configure BGP defaults\n"
2260        "subgroup-pkt-queue-max\n"
2261        "Configure subgroup packet queue max\n")
2262 {
2263   VTY_DECLVAR_CONTEXT(bgp, bgp);
2264   int idx_number = 3;
2265   u_int32_t max_size;
2266
2267   VTY_GET_INTEGER ("subgroup packet queue max", max_size, argv[idx_number]->arg);
2268
2269   bgp_default_subgroup_pkt_queue_max_set (bgp, max_size);
2270
2271   return CMD_SUCCESS;
2272 }
2273
2274 DEFUN (no_bgp_default_subgroup_pkt_queue_max,
2275        no_bgp_default_subgroup_pkt_queue_max_cmd,
2276        "no bgp default subgroup-pkt-queue-max [(20-100)]",
2277        NO_STR
2278        "BGP specific commands\n"
2279        "Configure BGP defaults\n"
2280        "subgroup-pkt-queue-max\n"
2281        "Configure subgroup packet queue max\n")
2282 {
2283   VTY_DECLVAR_CONTEXT(bgp, bgp);
2284   bgp_default_subgroup_pkt_queue_max_unset (bgp);
2285   return CMD_SUCCESS;
2286 }
2287
2288
2289 DEFUN (bgp_rr_allow_outbound_policy,
2290        bgp_rr_allow_outbound_policy_cmd,
2291        "bgp route-reflector allow-outbound-policy",
2292        "BGP specific commands\n"
2293        "Allow modifications made by out route-map\n"
2294        "on ibgp neighbors\n")
2295 {
2296   VTY_DECLVAR_CONTEXT(bgp, bgp);
2297
2298   if (!bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY))
2299     {
2300       bgp_flag_set(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2301       update_group_announce_rrclients(bgp);
2302       bgp_clear_star_soft_out (vty, bgp->name);
2303     }
2304
2305   return CMD_SUCCESS;
2306 }
2307
2308 DEFUN (no_bgp_rr_allow_outbound_policy,
2309        no_bgp_rr_allow_outbound_policy_cmd,
2310        "no bgp route-reflector allow-outbound-policy",
2311        NO_STR
2312        "BGP specific commands\n"
2313        "Allow modifications made by out route-map\n"
2314        "on ibgp neighbors\n")
2315 {
2316   VTY_DECLVAR_CONTEXT(bgp, bgp);
2317
2318   if (bgp_flag_check(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY))
2319     {
2320       bgp_flag_unset(bgp, BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY);
2321       update_group_announce_rrclients(bgp);
2322       bgp_clear_star_soft_out (vty, bgp->name);
2323     }
2324
2325   return CMD_SUCCESS;
2326 }
2327
2328 DEFUN (bgp_listen_limit,
2329        bgp_listen_limit_cmd,
2330        "bgp listen limit (1-5000)",
2331        "BGP specific commands\n"
2332        "Configure BGP defaults\n"
2333        "maximum number of BGP Dynamic Neighbors that can be created\n"
2334        "Configure Dynamic Neighbors listen limit value\n")
2335 {
2336   VTY_DECLVAR_CONTEXT(bgp, bgp);
2337   int idx_number = 3;
2338   int listen_limit;
2339
2340   VTY_GET_INTEGER_RANGE ("listen limit", listen_limit, argv[idx_number]->arg,
2341                          BGP_DYNAMIC_NEIGHBORS_LIMIT_MIN,
2342                          BGP_DYNAMIC_NEIGHBORS_LIMIT_MAX);
2343
2344   bgp_listen_limit_set (bgp, listen_limit);
2345
2346   return CMD_SUCCESS;
2347 }
2348
2349 DEFUN (no_bgp_listen_limit,
2350        no_bgp_listen_limit_cmd,
2351        "no bgp listen limit [(1-5000)]",
2352        "BGP specific commands\n"
2353        "Configure BGP defaults\n"
2354        "unset maximum number of BGP Dynamic Neighbors that can be created\n"
2355        "Configure Dynamic Neighbors listen limit value to default\n"
2356        "Configure Dynamic Neighbors listen limit value\n")
2357 {
2358   VTY_DECLVAR_CONTEXT(bgp, bgp);
2359   bgp_listen_limit_unset (bgp);
2360   return CMD_SUCCESS;
2361 }
2362
2363
2364 /*
2365  * Check if this listen range is already configured. Check for exact
2366  * match or overlap based on input.
2367  */
2368 static struct peer_group *
2369 listen_range_exists (struct bgp *bgp, struct prefix *range, int exact)
2370 {
2371   struct listnode *node, *nnode;
2372   struct listnode *node1, *nnode1;
2373   struct peer_group *group;
2374   struct prefix *lr;
2375   afi_t afi;
2376   int match;
2377
2378   afi = family2afi(range->family);
2379   for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
2380     {
2381       for (ALL_LIST_ELEMENTS (group->listen_range[afi], node1,
2382                               nnode1, lr))
2383         {
2384           if (exact)
2385             match = prefix_same (range, lr);
2386           else
2387             match = (prefix_match (range, lr) || prefix_match (lr, range));
2388           if (match)
2389             return group;
2390         }
2391     }
2392
2393   return NULL;
2394 }
2395
2396 DEFUN (bgp_listen_range,
2397        bgp_listen_range_cmd,
2398        "bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group WORD",
2399        "BGP specific commands\n"
2400        "Configure BGP dynamic neighbors listen range\n"
2401        "Configure BGP dynamic neighbors listen range\n"
2402        NEIGHBOR_ADDR_STR
2403        "Member of the peer-group\n"
2404        "Peer-group name\n")
2405 {
2406   VTY_DECLVAR_CONTEXT(bgp, bgp);
2407   struct prefix range;
2408   struct peer_group *group, *existing_group;
2409   afi_t afi;
2410   int ret;
2411   int idx = 0;
2412
2413   argv_find (argv, argc, "A.B.C.D/M", &idx);
2414   argv_find (argv, argc, "X:X::X:X/M", &idx);
2415   char *prefix = argv[idx]->arg;
2416   argv_find (argv, argc, "WORD", &idx);
2417   char *peergroup = argv[idx]->arg;
2418
2419   /* Convert IP prefix string to struct prefix. */
2420   ret = str2prefix (prefix, &range);
2421   if (! ret)
2422     {
2423       vty_out (vty, "%% Malformed listen range%s", VTY_NEWLINE);
2424       return CMD_WARNING;
2425     }
2426
2427   afi = family2afi(range.family);
2428
2429   if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL (&range.u.prefix6))
2430     {
2431       vty_out (vty, "%% Malformed listen range (link-local address)%s",
2432                VTY_NEWLINE);
2433       return CMD_WARNING;
2434     }
2435
2436   apply_mask (&range);
2437
2438   /* Check if same listen range is already configured. */
2439   existing_group = listen_range_exists (bgp, &range, 1);
2440   if (existing_group)
2441     {
2442       if (strcmp (existing_group->name, peergroup) == 0)
2443         return CMD_SUCCESS;
2444       else
2445         {
2446           vty_out (vty, "%% Same listen range is attached to peer-group %s%s",
2447                    existing_group->name, VTY_NEWLINE);
2448           return CMD_WARNING;
2449         }
2450     }
2451
2452   /* Check if an overlapping listen range exists. */
2453   if (listen_range_exists (bgp, &range, 0))
2454     {
2455       vty_out (vty, "%% Listen range overlaps with existing listen range%s",
2456                VTY_NEWLINE);
2457       return CMD_WARNING;
2458     }
2459
2460   group = peer_group_lookup (bgp, peergroup);
2461   if (! group)
2462     {
2463       vty_out (vty, "%% Configure the peer-group first%s", VTY_NEWLINE);
2464       return CMD_WARNING;
2465     }
2466
2467   ret = peer_group_listen_range_add(group, &range);
2468   return bgp_vty_return (vty, ret);
2469 }
2470
2471 DEFUN (no_bgp_listen_range,
2472        no_bgp_listen_range_cmd,
2473        "no bgp listen range <A.B.C.D/M|X:X::X:X/M> peer-group WORD",
2474        NO_STR
2475        "BGP specific commands\n"
2476        "Unconfigure BGP dynamic neighbors listen range\n"
2477        "Unconfigure BGP dynamic neighbors listen range\n"
2478        NEIGHBOR_ADDR_STR
2479        "Member of the peer-group\n"
2480        "Peer-group name\n")
2481 {
2482   VTY_DECLVAR_CONTEXT(bgp, bgp);
2483   struct prefix range;
2484   struct peer_group *group;
2485   afi_t afi;
2486   int ret;
2487   int idx = 0;
2488
2489   argv_find (argv, argc, "A.B.C.D/M", &idx);
2490   argv_find (argv, argc, "X:X::X:X/M", &idx);
2491   char *prefix = argv[idx]->arg;
2492   argv_find (argv, argc, "WORD", &idx);
2493   char *peergroup = argv[idx]->arg;
2494
2495   // VTY_GET_IPV4_PREFIX ("listen range", range, argv[idx_ipv4_prefixlen]->arg);
2496
2497   /* Convert IP prefix string to struct prefix. */
2498   ret = str2prefix (prefix, &range);
2499   if (! ret)
2500     {
2501       vty_out (vty, "%% Malformed listen range%s", VTY_NEWLINE);
2502       return CMD_WARNING;
2503     }
2504
2505   afi = family2afi(range.family);
2506
2507   if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL (&range.u.prefix6))
2508     {
2509       vty_out (vty, "%% Malformed listen range (link-local address)%s",
2510                VTY_NEWLINE);
2511       return CMD_WARNING;
2512     }
2513
2514   apply_mask (&range);
2515
2516   group = peer_group_lookup (bgp, peergroup);
2517   if (! group)
2518     {
2519       vty_out (vty, "%% Peer-group does not exist%s", VTY_NEWLINE);
2520       return CMD_WARNING;
2521     }
2522
2523   ret = peer_group_listen_range_del(group, &range);
2524   return bgp_vty_return (vty, ret);
2525 }
2526
2527 int
2528 bgp_config_write_listen (struct vty *vty, struct bgp *bgp)
2529 {
2530   struct peer_group *group;
2531   struct listnode *node, *nnode, *rnode, *nrnode;
2532   struct prefix *range;
2533   afi_t afi;
2534   char buf[PREFIX2STR_BUFFER];
2535
2536   if (bgp->dynamic_neighbors_limit != BGP_DYNAMIC_NEIGHBORS_LIMIT_DEFAULT)
2537       vty_out (vty, " bgp listen limit %d%s",
2538                bgp->dynamic_neighbors_limit, VTY_NEWLINE);
2539
2540   for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
2541     {
2542       for (afi = AFI_IP; afi < AFI_MAX; afi++)
2543         {
2544           for (ALL_LIST_ELEMENTS (group->listen_range[afi], rnode, nrnode, range))
2545             {
2546               prefix2str(range, buf, sizeof(buf));
2547               vty_out(vty, " bgp listen range %s peer-group %s%s",
2548                       buf, group->name, VTY_NEWLINE);
2549             }
2550         }
2551     }
2552
2553   return 0;
2554 }
2555
2556
2557 DEFUN (bgp_disable_connected_route_check,
2558        bgp_disable_connected_route_check_cmd,
2559        "bgp disable-ebgp-connected-route-check",
2560        "BGP specific commands\n"
2561        "Disable checking if nexthop is connected on ebgp sessions\n")
2562 {
2563   VTY_DECLVAR_CONTEXT(bgp, bgp);
2564   bgp_flag_set (bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2565   bgp_clear_star_soft_in (vty, bgp->name);
2566
2567   return CMD_SUCCESS;
2568 }
2569
2570 DEFUN (no_bgp_disable_connected_route_check,
2571        no_bgp_disable_connected_route_check_cmd,
2572        "no bgp disable-ebgp-connected-route-check",
2573        NO_STR
2574        "BGP specific commands\n"
2575        "Disable checking if nexthop is connected on ebgp sessions\n")
2576 {
2577   VTY_DECLVAR_CONTEXT(bgp, bgp);
2578   bgp_flag_unset (bgp, BGP_FLAG_DISABLE_NH_CONNECTED_CHK);
2579   bgp_clear_star_soft_in (vty, bgp->name);
2580
2581   return CMD_SUCCESS;
2582 }
2583
2584
2585 static int
2586 peer_remote_as_vty (struct vty *vty, const char *peer_str,
2587                     const char *as_str, afi_t afi, safi_t safi)
2588 {
2589   VTY_DECLVAR_CONTEXT(bgp, bgp);
2590   int ret;
2591   as_t as;
2592   int as_type = AS_SPECIFIED;
2593   union sockunion su;
2594
2595   if (as_str[0] == 'i')
2596     {
2597       as = 0;
2598       as_type = AS_INTERNAL;
2599     }
2600   else if (as_str[0] == 'e')
2601     {
2602       as = 0;
2603       as_type = AS_EXTERNAL;
2604     }
2605   else
2606     {
2607       /* Get AS number.  */
2608       VTY_GET_INTEGER_RANGE ("AS", as, as_str, 1, BGP_AS4_MAX);
2609     }
2610
2611   /* If peer is peer group, call proper function.  */
2612   ret = str2sockunion (peer_str, &su);
2613   if (ret < 0)
2614     {
2615       /* Check for peer by interface */
2616       ret = peer_remote_as (bgp, NULL, peer_str, &as, as_type, afi, safi);
2617       if (ret < 0)
2618         {
2619           ret = peer_group_remote_as (bgp, peer_str, &as, as_type);
2620           if (ret < 0)
2621             {
2622               vty_out (vty, "%% Create the peer-group or interface first%s",
2623                        VTY_NEWLINE);
2624               return CMD_WARNING;
2625             }
2626           return CMD_SUCCESS;
2627         }
2628     }
2629   else
2630     {
2631       if (peer_address_self_check (bgp, &su))
2632         {
2633           vty_out (vty, "%% Can not configure the local system as neighbor%s",
2634                    VTY_NEWLINE);
2635           return CMD_WARNING;
2636         }
2637       ret = peer_remote_as (bgp, &su, NULL, &as, as_type, afi, safi);
2638     }
2639
2640   /* This peer belongs to peer group.  */
2641   switch (ret)
2642     {
2643     case BGP_ERR_PEER_GROUP_MEMBER:
2644       vty_out (vty, "%% Peer-group AS %u. Cannot configure remote-as for member%s", as, VTY_NEWLINE);
2645       return CMD_WARNING;
2646     case BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT:
2647       vty_out (vty, "%% The AS# can not be changed from %u to %s, peer-group members must be all internal or all external%s", as, as_str, VTY_NEWLINE);
2648       return CMD_WARNING;
2649     }
2650   return bgp_vty_return (vty, ret);
2651 }
2652
2653 DEFUN (neighbor_remote_as,
2654        neighbor_remote_as_cmd,
2655        "neighbor <A.B.C.D|X:X::X:X|WORD> remote-as <(1-4294967295)|internal|external>",
2656        NEIGHBOR_STR
2657        NEIGHBOR_ADDR_STR2
2658        "Specify a BGP neighbor\n"
2659        AS_STR
2660        "Internal BGP peer\n"
2661        "External BGP peer\n")
2662 {
2663   int idx_peer = 1;
2664   int idx_remote_as = 3;
2665   return peer_remote_as_vty (vty, argv[idx_peer]->arg, argv[idx_remote_as]->arg, AFI_IP, SAFI_UNICAST);
2666 }
2667
2668 static int
2669 peer_conf_interface_get (struct vty *vty, const char *conf_if, afi_t afi,
2670                          safi_t safi, int v6only, const char *peer_group_name,
2671                          const char *as_str)
2672 {
2673   VTY_DECLVAR_CONTEXT(bgp, bgp);
2674   as_t as = 0;
2675   int as_type = AS_UNSPECIFIED;
2676   struct peer *peer;
2677   struct peer_group *group;
2678   int ret = 0;
2679   union sockunion su;
2680
2681   group = peer_group_lookup (bgp, conf_if);
2682
2683   if (group)
2684     {
2685       vty_out (vty, "%% Name conflict with peer-group %s", VTY_NEWLINE);
2686       return CMD_WARNING;
2687     }
2688
2689   if (as_str)
2690     {
2691       if (as_str[0] == 'i')
2692         {
2693           as_type = AS_INTERNAL;
2694         }
2695       else if (as_str[0] == 'e')
2696         {
2697           as_type = AS_EXTERNAL;
2698         }
2699       else
2700         {
2701           /* Get AS number.  */
2702           VTY_GET_INTEGER_RANGE ("AS", as, as_str, 1, BGP_AS4_MAX);
2703           as_type = AS_SPECIFIED;
2704         }
2705     }
2706
2707   peer = peer_lookup_by_conf_if (bgp, conf_if);
2708   if (!peer)
2709     {
2710       if (bgp_flag_check (bgp, BGP_FLAG_NO_DEFAULT_IPV4)
2711           && afi == AFI_IP && safi == SAFI_UNICAST)
2712         peer = peer_create (NULL, conf_if, bgp, bgp->as, as, as_type, 0, 0,
2713                             NULL);
2714       else
2715         peer = peer_create (NULL, conf_if, bgp, bgp->as, as, as_type, afi, safi,
2716                             NULL);
2717
2718       if (peer && v6only)
2719         SET_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY);
2720
2721       /* Request zebra to initiate IPv6 RAs on this interface. We do this
2722        * any unnumbered peer in order to not worry about run-time transitions
2723        * (e.g., peering is initially IPv4, but the IPv4 /30 or /31 address
2724        * gets deleted later etc.)
2725        */
2726       if (peer->ifp)
2727         {
2728           bgp_zebra_initiate_radv (bgp, peer);
2729         }
2730       peer_flag_set (peer, PEER_FLAG_CAPABILITY_ENHE);
2731     }
2732   else if ((v6only && !CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY)) ||
2733            (!v6only && CHECK_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY)))
2734     {
2735       if (v6only)
2736         SET_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY);
2737       else
2738         UNSET_FLAG(peer->flags, PEER_FLAG_IFPEER_V6ONLY);
2739
2740       /* v6only flag changed. Reset bgp seesion */
2741       if (BGP_IS_VALID_STATE_FOR_NOTIF(peer->status))
2742         {
2743           peer->last_reset = PEER_DOWN_V6ONLY_CHANGE;
2744           bgp_notify_send (peer, BGP_NOTIFY_CEASE,
2745                            BGP_NOTIFY_CEASE_CONFIG_CHANGE);
2746         }
2747       else
2748         bgp_session_reset(peer);
2749     }
2750
2751   if (!peer)
2752     return CMD_WARNING;
2753
2754   if (peer_group_name)
2755     {
2756       group = peer_group_lookup (bgp, peer_group_name);
2757       if (! group)
2758         {
2759           vty_out (vty, "%% Configure the peer-group first%s", VTY_NEWLINE);
2760           return CMD_WARNING;
2761         }
2762
2763       ret = peer_group_bind (bgp, &su, peer, group, &as);
2764     }
2765
2766   return bgp_vty_return (vty, ret);
2767 }
2768
2769 DEFUN (neighbor_interface_config,
2770        neighbor_interface_config_cmd,
2771        "neighbor WORD interface [peer-group WORD]",
2772        NEIGHBOR_STR
2773        "Interface name or neighbor tag\n"
2774        "Enable BGP on interface\n"
2775        "Member of the peer-group\n"
2776        "Peer-group name\n")
2777 {
2778   int idx_word = 1;
2779   int idx_peer_group_word = 4;
2780
2781   if (argc > idx_peer_group_word)
2782     return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 0,
2783                                     argv[idx_peer_group_word]->arg, NULL);
2784   else
2785     return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 0,
2786                                     NULL, NULL);
2787 }
2788
2789 DEFUN (neighbor_interface_config_v6only,
2790        neighbor_interface_config_v6only_cmd,
2791        "neighbor WORD interface v6only [peer-group WORD]",
2792        NEIGHBOR_STR
2793        "Interface name or neighbor tag\n"
2794        "Enable BGP on interface\n"
2795        "Enable BGP with v6 link-local only\n"
2796        "Member of the peer-group\n"
2797        "Peer-group name\n")
2798 {
2799   int idx_word = 1;
2800   int idx_peer_group_word = 5;
2801
2802   if (argc > idx_peer_group_word)
2803     return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 1,
2804                                     argv[idx_peer_group_word]->arg, NULL);
2805
2806   return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 1,
2807                                   NULL, NULL);
2808 }
2809
2810
2811 DEFUN (neighbor_interface_config_remote_as,
2812        neighbor_interface_config_remote_as_cmd,
2813        "neighbor WORD interface remote-as <(1-4294967295)|internal|external>",
2814        NEIGHBOR_STR
2815        "Interface name or neighbor tag\n"
2816        "Enable BGP on interface\n"
2817        "Specify a BGP neighbor\n"
2818        AS_STR
2819        "Internal BGP peer\n"
2820        "External BGP peer\n")
2821 {
2822   int idx_word = 1;
2823   int idx_remote_as = 4;
2824   return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 0,
2825                                   NULL, argv[idx_remote_as]->arg);
2826 }
2827
2828 DEFUN (neighbor_interface_v6only_config_remote_as,
2829        neighbor_interface_v6only_config_remote_as_cmd,
2830        "neighbor WORD interface v6only remote-as <(1-4294967295)|internal|external>",
2831        NEIGHBOR_STR
2832        "Interface name or neighbor tag\n"
2833        "Enable BGP with v6 link-local only\n"
2834        "Enable BGP on interface\n"
2835        "Specify a BGP neighbor\n"
2836        AS_STR
2837        "Internal BGP peer\n"
2838        "External BGP peer\n")
2839 {
2840   int idx_word = 1;
2841   int idx_remote_as = 5;
2842   return peer_conf_interface_get (vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, 1,
2843                                   NULL, argv[idx_remote_as]->arg);
2844 }
2845
2846 DEFUN (neighbor_peer_group,
2847        neighbor_peer_group_cmd,
2848        "neighbor WORD peer-group",
2849        NEIGHBOR_STR
2850        "Interface name or neighbor tag\n"
2851        "Configure peer-group\n")
2852 {
2853   VTY_DECLVAR_CONTEXT(bgp, bgp);
2854   int idx_word = 1;
2855   struct peer *peer;
2856   struct peer_group *group;
2857
2858   peer = peer_lookup_by_conf_if (bgp, argv[idx_word]->arg);
2859   if (peer)
2860     {
2861       vty_out (vty, "%% Name conflict with interface: %s", VTY_NEWLINE);
2862       return CMD_WARNING;
2863     }
2864
2865   group = peer_group_get (bgp, argv[idx_word]->arg);
2866   if (! group)
2867     return CMD_WARNING;
2868
2869   return CMD_SUCCESS;
2870 }
2871
2872 DEFUN (no_neighbor,
2873        no_neighbor_cmd,
2874        "no neighbor <WORD|<A.B.C.D|X:X::X:X> [remote-as <(1-4294967295)|internal|external>]>",
2875        NO_STR
2876        NEIGHBOR_STR
2877        NEIGHBOR_ADDR_STR2
2878        "Specify a BGP neighbor\n"
2879        AS_STR
2880        "Internal BGP peer\n"
2881        "External BGP peer\n")
2882 {
2883   VTY_DECLVAR_CONTEXT(bgp, bgp);
2884   int idx_peer = 2;
2885   int ret;
2886   union sockunion su;
2887   struct peer_group *group;
2888   struct peer *peer;
2889   struct peer *other;
2890
2891   ret = str2sockunion (argv[idx_peer]->arg, &su);
2892   if (ret < 0)
2893     {
2894       /* look up for neighbor by interface name config. */
2895       peer = peer_lookup_by_conf_if (bgp, argv[idx_peer]->arg);
2896       if (peer)
2897         {
2898           /* Request zebra to terminate IPv6 RAs on this interface. */
2899           if (peer->ifp)
2900             bgp_zebra_terminate_radv (peer->bgp, peer);
2901           peer_delete (peer);
2902           return CMD_SUCCESS;
2903         }
2904
2905       group = peer_group_lookup (bgp, argv[idx_peer]->arg);
2906       if (group)
2907         peer_group_delete (group);
2908       else
2909         {
2910           vty_out (vty, "%% Create the peer-group first%s", VTY_NEWLINE);
2911           return CMD_WARNING;
2912         }
2913     }
2914   else
2915     {
2916       peer = peer_lookup (bgp, &su);
2917       if (peer)
2918         {
2919           if (peer_dynamic_neighbor (peer))
2920             {
2921               vty_out (vty, "%% Operation not allowed on a dynamic neighbor%s",
2922                        VTY_NEWLINE);
2923               return CMD_WARNING;
2924             }
2925
2926           other = peer->doppelganger;
2927           peer_delete (peer);
2928           if (other && other->status != Deleted)
2929             peer_delete(other);
2930         }
2931     }
2932
2933   return CMD_SUCCESS;
2934 }
2935
2936 DEFUN (no_neighbor_interface_config,
2937        no_neighbor_interface_config_cmd,
2938        "no neighbor WORD interface [v6only] [peer-group WORD] [remote-as <(1-4294967295)|internal|external>]",
2939        NO_STR
2940        NEIGHBOR_STR
2941        "Interface name\n"
2942        "Configure BGP on interface\n"
2943        "Enable BGP with v6 link-local only\n"
2944        "Member of the peer-group\n"
2945        "Peer-group name\n"
2946        "Specify a BGP neighbor\n"
2947        AS_STR
2948        "Internal BGP peer\n"
2949        "External BGP peer\n")
2950 {
2951   VTY_DECLVAR_CONTEXT(bgp, bgp);
2952   int idx_word = 2;
2953   struct peer *peer;
2954
2955   /* look up for neighbor by interface name config. */
2956   peer = peer_lookup_by_conf_if (bgp, argv[idx_word]->arg);
2957   if (peer)
2958     {
2959       /* Request zebra to terminate IPv6 RAs on this interface. */
2960       if (peer->ifp)
2961         bgp_zebra_terminate_radv (peer->bgp, peer);
2962       peer_delete (peer);
2963     }
2964   else
2965     {
2966       vty_out (vty, "%% Create the bgp interface first%s", VTY_NEWLINE);
2967       return CMD_WARNING;
2968     }
2969   return CMD_SUCCESS;
2970 }
2971
2972 DEFUN (no_neighbor_peer_group,
2973        no_neighbor_peer_group_cmd,
2974        "no neighbor WORD peer-group",
2975        NO_STR
2976        NEIGHBOR_STR
2977        "Neighbor tag\n"
2978        "Configure peer-group\n")
2979 {
2980   VTY_DECLVAR_CONTEXT(bgp, bgp);
2981   int idx_word = 2;
2982   struct peer_group *group;
2983
2984   group = peer_group_lookup (bgp, argv[idx_word]->arg);
2985   if (group)
2986     peer_group_delete (group);
2987   else
2988     {
2989       vty_out (vty, "%% Create the peer-group first%s", VTY_NEWLINE);
2990       return CMD_WARNING;
2991     }
2992   return CMD_SUCCESS;
2993 }
2994
2995 DEFUN (no_neighbor_interface_peer_group_remote_as,
2996        no_neighbor_interface_peer_group_remote_as_cmd,
2997        "no neighbor WORD remote-as <(1-4294967295)|internal|external>",
2998        NO_STR
2999        NEIGHBOR_STR
3000        "Interface name or neighbor tag\n"
3001        "Specify a BGP neighbor\n"
3002        AS_STR
3003        "Internal BGP peer\n"
3004        "External BGP peer\n")
3005 {
3006   VTY_DECLVAR_CONTEXT(bgp, bgp);
3007   int idx_word = 2;
3008   struct peer_group *group;
3009   struct peer *peer;
3010
3011   /* look up for neighbor by interface name config. */
3012   peer = peer_lookup_by_conf_if (bgp, argv[idx_word]->arg);
3013   if (peer)
3014     {
3015       peer_as_change (peer, 0, AS_SPECIFIED);
3016       return CMD_SUCCESS;
3017     }
3018
3019   group = peer_group_lookup (bgp, argv[idx_word]->arg);
3020   if (group)
3021     peer_group_remote_as_delete (group);
3022   else
3023     {
3024       vty_out (vty, "%% Create the peer-group or interface first%s", VTY_NEWLINE);
3025       return CMD_WARNING;
3026     }
3027   return CMD_SUCCESS;
3028 }
3029
3030 DEFUN (neighbor_local_as,
3031        neighbor_local_as_cmd,
3032        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295)",
3033        NEIGHBOR_STR
3034        NEIGHBOR_ADDR_STR2
3035        "Specify a local-as number\n"
3036        "AS number used as local AS\n")
3037 {
3038   int idx_peer = 1;
3039   int idx_number = 3;
3040   struct peer *peer;
3041   int ret;
3042   as_t as;
3043
3044   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3045   if (! peer)
3046     return CMD_WARNING;
3047
3048   VTY_GET_INTEGER_RANGE ("Local AS", as, argv[idx_number]->arg, 1, BGP_AS4_MAX);
3049   ret = peer_local_as_set (peer, as, 0, 0);
3050   return bgp_vty_return (vty, ret);
3051 }
3052
3053 DEFUN (neighbor_local_as_no_prepend,
3054        neighbor_local_as_no_prepend_cmd,
3055        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend",
3056        NEIGHBOR_STR
3057        NEIGHBOR_ADDR_STR2
3058        "Specify a local-as number\n"
3059        "AS number used as local AS\n"
3060        "Do not prepend local-as to updates from ebgp peers\n")
3061 {
3062   int idx_peer = 1;
3063   int idx_number = 3;
3064   struct peer *peer;
3065   int ret;
3066   as_t as;
3067
3068   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3069   if (! peer)
3070     return CMD_WARNING;
3071
3072   VTY_GET_INTEGER_RANGE ("Local AS", as, argv[idx_number]->arg, 1, BGP_AS4_MAX);
3073   ret = peer_local_as_set (peer, as, 1, 0);
3074   return bgp_vty_return (vty, ret);
3075 }
3076
3077 DEFUN (neighbor_local_as_no_prepend_replace_as,
3078        neighbor_local_as_no_prepend_replace_as_cmd,
3079        "neighbor <A.B.C.D|X:X::X:X|WORD> local-as (1-4294967295) no-prepend replace-as",
3080        NEIGHBOR_STR
3081        NEIGHBOR_ADDR_STR2
3082        "Specify a local-as number\n"
3083        "AS number used as local AS\n"
3084        "Do not prepend local-as to updates from ebgp peers\n"
3085        "Do not prepend local-as to updates from ibgp peers\n")
3086 {
3087   int idx_peer = 1;
3088   int idx_number = 3;
3089   struct peer *peer;
3090   int ret;
3091   as_t as;
3092
3093   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3094   if (! peer)
3095     return CMD_WARNING;
3096
3097   VTY_GET_INTEGER_RANGE ("Local AS", as, argv[idx_number]->arg, 1, BGP_AS4_MAX);
3098   ret = peer_local_as_set (peer, as, 1, 1);
3099   return bgp_vty_return (vty, ret);
3100 }
3101
3102 DEFUN (no_neighbor_local_as,
3103        no_neighbor_local_as_cmd,
3104        "no neighbor <A.B.C.D|X:X::X:X|WORD> local-as [(1-4294967295) [no-prepend [replace-as]]]",
3105        NO_STR
3106        NEIGHBOR_STR
3107        NEIGHBOR_ADDR_STR2
3108        "Specify a local-as number\n"
3109        "AS number used as local AS\n"
3110        "Do not prepend local-as to updates from ebgp peers\n"
3111        "Do not prepend local-as to updates from ibgp peers\n")
3112 {
3113   int idx_peer = 2;
3114   struct peer *peer;
3115   int ret;
3116
3117   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3118   if (! peer)
3119     return CMD_WARNING;
3120
3121   ret = peer_local_as_unset (peer);
3122   return bgp_vty_return (vty, ret);
3123 }
3124
3125
3126
3127
3128 DEFUN (neighbor_solo,
3129        neighbor_solo_cmd,
3130        "neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3131        NEIGHBOR_STR
3132        NEIGHBOR_ADDR_STR2
3133        "Solo peer - part of its own update group\n")
3134 {
3135   int idx_peer = 1;
3136   struct peer *peer;
3137   int ret;
3138
3139   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3140   if (! peer)
3141     return CMD_WARNING;
3142
3143   ret = update_group_adjust_soloness(peer, 1);
3144   return bgp_vty_return (vty, ret);
3145 }
3146
3147 DEFUN (no_neighbor_solo,
3148        no_neighbor_solo_cmd,
3149        "no neighbor <A.B.C.D|X:X::X:X|WORD> solo",
3150        NO_STR
3151        NEIGHBOR_STR
3152        NEIGHBOR_ADDR_STR2
3153        "Solo peer - part of its own update group\n")
3154 {
3155   int idx_peer = 2;
3156   struct peer *peer;
3157   int ret;
3158
3159   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3160   if (! peer)
3161     return CMD_WARNING;
3162
3163   ret = update_group_adjust_soloness(peer, 0);
3164   return bgp_vty_return (vty, ret);
3165 }
3166
3167 DEFUN (neighbor_password,
3168        neighbor_password_cmd,
3169        "neighbor <A.B.C.D|X:X::X:X|WORD> password LINE",
3170        NEIGHBOR_STR
3171        NEIGHBOR_ADDR_STR2
3172        "Set a password\n"
3173        "The password\n")
3174 {
3175   int idx_peer = 1;
3176   int idx_line = 3;
3177   struct peer *peer;
3178   int ret;
3179
3180   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3181   if (! peer)
3182     return CMD_WARNING;
3183
3184   ret = peer_password_set (peer, argv[idx_line]->arg);
3185   return bgp_vty_return (vty, ret);
3186 }
3187
3188 DEFUN (no_neighbor_password,
3189        no_neighbor_password_cmd,
3190        "no neighbor <A.B.C.D|X:X::X:X|WORD> password [LINE]",
3191        NO_STR
3192        NEIGHBOR_STR
3193        NEIGHBOR_ADDR_STR2
3194        "Set a password\n"
3195        "The password\n")
3196 {
3197   int idx_peer = 2;
3198   struct peer *peer;
3199   int ret;
3200
3201   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3202   if (! peer)
3203     return CMD_WARNING;
3204
3205   ret = peer_password_unset (peer);
3206   return bgp_vty_return (vty, ret);
3207 }
3208
3209
3210 DEFUN (neighbor_activate,
3211        neighbor_activate_cmd,
3212        "neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3213        NEIGHBOR_STR
3214        NEIGHBOR_ADDR_STR2
3215        "Enable the Address Family for this Neighbor\n")
3216 {
3217   int idx_peer = 1;
3218   int ret;
3219   struct peer *peer;
3220
3221   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3222   if (! peer)
3223     return CMD_WARNING;
3224
3225   ret = peer_activate (peer, bgp_node_afi (vty), bgp_node_safi (vty));
3226
3227   if (ret)
3228     return CMD_WARNING;
3229   return CMD_SUCCESS;
3230 }
3231
3232 DEFUN (no_neighbor_activate,
3233        no_neighbor_activate_cmd,
3234        "no neighbor <A.B.C.D|X:X::X:X|WORD> activate",
3235        NO_STR
3236        NEIGHBOR_STR
3237        NEIGHBOR_ADDR_STR2
3238        "Enable the Address Family for this Neighbor\n")
3239 {
3240   int idx_peer = 2;
3241   int ret;
3242   struct peer *peer;
3243
3244   /* Lookup peer. */
3245   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3246   if (! peer)
3247     return CMD_WARNING;
3248
3249   ret = peer_deactivate (peer, bgp_node_afi (vty), bgp_node_safi (vty));
3250
3251   if (ret)
3252     return CMD_WARNING;
3253   return CMD_SUCCESS;
3254 }
3255
3256 DEFUN (neighbor_set_peer_group,
3257        neighbor_set_peer_group_cmd,
3258        "neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3259        NEIGHBOR_STR
3260        NEIGHBOR_ADDR_STR2
3261        "Member of the peer-group\n"
3262        "Peer-group name\n")
3263 {
3264   VTY_DECLVAR_CONTEXT(bgp, bgp);
3265   int idx_peer = 1;
3266   int idx_word = 3;
3267   int ret;
3268   as_t as;
3269   union sockunion su;
3270   struct peer *peer;
3271   struct peer_group *group;
3272
3273   peer = NULL;
3274
3275   ret = str2sockunion (argv[idx_peer]->arg, &su);
3276   if (ret < 0)
3277     {
3278       peer = peer_lookup_by_conf_if (bgp, argv[idx_peer]->arg);
3279       if (!peer)
3280         {
3281           vty_out (vty, "%% Malformed address or name: %s%s", argv[idx_peer]->arg, VTY_NEWLINE);
3282           return CMD_WARNING;
3283         }
3284     }
3285   else
3286     {
3287       if (peer_address_self_check (bgp, &su))
3288         {
3289           vty_out (vty, "%% Can not configure the local system as neighbor%s",
3290                    VTY_NEWLINE);
3291           return CMD_WARNING;
3292         }
3293
3294       /* Disallow for dynamic neighbor. */
3295       peer = peer_lookup (bgp, &su);
3296       if (peer && peer_dynamic_neighbor (peer))
3297         {
3298           vty_out (vty, "%% Operation not allowed on a dynamic neighbor%s",
3299                    VTY_NEWLINE);
3300           return CMD_WARNING;
3301         }
3302     }
3303
3304   group = peer_group_lookup (bgp, argv[idx_word]->arg);
3305   if (! group)
3306     {
3307       vty_out (vty, "%% Configure the peer-group first%s", VTY_NEWLINE);
3308       return CMD_WARNING;
3309     }
3310
3311   ret = peer_group_bind (bgp, &su, peer, group, &as);
3312
3313   if (ret == BGP_ERR_PEER_GROUP_PEER_TYPE_DIFFERENT)
3314     {
3315       vty_out (vty, "%% Peer with AS %u cannot be in this peer-group, members must be all internal or all external%s", as, VTY_NEWLINE);
3316       return CMD_WARNING;
3317     }
3318
3319   return bgp_vty_return (vty, ret);
3320 }
3321
3322 DEFUN (no_neighbor_set_peer_group,
3323        no_neighbor_set_peer_group_cmd,
3324        "no neighbor <A.B.C.D|X:X::X:X|WORD> peer-group WORD",
3325        NO_STR
3326        NEIGHBOR_STR
3327        NEIGHBOR_ADDR_STR2
3328        "Member of the peer-group\n"
3329        "Peer-group name\n")
3330 {
3331   VTY_DECLVAR_CONTEXT(bgp, bgp);
3332   int idx_peer = 2;
3333   int idx_word = 4;
3334   int ret;
3335   struct peer *peer;
3336   struct peer_group *group;
3337
3338   peer = peer_lookup_vty (vty, argv[idx_peer]->arg);
3339   if (! peer)
3340     return CMD_WARNING;
3341
3342   group = peer_group_lookup (bgp, argv[idx_word]->arg);
3343   if (! group)
3344     {
3345       vty_out (vty, "%% Configure the peer-group first%s", VTY_NEWLINE);
3346       return CMD_WARNING;
3347     }
3348
3349   ret = peer_group_unbind (bgp, peer, group);
3350
3351   return bgp_vty_return (vty, ret);
3352 }
3353
3354 static int
3355 peer_flag_modify_vty (struct vty *vty, const char *ip_str,
3356                       u_int16_t flag, int set)
3357 {
3358   int ret;
3359   struct peer *peer;
3360
3361   peer = peer_and_group_lookup_vty (vty, ip_str);
3362   if (! peer)
3363     return CMD_WARNING;
3364
3365   /*
3366    * If 'neighbor <interface>', then this is for directly connected peers,
3367    * we should not accept disable-connected-check.
3368    */
3369   if (peer->conf_if && (flag == PEER_FLAG_DISABLE_CONNECTED_CHECK)) {
3370     vty_out (vty, "%s is directly connected peer, cannot accept disable-"
3371                   "connected-check%s", ip_str, VTY_NEWLINE);
3372     return CMD_WARNING;
3373   }
3374
3375   if (set)
3376     ret = peer_flag_set (peer, flag);
3377   else
3378     ret = peer_flag_unset (peer, flag);
3379
3380   return bgp_vty_return (vty, ret);
3381 }
3382
3383 static int
3384 peer_flag_set_vty (struct vty *vty, const char *ip_str, u_int16_t flag)
3385 {
3386   return peer_flag_modify_vty (vty, ip_str, flag, 1);
3387 }
3388
3389 static int
3390 peer_flag_unset_vty (struct vty *vty, const char *ip_str, u_int16_t flag)
3391 {
3392   return peer_flag_modify_vty (vty, ip_str, flag, 0);
3393 }
3394
3395 /* neighbor passive. */
3396 DEFUN (neighbor_passive,
3397        neighbor_passive_cmd,
3398        "neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3399        NEIGHBOR_STR
3400        NEIGHBOR_ADDR_STR2
3401        "Don't send open messages to this neighbor\n")
3402 {
3403   int idx_peer = 1;
3404   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3405 }
3406
3407 DEFUN (no_neighbor_passive,
3408        no_neighbor_passive_cmd,
3409        "no neighbor <A.B.C.D|X:X::X:X|WORD> passive",
3410        NO_STR
3411        NEIGHBOR_STR
3412        NEIGHBOR_ADDR_STR2
3413        "Don't send open messages to this neighbor\n")
3414 {
3415   int idx_peer = 2;
3416   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_PASSIVE);
3417 }
3418
3419 /* neighbor shutdown. */
3420 DEFUN (neighbor_shutdown_msg,
3421        neighbor_shutdown_msg_cmd,
3422        "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3423        NEIGHBOR_STR
3424        NEIGHBOR_ADDR_STR2
3425        "Administratively shut down this neighbor\n"
3426        "Add a shutdown message (draft-ietf-idr-shutdown-06)\n"
3427        "Shutdown message\n")
3428 {
3429   int idx_peer = 1;
3430
3431   if (argc >= 5)
3432     {
3433       struct peer *peer = peer_lookup_vty (vty, argv[idx_peer]->arg);
3434       char *message;
3435
3436       message = argv_concat (argv, argc, 4);
3437       peer_tx_shutdown_message_set (peer, message);
3438       XFREE (MTYPE_TMP, message);
3439     }
3440
3441   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
3442 }
3443
3444 ALIAS (neighbor_shutdown_msg,
3445        neighbor_shutdown_cmd,
3446        "neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3447        NEIGHBOR_STR
3448        NEIGHBOR_ADDR_STR2
3449        "Administratively shut down this neighbor\n")
3450
3451 DEFUN (no_neighbor_shutdown_msg,
3452        no_neighbor_shutdown_msg_cmd,
3453        "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown message MSG...",
3454        NO_STR
3455        NEIGHBOR_STR
3456        NEIGHBOR_ADDR_STR2
3457        "Administratively shut down this neighbor\n"
3458        "Remove a shutdown message (draft-ietf-idr-shutdown-06)\n"
3459        "Shutdown message\n")
3460 {
3461   int idx_peer = 2;
3462
3463   struct peer *peer = peer_lookup_vty (vty, argv[idx_peer]->arg);
3464   peer_tx_shutdown_message_unset (peer);
3465
3466   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_SHUTDOWN);
3467 }
3468
3469 ALIAS (no_neighbor_shutdown_msg,
3470        no_neighbor_shutdown_cmd,
3471        "no neighbor <A.B.C.D|X:X::X:X|WORD> shutdown",
3472        NO_STR
3473        NEIGHBOR_STR
3474        NEIGHBOR_ADDR_STR2
3475        "Administratively shut down this neighbor\n")
3476
3477 /* neighbor capability dynamic. */
3478 DEFUN (neighbor_capability_dynamic,
3479        neighbor_capability_dynamic_cmd,
3480        "neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3481        NEIGHBOR_STR
3482        NEIGHBOR_ADDR_STR2
3483        "Advertise capability to the peer\n"
3484        "Advertise dynamic capability to this neighbor\n")
3485 {
3486   int idx_peer = 1;
3487   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DYNAMIC_CAPABILITY);
3488 }
3489
3490 DEFUN (no_neighbor_capability_dynamic,
3491        no_neighbor_capability_dynamic_cmd,
3492        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability dynamic",
3493        NO_STR
3494        NEIGHBOR_STR
3495        NEIGHBOR_ADDR_STR2
3496        "Advertise capability to the peer\n"
3497        "Advertise dynamic capability to this neighbor\n")
3498 {
3499   int idx_peer = 2;
3500   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DYNAMIC_CAPABILITY);
3501 }
3502
3503 /* neighbor dont-capability-negotiate */
3504 DEFUN (neighbor_dont_capability_negotiate,
3505        neighbor_dont_capability_negotiate_cmd,
3506        "neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3507        NEIGHBOR_STR
3508        NEIGHBOR_ADDR_STR2
3509        "Do not perform capability negotiation\n")
3510 {
3511   int idx_peer = 1;
3512   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DONT_CAPABILITY);
3513 }
3514
3515 DEFUN (no_neighbor_dont_capability_negotiate,
3516        no_neighbor_dont_capability_negotiate_cmd,
3517        "no neighbor <A.B.C.D|X:X::X:X|WORD> dont-capability-negotiate",
3518        NO_STR
3519        NEIGHBOR_STR
3520        NEIGHBOR_ADDR_STR2
3521        "Do not perform capability negotiation\n")
3522 {
3523   int idx_peer = 2;
3524   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DONT_CAPABILITY);
3525 }
3526
3527 /* neighbor capability extended next hop encoding */
3528 DEFUN (neighbor_capability_enhe,
3529        neighbor_capability_enhe_cmd,
3530        "neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3531        NEIGHBOR_STR
3532        NEIGHBOR_ADDR_STR2
3533        "Advertise capability to the peer\n"
3534        "Advertise extended next-hop capability to the peer\n")
3535 {
3536   int idx_peer = 1;
3537   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_CAPABILITY_ENHE);
3538 }
3539
3540 DEFUN (no_neighbor_capability_enhe,
3541        no_neighbor_capability_enhe_cmd,
3542        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability extended-nexthop",
3543        NO_STR
3544        NEIGHBOR_STR
3545        NEIGHBOR_ADDR_STR2
3546        "Advertise capability to the peer\n"
3547        "Advertise extended next-hop capability to the peer\n")
3548 {
3549   int idx_peer = 2;
3550   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_CAPABILITY_ENHE);
3551 }
3552
3553 static int
3554 peer_af_flag_modify_vty (struct vty *vty, const char *peer_str, afi_t afi,
3555                          safi_t safi, u_int32_t flag, int set)
3556 {
3557   int ret;
3558   struct peer *peer;
3559
3560   peer = peer_and_group_lookup_vty (vty, peer_str);
3561   if (! peer)
3562     return CMD_WARNING;
3563
3564   if (set)
3565     ret = peer_af_flag_set (peer, afi, safi, flag);
3566   else
3567     ret = peer_af_flag_unset (peer, afi, safi, flag);
3568
3569   return bgp_vty_return (vty, ret);
3570 }
3571
3572 static int
3573 peer_af_flag_set_vty (struct vty *vty, const char *peer_str, afi_t afi,
3574                       safi_t safi, u_int32_t flag)
3575 {
3576   return peer_af_flag_modify_vty (vty, peer_str, afi, safi, flag, 1);
3577 }
3578
3579 static int
3580 peer_af_flag_unset_vty (struct vty *vty, const char *peer_str, afi_t afi,
3581                         safi_t safi, u_int32_t flag)
3582 {
3583   return peer_af_flag_modify_vty (vty, peer_str, afi, safi, flag, 0);
3584 }
3585
3586 /* neighbor capability orf prefix-list. */
3587 DEFUN (neighbor_capability_orf_prefix,
3588        neighbor_capability_orf_prefix_cmd,
3589        "neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3590        NEIGHBOR_STR
3591        NEIGHBOR_ADDR_STR2
3592        "Advertise capability to the peer\n"
3593        "Advertise ORF capability to the peer\n"
3594        "Advertise prefixlist ORF capability to this neighbor\n"
3595        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3596        "Capability to RECEIVE the ORF from this neighbor\n"
3597        "Capability to SEND the ORF to this neighbor\n")
3598 {
3599   int idx_peer = 1;
3600   int idx_send_recv = 5;
3601   u_int16_t flag = 0;
3602
3603   if (strncmp (argv[idx_send_recv]->arg, "s", 1) == 0)
3604     flag = PEER_FLAG_ORF_PREFIX_SM;
3605   else if (strncmp (argv[idx_send_recv]->arg, "r", 1) == 0)
3606     flag = PEER_FLAG_ORF_PREFIX_RM;
3607   else if (strncmp (argv[idx_send_recv]->arg, "b", 1) == 0)
3608     flag = PEER_FLAG_ORF_PREFIX_SM|PEER_FLAG_ORF_PREFIX_RM;
3609   else
3610     return CMD_WARNING;
3611
3612   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3613                                bgp_node_safi (vty), flag);
3614 }
3615
3616 DEFUN (no_neighbor_capability_orf_prefix,
3617        no_neighbor_capability_orf_prefix_cmd,
3618        "no neighbor <A.B.C.D|X:X::X:X|WORD> capability orf prefix-list <both|send|receive>",
3619        NO_STR
3620        NEIGHBOR_STR
3621        NEIGHBOR_ADDR_STR2
3622        "Advertise capability to the peer\n"
3623        "Advertise ORF capability to the peer\n"
3624        "Advertise prefixlist ORF capability to this neighbor\n"
3625        "Capability to SEND and RECEIVE the ORF to/from this neighbor\n"
3626        "Capability to RECEIVE the ORF from this neighbor\n"
3627        "Capability to SEND the ORF to this neighbor\n")
3628 {
3629   int idx_peer = 2;
3630   int idx_send_recv = 6;
3631   u_int16_t flag = 0;
3632
3633   if (strncmp (argv[idx_send_recv]->arg, "s", 1) == 0)
3634     flag = PEER_FLAG_ORF_PREFIX_SM;
3635   else if (strncmp (argv[idx_send_recv]->arg, "r", 1) == 0)
3636     flag = PEER_FLAG_ORF_PREFIX_RM;
3637   else if (strncmp (argv[idx_send_recv]->arg, "b", 1) == 0)
3638     flag = PEER_FLAG_ORF_PREFIX_SM|PEER_FLAG_ORF_PREFIX_RM;
3639   else
3640     return CMD_WARNING;
3641
3642   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3643                                  bgp_node_safi (vty), flag);
3644 }
3645
3646 /* neighbor next-hop-self. */
3647 DEFUN (neighbor_nexthop_self,
3648        neighbor_nexthop_self_cmd,
3649        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3650        NEIGHBOR_STR
3651        NEIGHBOR_ADDR_STR2
3652        "Disable the next hop calculation for this neighbor\n")
3653 {
3654   int idx_peer = 1;
3655   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3656                                bgp_node_safi (vty), PEER_FLAG_NEXTHOP_SELF);
3657 }
3658
3659 /* neighbor next-hop-self. */
3660 DEFUN (neighbor_nexthop_self_force,
3661        neighbor_nexthop_self_force_cmd,
3662        "neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3663        NEIGHBOR_STR
3664        NEIGHBOR_ADDR_STR2
3665        "Disable the next hop calculation for this neighbor\n"
3666        "Set the next hop to self for reflected routes\n")
3667 {
3668   int idx_peer = 1;
3669   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3670                                bgp_node_safi (vty),
3671                                PEER_FLAG_FORCE_NEXTHOP_SELF);
3672 }
3673
3674 DEFUN (no_neighbor_nexthop_self,
3675        no_neighbor_nexthop_self_cmd,
3676        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self",
3677        NO_STR
3678        NEIGHBOR_STR
3679        NEIGHBOR_ADDR_STR2
3680        "Disable the next hop calculation for this neighbor\n")
3681 {
3682   int idx_peer = 2;
3683   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3684                                  bgp_node_safi (vty),
3685                                  PEER_FLAG_NEXTHOP_SELF);
3686 }
3687
3688 DEFUN (no_neighbor_nexthop_self_force,
3689        no_neighbor_nexthop_self_force_cmd,
3690        "no neighbor <A.B.C.D|X:X::X:X|WORD> next-hop-self force",
3691        NO_STR
3692        NEIGHBOR_STR
3693        NEIGHBOR_ADDR_STR2
3694        "Disable the next hop calculation for this neighbor\n"
3695        "Set the next hop to self for reflected routes\n")
3696 {
3697   int idx_peer = 2;
3698   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3699                                  bgp_node_safi (vty),
3700                                  PEER_FLAG_FORCE_NEXTHOP_SELF);
3701 }
3702
3703 /* neighbor as-override */
3704 DEFUN (neighbor_as_override,
3705        neighbor_as_override_cmd,
3706        "neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3707        NEIGHBOR_STR
3708        NEIGHBOR_ADDR_STR2
3709        "Override ASNs in outbound updates if aspath equals remote-as\n")
3710 {
3711   int idx_peer = 1;
3712   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3713                                bgp_node_safi (vty),
3714                                PEER_FLAG_AS_OVERRIDE);
3715 }
3716
3717 DEFUN (no_neighbor_as_override,
3718        no_neighbor_as_override_cmd,
3719        "no neighbor <A.B.C.D|X:X::X:X|WORD> as-override",
3720        NO_STR
3721        NEIGHBOR_STR
3722        NEIGHBOR_ADDR_STR2
3723        "Override ASNs in outbound updates if aspath equals remote-as\n")
3724 {
3725   int idx_peer = 2;
3726   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3727                                  bgp_node_safi (vty),
3728                                  PEER_FLAG_AS_OVERRIDE);
3729 }
3730
3731 /* neighbor remove-private-AS. */
3732 DEFUN (neighbor_remove_private_as,
3733        neighbor_remove_private_as_cmd,
3734        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3735        NEIGHBOR_STR
3736        NEIGHBOR_ADDR_STR2
3737        "Remove private ASNs in outbound updates\n")
3738 {
3739   int idx_peer = 1;
3740   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3741                                bgp_node_safi (vty),
3742                                PEER_FLAG_REMOVE_PRIVATE_AS);
3743 }
3744
3745 DEFUN (neighbor_remove_private_as_all,
3746        neighbor_remove_private_as_all_cmd,
3747        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
3748        NEIGHBOR_STR
3749        NEIGHBOR_ADDR_STR2
3750        "Remove private ASNs in outbound updates\n"
3751        "Apply to all AS numbers")
3752 {
3753   int idx_peer = 1;
3754   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3755                                bgp_node_safi (vty),
3756                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
3757 }
3758
3759 DEFUN (neighbor_remove_private_as_replace_as,
3760        neighbor_remove_private_as_replace_as_cmd,
3761        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
3762        NEIGHBOR_STR
3763        NEIGHBOR_ADDR_STR2
3764        "Remove private ASNs in outbound updates\n"
3765        "Replace private ASNs with our ASN in outbound updates\n")
3766 {
3767   int idx_peer = 1;
3768   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3769                                bgp_node_safi (vty),
3770                                PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
3771 }
3772
3773 DEFUN (neighbor_remove_private_as_all_replace_as,
3774        neighbor_remove_private_as_all_replace_as_cmd,
3775        "neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
3776        NEIGHBOR_STR
3777        NEIGHBOR_ADDR_STR2
3778        "Remove private ASNs in outbound updates\n"
3779        "Apply to all AS numbers\n"
3780        "Replace private ASNs with our ASN in outbound updates\n")
3781 {
3782   int idx_peer = 1;
3783   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3784                                bgp_node_safi (vty),
3785                                PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
3786 }
3787
3788 DEFUN (no_neighbor_remove_private_as,
3789        no_neighbor_remove_private_as_cmd,
3790        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS",
3791        NO_STR
3792        NEIGHBOR_STR
3793        NEIGHBOR_ADDR_STR2
3794        "Remove private ASNs in outbound updates\n")
3795 {
3796   int idx_peer = 2;
3797   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3798                                  bgp_node_safi (vty),
3799                                  PEER_FLAG_REMOVE_PRIVATE_AS);
3800 }
3801
3802 DEFUN (no_neighbor_remove_private_as_all,
3803        no_neighbor_remove_private_as_all_cmd,
3804        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all",
3805        NO_STR
3806        NEIGHBOR_STR
3807        NEIGHBOR_ADDR_STR2
3808        "Remove private ASNs in outbound updates\n"
3809        "Apply to all AS numbers\n")
3810 {
3811   int idx_peer = 2;
3812   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3813                                  bgp_node_safi (vty),
3814                                  PEER_FLAG_REMOVE_PRIVATE_AS_ALL);
3815 }
3816
3817 DEFUN (no_neighbor_remove_private_as_replace_as,
3818        no_neighbor_remove_private_as_replace_as_cmd,
3819        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS replace-AS",
3820        NO_STR
3821        NEIGHBOR_STR
3822        NEIGHBOR_ADDR_STR2
3823        "Remove private ASNs in outbound updates\n"
3824        "Replace private ASNs with our ASN in outbound updates\n")
3825 {
3826   int idx_peer = 2;
3827   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3828                                  bgp_node_safi (vty),
3829                                  PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE);
3830 }
3831
3832 DEFUN (no_neighbor_remove_private_as_all_replace_as,
3833        no_neighbor_remove_private_as_all_replace_as_cmd,
3834        "no neighbor <A.B.C.D|X:X::X:X|WORD> remove-private-AS all replace-AS",
3835        NO_STR
3836        NEIGHBOR_STR
3837        NEIGHBOR_ADDR_STR2
3838        "Remove private ASNs in outbound updates\n"
3839        "Apply to all AS numbers\n"
3840        "Replace private ASNs with our ASN in outbound updates\n")
3841 {
3842   int idx_peer = 2;
3843   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3844                                  bgp_node_safi (vty),
3845                                  PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE);
3846 }
3847
3848
3849 /* neighbor send-community. */
3850 DEFUN (neighbor_send_community,
3851        neighbor_send_community_cmd,
3852        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
3853        NEIGHBOR_STR
3854        NEIGHBOR_ADDR_STR2
3855        "Send Community attribute to 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),
3860                                PEER_FLAG_SEND_COMMUNITY);
3861 }
3862
3863 DEFUN (no_neighbor_send_community,
3864        no_neighbor_send_community_cmd,
3865        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community",
3866        NO_STR
3867        NEIGHBOR_STR
3868        NEIGHBOR_ADDR_STR2
3869        "Send Community attribute to this neighbor\n")
3870 {
3871   int idx_peer = 2;
3872   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3873                                  bgp_node_safi (vty),
3874                                  PEER_FLAG_SEND_COMMUNITY);
3875 }
3876
3877 /* neighbor send-community extended. */
3878 DEFUN (neighbor_send_community_type,
3879        neighbor_send_community_type_cmd,
3880        "neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
3881        NEIGHBOR_STR
3882        NEIGHBOR_ADDR_STR2
3883        "Send Community attribute to this neighbor\n"
3884        "Send Standard and Extended Community attributes\n"
3885        "Send Standard, Large and Extended Community attributes\n"
3886        "Send Extended Community attributes\n"
3887        "Send Standard Community attributes\n"
3888        "Send Large Community attributes\n")
3889 {
3890   int idx = 0;
3891   u_int32_t flag = 0;
3892
3893   char *peer = argv[1]->arg;
3894
3895   if (argv_find (argv, argc, "standard", &idx))
3896     SET_FLAG (flag, PEER_FLAG_SEND_COMMUNITY);
3897   else if (argv_find (argv, argc, "extended", &idx))
3898     SET_FLAG (flag, PEER_FLAG_SEND_EXT_COMMUNITY);
3899   else if (argv_find (argv, argc, "large", &idx))
3900     SET_FLAG (flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
3901   else if (argv_find (argv, argc, "both", &idx))
3902     {
3903       SET_FLAG (flag, PEER_FLAG_SEND_COMMUNITY);
3904       SET_FLAG (flag, PEER_FLAG_SEND_EXT_COMMUNITY);
3905     }
3906   else
3907     {
3908       SET_FLAG (flag, PEER_FLAG_SEND_COMMUNITY);
3909       SET_FLAG (flag, PEER_FLAG_SEND_EXT_COMMUNITY);
3910       SET_FLAG (flag, PEER_FLAG_SEND_LARGE_COMMUNITY);
3911     }
3912
3913   return peer_af_flag_set_vty (vty, peer, bgp_node_afi (vty), bgp_node_safi (vty), flag);
3914 }
3915
3916 DEFUN (no_neighbor_send_community_type,
3917        no_neighbor_send_community_type_cmd,
3918        "no neighbor <A.B.C.D|X:X::X:X|WORD> send-community <both|all|extended|standard|large>",
3919        NO_STR
3920        NEIGHBOR_STR
3921        NEIGHBOR_ADDR_STR2
3922        "Send Community attribute to this neighbor\n"
3923        "Send Standard and Extended Community attributes\n"
3924        "Send Standard, Large and Extended Community attributes\n"
3925        "Send Extended Community attributes\n"
3926        "Send Standard Community attributes\n"
3927        "Send Large Community attributes\n")
3928 {
3929   int idx_peer = 2;
3930   int idx_type = 4;
3931   if (strncmp (argv[idx_type]->arg, "s", 1) == 0)
3932     return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3933                                    bgp_node_safi (vty),
3934                                    PEER_FLAG_SEND_COMMUNITY);
3935   if (strncmp (argv[idx_type]->arg, "e", 1) == 0)
3936     return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3937                                    bgp_node_safi (vty),
3938                                    PEER_FLAG_SEND_EXT_COMMUNITY);
3939   if (strncmp (argv[idx_type]->arg, "l", 1) == 0)
3940     return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3941                                    bgp_node_safi (vty),
3942                                    PEER_FLAG_SEND_LARGE_COMMUNITY);
3943   if (strncmp (argv[idx_type]->arg, "b", 1) == 0)
3944     return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3945                                    bgp_node_safi (vty),
3946                                    PEER_FLAG_SEND_COMMUNITY |
3947                                    PEER_FLAG_SEND_EXT_COMMUNITY);
3948
3949   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
3950                                  bgp_node_safi (vty),
3951                                  (PEER_FLAG_SEND_COMMUNITY |
3952                                   PEER_FLAG_SEND_EXT_COMMUNITY|
3953                                   PEER_FLAG_SEND_LARGE_COMMUNITY));
3954 }
3955
3956 /* neighbor soft-reconfig. */
3957 DEFUN (neighbor_soft_reconfiguration,
3958        neighbor_soft_reconfiguration_cmd,
3959        "neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
3960        NEIGHBOR_STR
3961        NEIGHBOR_ADDR_STR2
3962        "Per neighbor soft reconfiguration\n"
3963        "Allow inbound soft reconfiguration for this neighbor\n")
3964 {
3965   int idx_peer = 1;
3966   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg,
3967                                bgp_node_afi (vty), bgp_node_safi (vty),
3968                                PEER_FLAG_SOFT_RECONFIG);
3969 }
3970
3971 DEFUN (no_neighbor_soft_reconfiguration,
3972        no_neighbor_soft_reconfiguration_cmd,
3973        "no neighbor <A.B.C.D|X:X::X:X|WORD> soft-reconfiguration inbound",
3974        NO_STR
3975        NEIGHBOR_STR
3976        NEIGHBOR_ADDR_STR2
3977        "Per neighbor soft reconfiguration\n"
3978        "Allow inbound soft reconfiguration for this neighbor\n")
3979 {
3980   int idx_peer = 2;
3981   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg,
3982                                  bgp_node_afi (vty), bgp_node_safi (vty),
3983                                  PEER_FLAG_SOFT_RECONFIG);
3984 }
3985
3986 DEFUN (neighbor_route_reflector_client,
3987        neighbor_route_reflector_client_cmd,
3988        "neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
3989        NEIGHBOR_STR
3990        NEIGHBOR_ADDR_STR2
3991        "Configure a neighbor as Route Reflector client\n")
3992 {
3993   int idx_peer = 1;
3994   struct peer *peer;
3995
3996
3997   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
3998   if (! peer)
3999     return CMD_WARNING;
4000
4001   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4002                                bgp_node_safi (vty),
4003                                PEER_FLAG_REFLECTOR_CLIENT);
4004 }
4005
4006 DEFUN (no_neighbor_route_reflector_client,
4007        no_neighbor_route_reflector_client_cmd,
4008        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-reflector-client",
4009        NO_STR
4010        NEIGHBOR_STR
4011        NEIGHBOR_ADDR_STR2
4012        "Configure a neighbor as Route Reflector client\n")
4013 {
4014   int idx_peer = 2;
4015   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4016                                  bgp_node_safi (vty),
4017                                  PEER_FLAG_REFLECTOR_CLIENT);
4018 }
4019
4020 /* neighbor route-server-client. */
4021 DEFUN (neighbor_route_server_client,
4022        neighbor_route_server_client_cmd,
4023        "neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4024        NEIGHBOR_STR
4025        NEIGHBOR_ADDR_STR2
4026        "Configure a neighbor as Route Server client\n")
4027 {
4028   int idx_peer = 1;
4029   struct peer *peer;
4030
4031   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
4032   if (! peer)
4033     return CMD_WARNING;
4034   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4035                                bgp_node_safi (vty),
4036                                PEER_FLAG_RSERVER_CLIENT);
4037 }
4038
4039 DEFUN (no_neighbor_route_server_client,
4040        no_neighbor_route_server_client_cmd,
4041        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-server-client",
4042        NO_STR
4043        NEIGHBOR_STR
4044        NEIGHBOR_ADDR_STR2
4045        "Configure a neighbor as Route Server client\n")
4046 {
4047   int idx_peer = 2;
4048   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4049                                  bgp_node_safi (vty),
4050                                  PEER_FLAG_RSERVER_CLIENT);
4051 }
4052
4053 DEFUN (neighbor_nexthop_local_unchanged,
4054        neighbor_nexthop_local_unchanged_cmd,
4055        "neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4056        NEIGHBOR_STR
4057        NEIGHBOR_ADDR_STR2
4058        "Configure treatment of outgoing link-local nexthop attribute\n"
4059        "Leave link-local nexthop unchanged for this peer\n")
4060 {
4061   int idx_peer = 1;
4062   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4063                                 bgp_node_safi (vty),
4064                                 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED );
4065 }
4066
4067 DEFUN (no_neighbor_nexthop_local_unchanged,
4068        no_neighbor_nexthop_local_unchanged_cmd,
4069        "no neighbor <A.B.C.D|X:X::X:X|WORD> nexthop-local unchanged",
4070        NO_STR
4071        NEIGHBOR_STR
4072        NEIGHBOR_ADDR_STR2
4073        "Configure treatment of outgoing link-local-nexthop attribute\n"
4074        "Leave link-local nexthop unchanged for this peer\n")
4075 {
4076   int idx_peer = 2;
4077   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4078                                  bgp_node_safi (vty),
4079                                 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED );
4080 }
4081
4082 DEFUN (neighbor_attr_unchanged,
4083        neighbor_attr_unchanged_cmd,
4084        "neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged\
4085        [<\
4086           as-path [<next-hop [med]|med [next-hop]>]|\
4087           next-hop [<as-path [med]|med [as-path]>]|\
4088           med [<as-path [next-hop]|next-hop [as-path]>]\
4089        >]",
4090        NEIGHBOR_STR
4091        NEIGHBOR_ADDR_STR2
4092        "BGP attribute is propagated unchanged to this neighbor\n"
4093        "As-path attribute\n"
4094        "Nexthop attribute\n"
4095        "Med attribute\n"
4096        "Med attribute\n"
4097        "Nexthop attribute\n"
4098        "Nexthop attribute\n"
4099        "As-path attribute\n"
4100        "Med attribute\n"
4101        "Med attribute\n"
4102        "As-path attribute\n"
4103        "Med attribute\n"
4104        "As-path attribute\n"
4105        "Nexthop attribute\n"
4106        "Nexthop attribute\n"
4107        "As-path attribute\n")
4108 {
4109   int idx = 0;
4110   char *peer = argv[1]->arg;
4111   u_int16_t flags = 0;
4112
4113   if (argv_find (argv, argc, "as-path", &idx))
4114     SET_FLAG (flags, PEER_FLAG_AS_PATH_UNCHANGED);
4115   idx = 0;
4116   if (argv_find (argv, argc, "next-hop", &idx))
4117     SET_FLAG (flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4118   idx = 0;
4119   if (argv_find (argv, argc, "med", &idx))
4120     SET_FLAG (flags, PEER_FLAG_MED_UNCHANGED);
4121
4122   if (!flags) // no flags means all of them!
4123   {
4124     SET_FLAG (flags, PEER_FLAG_AS_PATH_UNCHANGED);
4125     SET_FLAG (flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4126     SET_FLAG (flags, PEER_FLAG_MED_UNCHANGED);
4127   }
4128
4129   return peer_af_flag_set_vty (vty, peer, bgp_node_afi (vty), bgp_node_safi (vty), flags);
4130 }
4131
4132 DEFUN (no_neighbor_attr_unchanged,
4133        no_neighbor_attr_unchanged_cmd,
4134        "no neighbor <A.B.C.D|X:X::X:X|WORD> attribute-unchanged\
4135        [<\
4136           as-path [<next-hop [med]|med [next-hop]>]|\
4137           next-hop [<as-path [med]|med [as-path]>]|\
4138           med [<as-path [next-hop]|next-hop [as-path]>]\
4139        >]",
4140        NO_STR
4141        NEIGHBOR_STR
4142        NEIGHBOR_ADDR_STR2
4143        "BGP attribute is propagated unchanged to this neighbor\n"
4144        "As-path attribute\n"
4145        "Nexthop attribute\n"
4146        "Med attribute\n"
4147        "Med attribute\n"
4148        "Nexthop attribute\n"
4149        "Nexthop attribute\n"
4150        "As-path attribute\n"
4151        "Med attribute\n"
4152        "Med attribute\n"
4153        "As-path attribute\n"
4154        "Med attribute\n"
4155        "As-path attribute\n"
4156        "Nexthop attribute\n"
4157        "Nexthop attribute\n"
4158        "As-path attribute\n")
4159 {
4160   int idx = 0;
4161   char *peer = argv[2]->arg;
4162   u_int16_t flags = 0;
4163
4164   if (argv_find (argv, argc, "as-path", &idx))
4165     SET_FLAG (flags, PEER_FLAG_AS_PATH_UNCHANGED);
4166   idx = 0;
4167   if (argv_find (argv, argc, "next-hop", &idx))
4168     SET_FLAG (flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4169   idx = 0;
4170   if (argv_find (argv, argc, "med", &idx))
4171     SET_FLAG (flags, PEER_FLAG_MED_UNCHANGED);
4172
4173   if (!flags) // no flags means all of them!
4174   {
4175     SET_FLAG (flags, PEER_FLAG_AS_PATH_UNCHANGED);
4176     SET_FLAG (flags, PEER_FLAG_NEXTHOP_UNCHANGED);
4177     SET_FLAG (flags, PEER_FLAG_MED_UNCHANGED);
4178   }
4179
4180   return peer_af_flag_unset_vty (vty, peer, bgp_node_afi (vty), bgp_node_safi (vty), flags);
4181 }
4182
4183
4184 /* EBGP multihop configuration. */
4185 static int
4186 peer_ebgp_multihop_set_vty (struct vty *vty, const char *ip_str,
4187                             const char *ttl_str)
4188 {
4189   struct peer *peer;
4190   unsigned int ttl;
4191
4192   peer = peer_and_group_lookup_vty (vty, ip_str);
4193   if (! peer)
4194     return CMD_WARNING;
4195
4196   if (peer->conf_if)
4197     return bgp_vty_return (vty, BGP_ERR_INVALID_FOR_DIRECT_PEER);
4198
4199   if (! ttl_str)
4200     ttl = MAXTTL;
4201   else
4202     VTY_GET_INTEGER_RANGE ("TTL", ttl, ttl_str, 1, MAXTTL);
4203
4204   return bgp_vty_return (vty,  peer_ebgp_multihop_set (peer, ttl));
4205 }
4206
4207 static int
4208 peer_ebgp_multihop_unset_vty (struct vty *vty, const char *ip_str)
4209 {
4210   struct peer *peer;
4211
4212   peer = peer_and_group_lookup_vty (vty, ip_str);
4213   if (! peer)
4214     return CMD_WARNING;
4215
4216   return bgp_vty_return (vty, peer_ebgp_multihop_unset (peer));
4217 }
4218
4219 /* neighbor ebgp-multihop. */
4220 DEFUN (neighbor_ebgp_multihop,
4221        neighbor_ebgp_multihop_cmd,
4222        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop",
4223        NEIGHBOR_STR
4224        NEIGHBOR_ADDR_STR2
4225        "Allow EBGP neighbors not on directly connected networks\n")
4226 {
4227   int idx_peer = 1;
4228   return peer_ebgp_multihop_set_vty (vty, argv[idx_peer]->arg, NULL);
4229 }
4230
4231 DEFUN (neighbor_ebgp_multihop_ttl,
4232        neighbor_ebgp_multihop_ttl_cmd,
4233        "neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop (1-255)",
4234        NEIGHBOR_STR
4235        NEIGHBOR_ADDR_STR2
4236        "Allow EBGP neighbors not on directly connected networks\n"
4237        "maximum hop count\n")
4238 {
4239   int idx_peer = 1;
4240   int idx_number = 3;
4241   return peer_ebgp_multihop_set_vty (vty, argv[idx_peer]->arg, argv[idx_number]->arg);
4242 }
4243
4244 DEFUN (no_neighbor_ebgp_multihop,
4245        no_neighbor_ebgp_multihop_cmd,
4246        "no neighbor <A.B.C.D|X:X::X:X|WORD> ebgp-multihop [(1-255)]",
4247        NO_STR
4248        NEIGHBOR_STR
4249        NEIGHBOR_ADDR_STR2
4250        "Allow EBGP neighbors not on directly connected networks\n"
4251        "maximum hop count\n")
4252 {
4253   int idx_peer = 2;
4254   return peer_ebgp_multihop_unset_vty (vty, argv[idx_peer]->arg);
4255 }
4256
4257
4258 /* disable-connected-check */
4259 DEFUN (neighbor_disable_connected_check,
4260        neighbor_disable_connected_check_cmd,
4261        "neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4262        NEIGHBOR_STR
4263        NEIGHBOR_ADDR_STR2
4264        "one-hop away EBGP peer using loopback address\n"
4265        "Enforce EBGP neighbors perform multihop\n")
4266 {
4267   int idx_peer = 1;
4268   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DISABLE_CONNECTED_CHECK);
4269 }
4270
4271 DEFUN (no_neighbor_disable_connected_check,
4272        no_neighbor_disable_connected_check_cmd,
4273        "no neighbor <A.B.C.D|X:X::X:X|WORD> <disable-connected-check|enforce-multihop>",
4274        NO_STR
4275        NEIGHBOR_STR
4276        NEIGHBOR_ADDR_STR2
4277        "one-hop away EBGP peer using loopback address\n"
4278        "Enforce EBGP neighbors perform multihop\n")
4279 {
4280   int idx_peer = 2;
4281   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_DISABLE_CONNECTED_CHECK);
4282 }
4283
4284 DEFUN (neighbor_description,
4285        neighbor_description_cmd,
4286        "neighbor <A.B.C.D|X:X::X:X|WORD> description LINE...",
4287        NEIGHBOR_STR
4288        NEIGHBOR_ADDR_STR2
4289        "Neighbor specific description\n"
4290        "Up to 80 characters describing this neighbor\n")
4291 {
4292   int idx_peer = 1;
4293   int idx_line = 3;
4294   struct peer *peer;
4295   char *str;
4296
4297   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
4298   if (! peer)
4299     return CMD_WARNING;
4300
4301   str = argv_concat(argv, argc, idx_line);
4302
4303   peer_description_set (peer, str);
4304
4305   XFREE (MTYPE_TMP, str);
4306
4307   return CMD_SUCCESS;
4308 }
4309
4310 DEFUN (no_neighbor_description,
4311        no_neighbor_description_cmd,
4312        "no neighbor <A.B.C.D|X:X::X:X|WORD> description [LINE]",
4313        NO_STR
4314        NEIGHBOR_STR
4315        NEIGHBOR_ADDR_STR2
4316        "Neighbor specific description\n"
4317        "Up to 80 characters describing this neighbor\n")
4318 {
4319   int idx_peer = 2;
4320   struct peer *peer;
4321
4322   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
4323   if (! peer)
4324     return CMD_WARNING;
4325
4326   peer_description_unset (peer);
4327
4328   return CMD_SUCCESS;
4329 }
4330
4331
4332 /* Neighbor update-source. */
4333 static int
4334 peer_update_source_vty (struct vty *vty, const char *peer_str,
4335                         const char *source_str)
4336 {
4337   struct peer *peer;
4338   struct prefix p;
4339
4340   peer = peer_and_group_lookup_vty (vty, peer_str);
4341   if (! peer)
4342     return CMD_WARNING;
4343
4344   if (peer->conf_if)
4345     return CMD_WARNING;
4346
4347   if (source_str)
4348     {
4349       union sockunion su;
4350       int ret = str2sockunion (source_str, &su);
4351
4352       if (ret == 0)
4353         peer_update_source_addr_set (peer, &su);
4354       else
4355         {
4356           if (str2prefix (source_str, &p))
4357             {
4358               vty_out (vty, "%% Invalid update-source, remove prefix length %s",
4359                        VTY_NEWLINE);
4360               return CMD_WARNING;
4361             }
4362           else
4363             peer_update_source_if_set (peer, source_str);
4364         }
4365     }
4366   else
4367     peer_update_source_unset (peer);
4368
4369   return CMD_SUCCESS;
4370 }
4371
4372 #define BGP_UPDATE_SOURCE_HELP_STR \
4373   "IPv4 address\n" \
4374   "IPv6 address\n" \
4375   "Interface name (requires zebra to be running)\n"
4376
4377 DEFUN (neighbor_update_source,
4378        neighbor_update_source_cmd,
4379        "neighbor <A.B.C.D|X:X::X:X|WORD> update-source <A.B.C.D|X:X::X:X|WORD>",
4380        NEIGHBOR_STR
4381        NEIGHBOR_ADDR_STR2
4382        "Source of routing updates\n"
4383        BGP_UPDATE_SOURCE_HELP_STR)
4384 {
4385   int idx_peer = 1;
4386   int idx_peer_2 = 3;
4387   return peer_update_source_vty (vty, argv[idx_peer]->arg, argv[idx_peer_2]->arg);
4388 }
4389
4390 DEFUN (no_neighbor_update_source,
4391        no_neighbor_update_source_cmd,
4392        "no neighbor <A.B.C.D|X:X::X:X|WORD> update-source [<A.B.C.D|X:X::X:X|WORD>]",
4393        NO_STR
4394        NEIGHBOR_STR
4395        NEIGHBOR_ADDR_STR2
4396        "Source of routing updates\n"
4397        BGP_UPDATE_SOURCE_HELP_STR)
4398 {
4399   int idx_peer = 2;
4400   return peer_update_source_vty (vty, argv[idx_peer]->arg, NULL);
4401 }
4402
4403 static int
4404 peer_default_originate_set_vty (struct vty *vty, const char *peer_str,
4405                                 afi_t afi, safi_t safi,
4406                                 const char *rmap, int set)
4407 {
4408   int ret;
4409   struct peer *peer;
4410
4411   peer = peer_and_group_lookup_vty (vty, peer_str);
4412   if (! peer)
4413     return CMD_WARNING;
4414
4415   if (set)
4416     ret = peer_default_originate_set (peer, afi, safi, rmap);
4417   else
4418     ret = peer_default_originate_unset (peer, afi, safi);
4419
4420   return bgp_vty_return (vty, ret);
4421 }
4422
4423 /* neighbor default-originate. */
4424 DEFUN (neighbor_default_originate,
4425        neighbor_default_originate_cmd,
4426        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate",
4427        NEIGHBOR_STR
4428        NEIGHBOR_ADDR_STR2
4429        "Originate default route to this neighbor\n")
4430 {
4431   int idx_peer = 1;
4432   return peer_default_originate_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4433                                          bgp_node_safi (vty), NULL, 1);
4434 }
4435
4436 DEFUN (neighbor_default_originate_rmap,
4437        neighbor_default_originate_rmap_cmd,
4438        "neighbor <A.B.C.D|X:X::X:X|WORD> default-originate route-map WORD",
4439        NEIGHBOR_STR
4440        NEIGHBOR_ADDR_STR2
4441        "Originate default route to this neighbor\n"
4442        "Route-map to specify criteria to originate default\n"
4443        "route-map name\n")
4444 {
4445   int idx_peer = 1;
4446   int idx_word = 4;
4447   return peer_default_originate_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4448                                          bgp_node_safi (vty), argv[idx_word]->arg, 1);
4449 }
4450
4451 DEFUN (no_neighbor_default_originate,
4452        no_neighbor_default_originate_cmd,
4453        "no neighbor <A.B.C.D|X:X::X:X|WORD> default-originate [route-map WORD]",
4454        NO_STR
4455        NEIGHBOR_STR
4456        NEIGHBOR_ADDR_STR2
4457        "Originate default route to this neighbor\n"
4458        "Route-map to specify criteria to originate default\n"
4459        "route-map name\n")
4460 {
4461   int idx_peer = 2;
4462   return peer_default_originate_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4463                                          bgp_node_safi (vty), NULL, 0);
4464 }
4465
4466
4467 /* Set neighbor's BGP port.  */
4468 static int
4469 peer_port_vty (struct vty *vty, const char *ip_str, int afi,
4470                const char *port_str)
4471 {
4472   struct peer *peer;
4473   u_int16_t port;
4474   struct servent *sp;
4475
4476   peer = peer_lookup_vty (vty, ip_str);
4477   if (! peer)
4478     return CMD_WARNING;
4479
4480   if (! port_str)
4481     {
4482       sp = getservbyname ("bgp", "tcp");
4483       port = (sp == NULL) ? BGP_PORT_DEFAULT : ntohs (sp->s_port);
4484     }
4485   else
4486     {
4487       VTY_GET_INTEGER("port", port, port_str);
4488     }
4489
4490   peer_port_set (peer, port);
4491
4492   return CMD_SUCCESS;
4493 }
4494
4495 /* Set specified peer's BGP port.  */
4496 DEFUN (neighbor_port,
4497        neighbor_port_cmd,
4498        "neighbor <A.B.C.D|X:X::X:X> port (0-65535)",
4499        NEIGHBOR_STR
4500        NEIGHBOR_ADDR_STR
4501        "Neighbor's BGP port\n"
4502        "TCP port number\n")
4503 {
4504   int idx_ip = 1;
4505   int idx_number = 3;
4506   return peer_port_vty (vty, argv[idx_ip]->arg, AFI_IP, argv[idx_number]->arg);
4507 }
4508
4509 DEFUN (no_neighbor_port,
4510        no_neighbor_port_cmd,
4511        "no neighbor <A.B.C.D|X:X::X:X> port [(0-65535)]",
4512        NO_STR
4513        NEIGHBOR_STR
4514        NEIGHBOR_ADDR_STR
4515        "Neighbor's BGP port\n"
4516        "TCP port number\n")
4517 {
4518   int idx_ip = 2;
4519   return peer_port_vty (vty, argv[idx_ip]->arg, AFI_IP, NULL);
4520 }
4521
4522
4523 /* neighbor weight. */
4524 static int
4525 peer_weight_set_vty (struct vty *vty, const char *ip_str,
4526                      afi_t afi, safi_t safi,
4527                      const char *weight_str)
4528 {
4529   int ret;
4530   struct peer *peer;
4531   unsigned long weight;
4532
4533   peer = peer_and_group_lookup_vty (vty, ip_str);
4534   if (! peer)
4535     return CMD_WARNING;
4536
4537   VTY_GET_INTEGER_RANGE("weight", weight, weight_str, 0, 65535);
4538
4539   ret = peer_weight_set (peer, afi, safi, weight);
4540   return bgp_vty_return (vty, ret);
4541 }
4542
4543 static int
4544 peer_weight_unset_vty (struct vty *vty, const char *ip_str,
4545                        afi_t afi, safi_t safi)
4546 {
4547   int ret;
4548   struct peer *peer;
4549
4550   peer = peer_and_group_lookup_vty (vty, ip_str);
4551   if (! peer)
4552     return CMD_WARNING;
4553
4554   ret = peer_weight_unset (peer, afi, safi);
4555   return bgp_vty_return (vty, ret);
4556 }
4557
4558 DEFUN (neighbor_weight,
4559        neighbor_weight_cmd,
4560        "neighbor <A.B.C.D|X:X::X:X|WORD> weight (0-65535)",
4561        NEIGHBOR_STR
4562        NEIGHBOR_ADDR_STR2
4563        "Set default weight for routes from this neighbor\n"
4564        "default weight\n")
4565 {
4566   int idx_peer = 1;
4567   int idx_number = 3;
4568   return peer_weight_set_vty (vty,
4569                               argv[idx_peer]->arg,
4570                               bgp_node_afi (vty),
4571                               bgp_node_safi (vty),
4572                               argv[idx_number]->arg);
4573 }
4574
4575 DEFUN (no_neighbor_weight,
4576        no_neighbor_weight_cmd,
4577        "no neighbor <A.B.C.D|X:X::X:X|WORD> weight [(0-65535)]",
4578        NO_STR
4579        NEIGHBOR_STR
4580        NEIGHBOR_ADDR_STR2
4581        "Set default weight for routes from this neighbor\n"
4582        "default weight\n")
4583 {
4584   int idx_peer = 2;
4585   return peer_weight_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty), bgp_node_safi (vty));
4586 }
4587
4588
4589 /* Override capability negotiation. */
4590 DEFUN (neighbor_override_capability,
4591        neighbor_override_capability_cmd,
4592        "neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
4593        NEIGHBOR_STR
4594        NEIGHBOR_ADDR_STR2
4595        "Override capability negotiation result\n")
4596 {
4597   int idx_peer = 1;
4598   return peer_flag_set_vty (vty, argv[idx_peer]->arg, PEER_FLAG_OVERRIDE_CAPABILITY);
4599 }
4600
4601 DEFUN (no_neighbor_override_capability,
4602        no_neighbor_override_capability_cmd,
4603        "no neighbor <A.B.C.D|X:X::X:X|WORD> override-capability",
4604        NO_STR
4605        NEIGHBOR_STR
4606        NEIGHBOR_ADDR_STR2
4607        "Override capability negotiation result\n")
4608 {
4609   int idx_peer = 2;
4610   return peer_flag_unset_vty (vty, argv[idx_peer]->arg, PEER_FLAG_OVERRIDE_CAPABILITY);
4611 }
4612
4613 DEFUN (neighbor_strict_capability,
4614        neighbor_strict_capability_cmd,
4615        "neighbor <A.B.C.D|X:X::X:X> strict-capability-match",
4616        NEIGHBOR_STR
4617        NEIGHBOR_ADDR_STR
4618        "Strict capability negotiation match\n")
4619 {
4620   int idx_ip = 1;
4621   return peer_flag_set_vty (vty, argv[idx_ip]->arg, PEER_FLAG_STRICT_CAP_MATCH);
4622 }
4623
4624 DEFUN (no_neighbor_strict_capability,
4625        no_neighbor_strict_capability_cmd,
4626        "no neighbor <A.B.C.D|X:X::X:X> strict-capability-match",
4627        NO_STR
4628        NEIGHBOR_STR
4629        NEIGHBOR_ADDR_STR
4630        "Strict capability negotiation match\n")
4631 {
4632   int idx_ip = 2;
4633   return peer_flag_unset_vty (vty, argv[idx_ip]->arg, PEER_FLAG_STRICT_CAP_MATCH);
4634 }
4635
4636 static int
4637 peer_timers_set_vty (struct vty *vty, const char *ip_str,
4638                      const char *keep_str, const char *hold_str)
4639 {
4640   int ret;
4641   struct peer *peer;
4642   u_int32_t keepalive;
4643   u_int32_t holdtime;
4644
4645   peer = peer_and_group_lookup_vty (vty, ip_str);
4646   if (! peer)
4647     return CMD_WARNING;
4648
4649   VTY_GET_INTEGER_RANGE ("Keepalive", keepalive, keep_str, 0, 65535);
4650   VTY_GET_INTEGER_RANGE ("Holdtime", holdtime, hold_str, 0, 65535);
4651
4652   ret = peer_timers_set (peer, keepalive, holdtime);
4653
4654   return bgp_vty_return (vty, ret);
4655 }
4656
4657 static int
4658 peer_timers_unset_vty (struct vty *vty, const char *ip_str)
4659 {
4660   int ret;
4661   struct peer *peer;
4662
4663   peer = peer_and_group_lookup_vty (vty, ip_str);
4664   if (! peer)
4665     return CMD_WARNING;
4666
4667   ret = peer_timers_unset (peer);
4668
4669   return bgp_vty_return (vty, ret);
4670 }
4671
4672 DEFUN (neighbor_timers,
4673        neighbor_timers_cmd,
4674        "neighbor <A.B.C.D|X:X::X:X|WORD> timers (0-65535) (0-65535)",
4675        NEIGHBOR_STR
4676        NEIGHBOR_ADDR_STR2
4677        "BGP per neighbor timers\n"
4678        "Keepalive interval\n"
4679        "Holdtime\n")
4680 {
4681   int idx_peer = 1;
4682   int idx_number = 3;
4683   int idx_number_2 = 4;
4684   return peer_timers_set_vty (vty, argv[idx_peer]->arg, argv[idx_number]->arg, argv[idx_number_2]->arg);
4685 }
4686
4687 DEFUN (no_neighbor_timers,
4688        no_neighbor_timers_cmd,
4689        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers [(0-65535) (0-65535)]",
4690        NO_STR
4691        NEIGHBOR_STR
4692        NEIGHBOR_ADDR_STR2
4693        "BGP per neighbor timers\n"
4694        "Keepalive interval\n"
4695        "Holdtime\n")
4696 {
4697   int idx_peer = 2;
4698   return peer_timers_unset_vty (vty, argv[idx_peer]->arg);
4699 }
4700
4701
4702 static int
4703 peer_timers_connect_set_vty (struct vty *vty, const char *ip_str,
4704                              const char *time_str)
4705 {
4706   int ret;
4707   struct peer *peer;
4708   u_int32_t connect;
4709
4710   peer = peer_and_group_lookup_vty (vty, ip_str);
4711   if (! peer)
4712     return CMD_WARNING;
4713
4714   VTY_GET_INTEGER_RANGE ("Connect time", connect, time_str, 0, 65535);
4715
4716   ret = peer_timers_connect_set (peer, connect);
4717
4718   return bgp_vty_return (vty, ret);
4719 }
4720
4721 static int
4722 peer_timers_connect_unset_vty (struct vty *vty, const char *ip_str)
4723 {
4724   int ret;
4725   struct peer *peer;
4726
4727   peer = peer_and_group_lookup_vty (vty, ip_str);
4728   if (! peer)
4729     return CMD_WARNING;
4730
4731   ret = peer_timers_connect_unset (peer);
4732
4733   return bgp_vty_return (vty, ret);
4734 }
4735
4736 DEFUN (neighbor_timers_connect,
4737        neighbor_timers_connect_cmd,
4738        "neighbor <A.B.C.D|X:X::X:X|WORD> timers connect (1-65535)",
4739        NEIGHBOR_STR
4740        NEIGHBOR_ADDR_STR2
4741        "BGP per neighbor timers\n"
4742        "BGP connect timer\n"
4743        "Connect timer\n")
4744 {
4745   int idx_peer = 1;
4746   int idx_number = 4;
4747   return peer_timers_connect_set_vty (vty, argv[idx_peer]->arg, argv[idx_number]->arg);
4748 }
4749
4750 DEFUN (no_neighbor_timers_connect,
4751        no_neighbor_timers_connect_cmd,
4752        "no neighbor <A.B.C.D|X:X::X:X|WORD> timers connect [(1-65535)]",
4753        NO_STR
4754        NEIGHBOR_STR
4755        NEIGHBOR_ADDR_STR2
4756        "BGP per neighbor timers\n"
4757        "BGP connect timer\n"
4758        "Connect timer\n")
4759 {
4760   int idx_peer = 2;
4761   return peer_timers_connect_unset_vty (vty, argv[idx_peer]->arg);
4762 }
4763
4764
4765 static int
4766 peer_advertise_interval_vty (struct vty *vty, const char *ip_str,
4767                              const char *time_str, int set)
4768 {
4769   int ret;
4770   struct peer *peer;
4771   u_int32_t routeadv = 0;
4772
4773   peer = peer_and_group_lookup_vty (vty, ip_str);
4774   if (! peer)
4775     return CMD_WARNING;
4776
4777   if (time_str)
4778     VTY_GET_INTEGER_RANGE ("advertise interval", routeadv, time_str, 0, 600);
4779
4780   if (set)
4781     ret = peer_advertise_interval_set (peer, routeadv);
4782   else
4783     ret = peer_advertise_interval_unset (peer);
4784
4785   return bgp_vty_return (vty, ret);
4786 }
4787
4788 DEFUN (neighbor_advertise_interval,
4789        neighbor_advertise_interval_cmd,
4790        "neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval (0-600)",
4791        NEIGHBOR_STR
4792        NEIGHBOR_ADDR_STR2
4793        "Minimum interval between sending BGP routing updates\n"
4794        "time in seconds\n")
4795 {
4796   int idx_peer = 1;
4797   int idx_number = 3;
4798   return peer_advertise_interval_vty (vty, argv[idx_peer]->arg, argv[idx_number]->arg, 1);
4799 }
4800
4801 DEFUN (no_neighbor_advertise_interval,
4802        no_neighbor_advertise_interval_cmd,
4803        "no neighbor <A.B.C.D|X:X::X:X|WORD> advertisement-interval [(0-600)]",
4804        NO_STR
4805        NEIGHBOR_STR
4806        NEIGHBOR_ADDR_STR2
4807        "Minimum interval between sending BGP routing updates\n"
4808        "time in seconds\n")
4809 {
4810   int idx_peer = 2;
4811   return peer_advertise_interval_vty (vty, argv[idx_peer]->arg, NULL, 0);
4812 }
4813
4814
4815 /* Time to wait before processing route-map updates */
4816 DEFUN (bgp_set_route_map_delay_timer,
4817        bgp_set_route_map_delay_timer_cmd,
4818        "bgp route-map delay-timer (0-600)",
4819        SET_STR
4820        "BGP route-map delay timer\n"
4821        "Time in secs to wait before processing route-map changes\n"
4822        "0 disables the timer, no route updates happen when route-maps change\n")
4823 {
4824   int idx_number = 3;
4825   u_int32_t rmap_delay_timer;
4826
4827   if (argv[idx_number]->arg)
4828     {
4829       VTY_GET_INTEGER_RANGE ("delay-timer", rmap_delay_timer, argv[idx_number]->arg, 0, 600);
4830       bm->rmap_update_timer = rmap_delay_timer;
4831
4832       /* if the dynamic update handling is being disabled, and a timer is
4833        * running, stop the timer and act as if the timer has already fired.
4834        */
4835       if (!rmap_delay_timer && bm->t_rmap_update )
4836         {
4837           BGP_TIMER_OFF(bm->t_rmap_update);
4838           thread_execute (bm->master, bgp_route_map_update_timer, NULL, 0);
4839         }
4840       return CMD_SUCCESS;
4841     }
4842   else
4843     return CMD_WARNING;
4844 }
4845
4846 DEFUN (no_bgp_set_route_map_delay_timer,
4847        no_bgp_set_route_map_delay_timer_cmd,
4848        "no bgp route-map delay-timer [(0-600)]",
4849        NO_STR
4850        BGP_STR
4851        "Default BGP route-map delay timer\n"
4852        "Reset to default time to wait for processing route-map changes\n"
4853        "0 disables the timer, no route updates happen when route-maps change\n")
4854 {
4855
4856   bm->rmap_update_timer = RMAP_DEFAULT_UPDATE_TIMER;
4857
4858   return CMD_SUCCESS;
4859 }
4860
4861
4862 /* neighbor interface */
4863 static int
4864 peer_interface_vty (struct vty *vty, const char *ip_str, const char *str)
4865 {
4866   struct peer *peer;
4867
4868   peer = peer_lookup_vty (vty, ip_str);
4869   if (! peer || peer->conf_if)
4870     return CMD_WARNING;
4871
4872   if (str)
4873     peer_interface_set (peer, str);
4874   else
4875     peer_interface_unset (peer);
4876
4877   return CMD_SUCCESS;
4878 }
4879
4880 DEFUN (neighbor_interface,
4881        neighbor_interface_cmd,
4882        "neighbor <A.B.C.D|X:X::X:X> interface WORD",
4883        NEIGHBOR_STR
4884        NEIGHBOR_ADDR_STR
4885        "Interface\n"
4886        "Interface name\n")
4887 {
4888   int idx_ip = 1;
4889   int idx_word = 3;
4890   return peer_interface_vty (vty, argv[idx_ip]->arg, argv[idx_word]->arg);
4891 }
4892
4893 DEFUN (no_neighbor_interface,
4894        no_neighbor_interface_cmd,
4895        "no neighbor <A.B.C.D|X:X::X:X|WORD> interface WORD",
4896        NO_STR
4897        NEIGHBOR_STR
4898        NEIGHBOR_ADDR_STR2
4899        "Interface\n"
4900        "Interface name\n")
4901 {
4902   int idx_peer = 2;
4903   return peer_interface_vty (vty, argv[idx_peer]->arg, NULL);
4904 }
4905
4906 /* Set distribute list to the peer. */
4907 static int
4908 peer_distribute_set_vty (struct vty *vty, const char *ip_str,
4909                          afi_t afi, safi_t safi,
4910                          const char *name_str, const char *direct_str)
4911 {
4912   int ret;
4913   struct peer *peer;
4914   int direct = FILTER_IN;
4915
4916   peer = peer_and_group_lookup_vty (vty, ip_str);
4917   if (! peer)
4918     return CMD_WARNING;
4919
4920   /* Check filter direction. */
4921   if (strncmp (direct_str, "i", 1) == 0)
4922     direct = FILTER_IN;
4923   else if (strncmp (direct_str, "o", 1) == 0)
4924     direct = FILTER_OUT;
4925
4926   ret = peer_distribute_set (peer, afi, safi, direct, name_str);
4927
4928   return bgp_vty_return (vty, ret);
4929 }
4930
4931 static int
4932 peer_distribute_unset_vty (struct vty *vty, const char *ip_str, afi_t afi,
4933                            safi_t safi, const char *direct_str)
4934 {
4935   int ret;
4936   struct peer *peer;
4937   int direct = FILTER_IN;
4938
4939   peer = peer_and_group_lookup_vty (vty, ip_str);
4940   if (! peer)
4941     return CMD_WARNING;
4942
4943   /* Check filter direction. */
4944   if (strncmp (direct_str, "i", 1) == 0)
4945     direct = FILTER_IN;
4946   else if (strncmp (direct_str, "o", 1) == 0)
4947     direct = FILTER_OUT;
4948
4949   ret = peer_distribute_unset (peer, afi, safi, direct);
4950
4951   return bgp_vty_return (vty, ret);
4952 }
4953
4954 DEFUN (neighbor_distribute_list,
4955        neighbor_distribute_list_cmd,
4956        "neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
4957        NEIGHBOR_STR
4958        NEIGHBOR_ADDR_STR2
4959        "Filter updates to/from this neighbor\n"
4960        "IP access-list number\n"
4961        "IP access-list number (expanded range)\n"
4962        "IP Access-list name\n"
4963        "Filter incoming updates\n"
4964        "Filter outgoing updates\n")
4965 {
4966   int idx_peer = 1;
4967   int idx_acl = 3;
4968   int idx_in_out = 4;
4969   return peer_distribute_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4970                                   bgp_node_safi (vty), argv[idx_acl]->arg, argv[idx_in_out]->arg);
4971 }
4972
4973 DEFUN (no_neighbor_distribute_list,
4974        no_neighbor_distribute_list_cmd,
4975        "no neighbor <A.B.C.D|X:X::X:X|WORD> distribute-list <(1-199)|(1300-2699)|WORD> <in|out>",
4976        NO_STR
4977        NEIGHBOR_STR
4978        NEIGHBOR_ADDR_STR2
4979        "Filter updates to/from this neighbor\n"
4980        "IP access-list number\n"
4981        "IP access-list number (expanded range)\n"
4982        "IP Access-list name\n"
4983        "Filter incoming updates\n"
4984        "Filter outgoing updates\n")
4985 {
4986   int idx_peer = 2;
4987   int idx_in_out = 5;
4988   return peer_distribute_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
4989                                     bgp_node_safi (vty), argv[idx_in_out]->arg);
4990 }
4991
4992 /* Set prefix list to the peer. */
4993 static int
4994 peer_prefix_list_set_vty (struct vty *vty, const char *ip_str, afi_t afi,
4995                           safi_t safi, const char *name_str,
4996                           const char *direct_str)
4997 {
4998   int ret;
4999   struct peer *peer;
5000   int direct = FILTER_IN;
5001
5002   peer = peer_and_group_lookup_vty (vty, ip_str);
5003   if (! peer)
5004     return CMD_WARNING;
5005
5006   /* Check filter direction. */
5007   if (strncmp (direct_str, "i", 1) == 0)
5008     direct = FILTER_IN;
5009   else if (strncmp (direct_str, "o", 1) == 0)
5010     direct = FILTER_OUT;
5011
5012   ret = peer_prefix_list_set (peer, afi, safi, direct, name_str);
5013
5014   return bgp_vty_return (vty, ret);
5015 }
5016
5017 static int
5018 peer_prefix_list_unset_vty (struct vty *vty, const char *ip_str, afi_t afi,
5019                             safi_t safi, const char *direct_str)
5020 {
5021   int ret;
5022   struct peer *peer;
5023   int direct = FILTER_IN;
5024
5025   peer = peer_and_group_lookup_vty (vty, ip_str);
5026   if (! peer)
5027     return CMD_WARNING;
5028
5029   /* Check filter direction. */
5030   if (strncmp (direct_str, "i", 1) == 0)
5031     direct = FILTER_IN;
5032   else if (strncmp (direct_str, "o", 1) == 0)
5033     direct = FILTER_OUT;
5034
5035   ret = peer_prefix_list_unset (peer, afi, safi, direct);
5036
5037   return bgp_vty_return (vty, ret);
5038 }
5039
5040 DEFUN (neighbor_prefix_list,
5041        neighbor_prefix_list_cmd,
5042        "neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5043        NEIGHBOR_STR
5044        NEIGHBOR_ADDR_STR2
5045        "Filter updates to/from this neighbor\n"
5046        "Name of a prefix list\n"
5047        "Filter incoming updates\n"
5048        "Filter outgoing updates\n")
5049 {
5050   int idx_peer = 1;
5051   int idx_word = 3;
5052   int idx_in_out = 4;
5053   return peer_prefix_list_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5054                                    bgp_node_safi (vty), argv[idx_word]->arg, argv[idx_in_out]->arg);
5055 }
5056
5057 DEFUN (no_neighbor_prefix_list,
5058        no_neighbor_prefix_list_cmd,
5059        "no neighbor <A.B.C.D|X:X::X:X|WORD> prefix-list WORD <in|out>",
5060        NO_STR
5061        NEIGHBOR_STR
5062        NEIGHBOR_ADDR_STR2
5063        "Filter updates to/from this neighbor\n"
5064        "Name of a prefix list\n"
5065        "Filter incoming updates\n"
5066        "Filter outgoing updates\n")
5067 {
5068   int idx_peer = 2;
5069   int idx_in_out = 5;
5070   return peer_prefix_list_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5071                                      bgp_node_safi (vty), argv[idx_in_out]->arg);
5072 }
5073
5074 static int
5075 peer_aslist_set_vty (struct vty *vty, const char *ip_str,
5076                      afi_t afi, safi_t safi,
5077                      const char *name_str, const char *direct_str)
5078 {
5079   int ret;
5080   struct peer *peer;
5081   int direct = FILTER_IN;
5082
5083   peer = peer_and_group_lookup_vty (vty, ip_str);
5084   if (! peer)
5085     return CMD_WARNING;
5086
5087   /* Check filter direction. */
5088   if (strncmp (direct_str, "i", 1) == 0)
5089     direct = FILTER_IN;
5090   else if (strncmp (direct_str, "o", 1) == 0)
5091     direct = FILTER_OUT;
5092
5093   ret = peer_aslist_set (peer, afi, safi, direct, name_str);
5094
5095   return bgp_vty_return (vty, ret);
5096 }
5097
5098 static int
5099 peer_aslist_unset_vty (struct vty *vty, const char *ip_str,
5100                        afi_t afi, safi_t safi,
5101                        const char *direct_str)
5102 {
5103   int ret;
5104   struct peer *peer;
5105   int direct = FILTER_IN;
5106
5107   peer = peer_and_group_lookup_vty (vty, ip_str);
5108   if (! peer)
5109     return CMD_WARNING;
5110
5111   /* Check filter direction. */
5112   if (strncmp (direct_str, "i", 1) == 0)
5113     direct = FILTER_IN;
5114   else if (strncmp (direct_str, "o", 1) == 0)
5115     direct = FILTER_OUT;
5116
5117   ret = peer_aslist_unset (peer, afi, safi, direct);
5118
5119   return bgp_vty_return (vty, ret);
5120 }
5121
5122 DEFUN (neighbor_filter_list,
5123        neighbor_filter_list_cmd,
5124        "neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5125        NEIGHBOR_STR
5126        NEIGHBOR_ADDR_STR2
5127        "Establish BGP filters\n"
5128        "AS path access-list name\n"
5129        "Filter incoming routes\n"
5130        "Filter outgoing routes\n")
5131 {
5132   int idx_peer = 1;
5133   int idx_word = 3;
5134   int idx_in_out = 4;
5135   return peer_aslist_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5136                               bgp_node_safi (vty), argv[idx_word]->arg, argv[idx_in_out]->arg);
5137 }
5138
5139 DEFUN (no_neighbor_filter_list,
5140        no_neighbor_filter_list_cmd,
5141        "no neighbor <A.B.C.D|X:X::X:X|WORD> filter-list WORD <in|out>",
5142        NO_STR
5143        NEIGHBOR_STR
5144        NEIGHBOR_ADDR_STR2
5145        "Establish BGP filters\n"
5146        "AS path access-list name\n"
5147        "Filter incoming routes\n"
5148        "Filter outgoing routes\n")
5149 {
5150   int idx_peer = 2;
5151   int idx_in_out = 5;
5152   return peer_aslist_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5153                                 bgp_node_safi (vty), argv[idx_in_out]->arg);
5154 }
5155
5156 /* Set route-map to the peer. */
5157 static int
5158 peer_route_map_set_vty (struct vty *vty, const char *ip_str,
5159                         afi_t afi, safi_t safi,
5160                         const char *name_str, const char *direct_str)
5161 {
5162   int ret;
5163   struct peer *peer;
5164   int direct = RMAP_IN;
5165
5166   peer = peer_and_group_lookup_vty (vty, ip_str);
5167   if (! peer)
5168     return CMD_WARNING;
5169
5170   /* Check filter direction. */
5171   if (strncmp (direct_str, "in", 2) == 0)
5172     direct = RMAP_IN;
5173   else if (strncmp (direct_str, "o", 1) == 0)
5174     direct = RMAP_OUT;
5175
5176   ret = peer_route_map_set (peer, afi, safi, direct, name_str);
5177
5178   return bgp_vty_return (vty, ret);
5179 }
5180
5181 static int
5182 peer_route_map_unset_vty (struct vty *vty, const char *ip_str, afi_t afi,
5183                           safi_t safi, const char *direct_str)
5184 {
5185   int ret;
5186   struct peer *peer;
5187   int direct = RMAP_IN;
5188
5189   peer = peer_and_group_lookup_vty (vty, ip_str);
5190   if (! peer)
5191     return CMD_WARNING;
5192
5193   /* Check filter direction. */
5194   if (strncmp (direct_str, "in", 2) == 0)
5195     direct = RMAP_IN;
5196   else if (strncmp (direct_str, "o", 1) == 0)
5197     direct = RMAP_OUT;
5198
5199   ret = peer_route_map_unset (peer, afi, safi, direct);
5200
5201   return bgp_vty_return (vty, ret);
5202 }
5203
5204 DEFUN (neighbor_route_map,
5205        neighbor_route_map_cmd,
5206        "neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5207        NEIGHBOR_STR
5208        NEIGHBOR_ADDR_STR2
5209        "Apply route map to neighbor\n"
5210        "Name of route map\n"
5211        "Apply map to incoming routes\n"
5212        "Apply map to outbound routes\n")
5213 {
5214   int idx_peer = 1;
5215   int idx_word = 3;
5216   int idx_in_out = 4;
5217   return peer_route_map_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5218                                  bgp_node_safi (vty), argv[idx_word]->arg, argv[idx_in_out]->arg);
5219 }
5220
5221 DEFUN (no_neighbor_route_map,
5222        no_neighbor_route_map_cmd,
5223        "no neighbor <A.B.C.D|X:X::X:X|WORD> route-map WORD <in|out>",
5224        NO_STR
5225        NEIGHBOR_STR
5226        NEIGHBOR_ADDR_STR2
5227        "Apply route map to neighbor\n"
5228        "Name of route map\n"
5229        "Apply map to incoming routes\n"
5230        "Apply map to outbound routes\n")
5231 {
5232   int idx_peer = 2;
5233   int idx_in_out = 5;
5234   return peer_route_map_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5235                                    bgp_node_safi (vty), argv[idx_in_out]->arg);
5236 }
5237
5238 /* Set unsuppress-map to the peer. */
5239 static int
5240 peer_unsuppress_map_set_vty (struct vty *vty, const char *ip_str, afi_t afi,
5241                              safi_t safi, const char *name_str)
5242 {
5243   int ret;
5244   struct peer *peer;
5245
5246   peer = peer_and_group_lookup_vty (vty, ip_str);
5247   if (! peer)
5248     return CMD_WARNING;
5249
5250   ret = peer_unsuppress_map_set (peer, afi, safi, name_str);
5251
5252   return bgp_vty_return (vty, ret);
5253 }
5254
5255 /* Unset route-map from the peer. */
5256 static int
5257 peer_unsuppress_map_unset_vty (struct vty *vty, const char *ip_str, afi_t afi,
5258                                safi_t safi)
5259 {
5260   int ret;
5261   struct peer *peer;
5262
5263   peer = peer_and_group_lookup_vty (vty, ip_str);
5264   if (! peer)
5265     return CMD_WARNING;
5266
5267   ret = peer_unsuppress_map_unset (peer, afi, safi);
5268
5269   return bgp_vty_return (vty, ret);
5270 }
5271
5272 DEFUN (neighbor_unsuppress_map,
5273        neighbor_unsuppress_map_cmd,
5274        "neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5275        NEIGHBOR_STR
5276        NEIGHBOR_ADDR_STR2
5277        "Route-map to selectively unsuppress suppressed routes\n"
5278        "Name of route map\n")
5279 {
5280   int idx_peer = 1;
5281   int idx_word = 3;
5282   return peer_unsuppress_map_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5283                                       bgp_node_safi (vty), argv[idx_word]->arg);
5284 }
5285
5286 DEFUN (no_neighbor_unsuppress_map,
5287        no_neighbor_unsuppress_map_cmd,
5288        "no neighbor <A.B.C.D|X:X::X:X|WORD> unsuppress-map WORD",
5289        NO_STR
5290        NEIGHBOR_STR
5291        NEIGHBOR_ADDR_STR2
5292        "Route-map to selectively unsuppress suppressed routes\n"
5293        "Name of route map\n")
5294 {
5295   int idx_peer = 2;
5296   return peer_unsuppress_map_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5297                                         bgp_node_safi (vty));
5298 }
5299
5300 static int
5301 peer_maximum_prefix_set_vty (struct vty *vty, const char *ip_str, afi_t afi,
5302                              safi_t safi, const char *num_str,
5303                              const char *threshold_str, int warning,
5304                              const char *restart_str)
5305 {
5306   int ret;
5307   struct peer *peer;
5308   u_int32_t max;
5309   u_char threshold;
5310   u_int16_t restart;
5311
5312   peer = peer_and_group_lookup_vty (vty, ip_str);
5313   if (! peer)
5314     return CMD_WARNING;
5315
5316   VTY_GET_INTEGER ("maximum number", max, num_str);
5317   if (threshold_str)
5318     threshold = atoi (threshold_str);
5319   else
5320     threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
5321
5322   if (restart_str)
5323     restart = atoi (restart_str);
5324   else
5325     restart = 0;
5326
5327   ret = peer_maximum_prefix_set (peer, afi, safi, max, threshold, warning, restart);
5328
5329   return bgp_vty_return (vty, ret);
5330 }
5331
5332 static int
5333 peer_maximum_prefix_unset_vty (struct vty *vty, const char *ip_str, afi_t afi,
5334                                safi_t safi)
5335 {
5336   int ret;
5337   struct peer *peer;
5338
5339   peer = peer_and_group_lookup_vty (vty, ip_str);
5340   if (! peer)
5341     return CMD_WARNING;
5342
5343   ret = peer_maximum_prefix_unset (peer, afi, safi);
5344
5345   return bgp_vty_return (vty, ret);
5346 }
5347
5348 /* Maximum number of prefix configuration.  prefix count is different
5349    for each peer configuration.  So this configuration can be set for
5350    each peer configuration. */
5351 DEFUN (neighbor_maximum_prefix,
5352        neighbor_maximum_prefix_cmd,
5353        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295)",
5354        NEIGHBOR_STR
5355        NEIGHBOR_ADDR_STR2
5356        "Maximum number of prefix accept from this peer\n"
5357        "maximum no. of prefix limit\n")
5358 {
5359   int idx_peer = 1;
5360   int idx_number = 3;
5361   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5362                                       bgp_node_safi (vty), argv[idx_number]->arg, NULL, 0,
5363                                       NULL);
5364 }
5365
5366 DEFUN (neighbor_maximum_prefix_threshold,
5367        neighbor_maximum_prefix_threshold_cmd,
5368        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100)",
5369        NEIGHBOR_STR
5370        NEIGHBOR_ADDR_STR2
5371        "Maximum number of prefix accept from this peer\n"
5372        "maximum no. of prefix limit\n"
5373        "Threshold value (%) at which to generate a warning msg\n")
5374 {
5375   int idx_peer = 1;
5376   int idx_number = 3;
5377   int idx_number_2 = 4;
5378   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5379                                       bgp_node_safi (vty), argv[idx_number]->arg, argv[idx_number_2]->arg, 0,
5380                                       NULL);
5381 }
5382
5383 DEFUN (neighbor_maximum_prefix_warning,
5384        neighbor_maximum_prefix_warning_cmd,
5385        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) warning-only",
5386        NEIGHBOR_STR
5387        NEIGHBOR_ADDR_STR2
5388        "Maximum number of prefix accept from this peer\n"
5389        "maximum no. of prefix limit\n"
5390        "Only give warning message when limit is exceeded\n")
5391 {
5392   int idx_peer = 1;
5393   int idx_number = 3;
5394   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5395                                       bgp_node_safi (vty), argv[idx_number]->arg, NULL, 1,
5396                                       NULL);
5397 }
5398
5399 DEFUN (neighbor_maximum_prefix_threshold_warning,
5400        neighbor_maximum_prefix_threshold_warning_cmd,
5401        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) warning-only",
5402        NEIGHBOR_STR
5403        NEIGHBOR_ADDR_STR2
5404        "Maximum number of prefix accept from this peer\n"
5405        "maximum no. of prefix limit\n"
5406        "Threshold value (%) at which to generate a warning msg\n"
5407        "Only give warning message when limit is exceeded\n")
5408 {
5409   int idx_peer = 1;
5410   int idx_number = 3;
5411   int idx_number_2 = 4;
5412   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5413                                       bgp_node_safi (vty), argv[idx_number]->arg, argv[idx_number_2]->arg, 1, NULL);
5414 }
5415
5416 DEFUN (neighbor_maximum_prefix_restart,
5417        neighbor_maximum_prefix_restart_cmd,
5418        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) restart (1-65535)",
5419        NEIGHBOR_STR
5420        NEIGHBOR_ADDR_STR2
5421        "Maximum number of prefix accept from this peer\n"
5422        "maximum no. of prefix limit\n"
5423        "Restart bgp connection after limit is exceeded\n"
5424        "Restart interval in minutes")
5425 {
5426   int idx_peer = 1;
5427   int idx_number = 3;
5428   int idx_number_2 = 5;
5429   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5430                                       bgp_node_safi (vty), argv[idx_number]->arg, NULL, 0, argv[idx_number_2]->arg);
5431 }
5432
5433 DEFUN (neighbor_maximum_prefix_threshold_restart,
5434        neighbor_maximum_prefix_threshold_restart_cmd,
5435        "neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix (1-4294967295) (1-100) restart (1-65535)",
5436        NEIGHBOR_STR
5437        NEIGHBOR_ADDR_STR2
5438        "Maximum number of prefixes to accept from this peer\n"
5439        "maximum no. of prefix limit\n"
5440        "Threshold value (%) at which to generate a warning msg\n"
5441        "Restart bgp connection after limit is exceeded\n"
5442        "Restart interval in minutes\n")
5443 {
5444   int idx_peer = 1;
5445   int idx_number = 3;
5446   int idx_number_2 = 4;
5447   int idx_number_3 = 6;
5448   return peer_maximum_prefix_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5449                                       bgp_node_safi (vty), argv[idx_number]->arg, argv[idx_number_2]->arg, 0, argv[idx_number_3]->arg);
5450 }
5451
5452 DEFUN (no_neighbor_maximum_prefix,
5453        no_neighbor_maximum_prefix_cmd,
5454        "no neighbor <A.B.C.D|X:X::X:X|WORD> maximum-prefix [(1-4294967295) [(1-100)] [restart (1-65535)] [warning-only]]",
5455        NO_STR
5456        NEIGHBOR_STR
5457        NEIGHBOR_ADDR_STR2
5458        "Maximum number of prefixes to accept from this peer\n"
5459        "maximum no. of prefix limit\n"
5460        "Threshold value (%) at which to generate a warning msg\n"
5461        "Restart bgp connection after limit is exceeded\n"
5462        "Restart interval in minutes\n"
5463        "Only give warning message when limit is exceeded\n")
5464 {
5465   int idx_peer = 2;
5466   return peer_maximum_prefix_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5467                                         bgp_node_safi (vty));
5468 }
5469
5470
5471 /* "neighbor allowas-in" */
5472 DEFUN (neighbor_allowas_in,
5473        neighbor_allowas_in_cmd,
5474        "neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
5475        NEIGHBOR_STR
5476        NEIGHBOR_ADDR_STR2
5477        "Accept as-path with my AS present in it\n"
5478        "Number of occurances of AS number\n"
5479        "Only accept my AS in the as-path if the route was originated in my AS\n")
5480 {
5481   int idx_peer = 1;
5482   int idx_number_origin = 3;
5483   int ret;
5484   int origin = 0;
5485   struct peer *peer;
5486   int allow_num = 0;
5487
5488   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5489   if (! peer)
5490     return CMD_WARNING;
5491
5492   if (argc <= idx_number_origin)
5493     allow_num = 3;
5494   else
5495     {
5496       if (argv[idx_number_origin]->type == WORD_TKN)
5497         origin = 1;
5498       else
5499         allow_num = atoi (argv[idx_number_origin]->arg);
5500     }
5501
5502   ret = peer_allowas_in_set (peer, bgp_node_afi (vty), bgp_node_safi (vty),
5503                              allow_num, origin);
5504
5505   return bgp_vty_return (vty, ret);
5506 }
5507
5508 DEFUN (no_neighbor_allowas_in,
5509        no_neighbor_allowas_in_cmd,
5510        "no neighbor <A.B.C.D|X:X::X:X|WORD> allowas-in [<(1-10)|origin>]",
5511        NO_STR
5512        NEIGHBOR_STR
5513        NEIGHBOR_ADDR_STR2
5514        "allow local ASN appears in aspath attribute\n"
5515        "Number of occurances of AS number\n"
5516        "Only accept my AS in the as-path if the route was originated in my AS\n")
5517 {
5518   int idx_peer = 2;
5519   int ret;
5520   struct peer *peer;
5521
5522   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5523   if (! peer)
5524     return CMD_WARNING;
5525
5526   ret = peer_allowas_in_unset (peer, bgp_node_afi (vty), bgp_node_safi (vty));
5527
5528   return bgp_vty_return (vty, ret);
5529 }
5530
5531 DEFUN (neighbor_ttl_security,
5532        neighbor_ttl_security_cmd,
5533        "neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
5534        NEIGHBOR_STR
5535        NEIGHBOR_ADDR_STR2
5536        "BGP ttl-security parameters\n"
5537        "Specify the maximum number of hops to the BGP peer\n"
5538        "Number of hops to BGP peer\n")
5539 {
5540   int idx_peer = 1;
5541   int idx_number = 4;
5542   struct peer *peer;
5543   int gtsm_hops;
5544
5545   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5546   if (! peer)
5547     return CMD_WARNING;
5548
5549   VTY_GET_INTEGER_RANGE ("", gtsm_hops, argv[idx_number]->arg, 1, 254);
5550
5551   /*
5552    * If 'neighbor swpX', then this is for directly connected peers,
5553    * we should not accept a ttl-security hops value greater than 1.
5554    */
5555   if (peer->conf_if && (gtsm_hops > 1)) {
5556     vty_out (vty, "%s is directly connected peer, hops cannot exceed 1%s",
5557                   argv[idx_peer]->arg, VTY_NEWLINE);
5558     return CMD_WARNING;
5559   }
5560
5561   return bgp_vty_return (vty, peer_ttl_security_hops_set (peer, gtsm_hops));
5562 }
5563
5564 DEFUN (no_neighbor_ttl_security,
5565        no_neighbor_ttl_security_cmd,
5566        "no neighbor <A.B.C.D|X:X::X:X|WORD> ttl-security hops (1-254)",
5567        NO_STR
5568        NEIGHBOR_STR
5569        NEIGHBOR_ADDR_STR2
5570        "BGP ttl-security parameters\n"
5571        "Specify the maximum number of hops to the BGP peer\n"
5572        "Number of hops to BGP peer\n")
5573 {
5574   int idx_peer = 2;
5575   struct peer *peer;
5576
5577   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5578   if (! peer)
5579     return CMD_WARNING;
5580
5581   return bgp_vty_return (vty, peer_ttl_security_hops_unset (peer));
5582 }
5583
5584 DEFUN (neighbor_addpath_tx_all_paths,
5585        neighbor_addpath_tx_all_paths_cmd,
5586        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
5587        NEIGHBOR_STR
5588        NEIGHBOR_ADDR_STR2
5589        "Use addpath to advertise all paths to a neighbor\n")
5590 {
5591   int idx_peer = 1;
5592   struct peer *peer;
5593
5594   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5595   if (! peer)
5596     return CMD_WARNING;
5597
5598   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5599                                bgp_node_safi (vty),
5600                                PEER_FLAG_ADDPATH_TX_ALL_PATHS);
5601 }
5602
5603 DEFUN (no_neighbor_addpath_tx_all_paths,
5604        no_neighbor_addpath_tx_all_paths_cmd,
5605        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-all-paths",
5606        NO_STR
5607        NEIGHBOR_STR
5608        NEIGHBOR_ADDR_STR2
5609        "Use addpath to advertise all paths to a neighbor\n")
5610 {
5611   int idx_peer = 2;
5612   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5613                                  bgp_node_safi (vty),
5614                                  PEER_FLAG_ADDPATH_TX_ALL_PATHS);
5615 }
5616
5617 DEFUN (neighbor_addpath_tx_bestpath_per_as,
5618        neighbor_addpath_tx_bestpath_per_as_cmd,
5619        "neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
5620        NEIGHBOR_STR
5621        NEIGHBOR_ADDR_STR2
5622        "Use addpath to advertise the bestpath per each neighboring AS\n")
5623 {
5624   int idx_peer = 1;
5625   struct peer *peer;
5626
5627   peer = peer_and_group_lookup_vty (vty, argv[idx_peer]->arg);
5628   if (! peer)
5629     return CMD_WARNING;
5630
5631   return peer_af_flag_set_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5632                                bgp_node_safi (vty),
5633                                PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS);
5634 }
5635
5636 DEFUN (no_neighbor_addpath_tx_bestpath_per_as,
5637        no_neighbor_addpath_tx_bestpath_per_as_cmd,
5638        "no neighbor <A.B.C.D|X:X::X:X|WORD> addpath-tx-bestpath-per-AS",
5639        NO_STR
5640        NEIGHBOR_STR
5641        NEIGHBOR_ADDR_STR2
5642        "Use addpath to advertise the bestpath per each neighboring AS\n")
5643 {
5644   int idx_peer = 2;
5645   return peer_af_flag_unset_vty (vty, argv[idx_peer]->arg, bgp_node_afi (vty),
5646                                  bgp_node_safi (vty),
5647                                  PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS);
5648 }
5649
5650 DEFUN_NOSH (address_family_ipv4_safi,
5651        address_family_ipv4_safi_cmd,
5652        "address-family ipv4 [<unicast|multicast|vpn|encap>]",
5653        "Enter Address Family command mode\n"
5654        "Address Family\n"
5655        BGP_SAFI_HELP_STR)
5656 {
5657   int idx_safi = 2;
5658   if (argc == (idx_safi + 1))
5659     {
5660       switch (bgp_vty_safi_from_arg(argv[idx_safi]->arg))
5661         {
5662         case SAFI_MULTICAST:
5663           vty->node = BGP_IPV4M_NODE;
5664           break;
5665         case SAFI_ENCAP:
5666           vty->node = BGP_ENCAP_NODE;
5667           break;
5668         case SAFI_MPLS_VPN:
5669           vty->node = BGP_VPNV4_NODE;
5670           break;
5671         case SAFI_UNICAST:
5672         default:
5673           vty->node = BGP_IPV4_NODE;
5674           break;
5675         }
5676     }
5677   else
5678     vty->node = BGP_IPV4_NODE;
5679
5680   return CMD_SUCCESS;
5681 }
5682
5683 DEFUN_NOSH (address_family_ipv6_safi,
5684        address_family_ipv6_safi_cmd,
5685        "address-family ipv6 [<unicast|multicast|vpn|encap>]",
5686        "Enter Address Family command mode\n"
5687        "Address Family\n"
5688        BGP_SAFI_HELP_STR)
5689 {
5690   int idx_safi = 2;
5691   if (argc == (idx_safi + 1))
5692     {
5693       switch (bgp_vty_safi_from_arg(argv[idx_safi]->arg))
5694         {
5695         case SAFI_MULTICAST:
5696           vty->node = BGP_IPV6M_NODE;
5697           break;
5698         case SAFI_ENCAP:
5699           vty->node = BGP_ENCAPV6_NODE;
5700           break;
5701         case SAFI_MPLS_VPN:
5702           vty->node = BGP_VPNV6_NODE;
5703           break;
5704         case SAFI_UNICAST:
5705         default:
5706           vty->node = BGP_IPV6_NODE;
5707           break;
5708         }
5709     }
5710   else
5711     vty->node = BGP_IPV6_NODE;
5712
5713   return CMD_SUCCESS;
5714 }
5715
5716 #ifdef KEEP_OLD_VPN_COMMANDS
5717 DEFUN_NOSH (address_family_vpnv4,
5718        address_family_vpnv4_cmd,
5719        "address-family vpnv4 [unicast]",
5720        "Enter Address Family command mode\n"
5721        "Address Family\n"
5722        "Address Family modifier\n")
5723 {
5724   vty->node = BGP_VPNV4_NODE;
5725   return CMD_SUCCESS;
5726 }
5727
5728 DEFUN_NOSH (address_family_vpnv6,
5729        address_family_vpnv6_cmd,
5730        "address-family vpnv6 [unicast]",
5731        "Enter Address Family command mode\n"
5732        "Address Family\n"
5733        "Address Family modifier\n")
5734 {
5735   vty->node = BGP_VPNV6_NODE;
5736   return CMD_SUCCESS;
5737 }
5738 #endif
5739
5740 DEFUN_NOSH (address_family_encap,
5741        address_family_encap_cmd,
5742        "address-family <encap|encapv4>",
5743        "Enter Address Family command mode\n"
5744        "Address Family\n"
5745        "Address Family\n")
5746 {
5747   vty->node = BGP_ENCAP_NODE;
5748   return CMD_SUCCESS;
5749 }
5750
5751
5752 DEFUN_NOSH (address_family_encapv6,
5753        address_family_encapv6_cmd,
5754        "address-family encapv6",
5755        "Enter Address Family command mode\n"
5756        "Address Family\n")
5757 {
5758   vty->node = BGP_ENCAPV6_NODE;
5759   return CMD_SUCCESS;
5760 }
5761
5762 DEFUN_NOSH (address_family_evpn,
5763        address_family_evpn_cmd,
5764        "address-family <l2vpn evpn>",
5765        "Enter Address Family command mode\n"
5766        "EVPN Address family\n"
5767        "Layer2 VPN Address family\n"
5768        "Ethernet Virtual Private Network Subsequent Address Family\n")
5769 {
5770   vty->node = BGP_EVPN_NODE;
5771   return CMD_SUCCESS;
5772 }
5773
5774 DEFUN_NOSH (exit_address_family,
5775        exit_address_family_cmd,
5776        "exit-address-family",
5777        "Exit from Address Family configuration mode\n")
5778 {
5779   if (vty->node == BGP_IPV4_NODE
5780       || vty->node == BGP_IPV4M_NODE
5781       || vty->node == BGP_VPNV4_NODE
5782       || vty->node == BGP_IPV6_NODE
5783       || vty->node == BGP_IPV6M_NODE
5784       || vty->node == BGP_VPNV6_NODE
5785       || vty->node == BGP_ENCAP_NODE
5786       || vty->node == BGP_ENCAPV6_NODE
5787       || vty->node == BGP_EVPN_NODE)
5788     vty->node = BGP_NODE;
5789   return CMD_SUCCESS;
5790 }
5791
5792 /* Recalculate bestpath and re-advertise a prefix */
5793 static int
5794 bgp_clear_prefix (struct vty *vty, const char *view_name, const char *ip_str,
5795                   afi_t afi, safi_t safi, struct prefix_rd *prd)
5796 {
5797   int ret;
5798   struct prefix match;
5799   struct bgp_node *rn;
5800   struct bgp_node *rm;
5801   struct bgp *bgp;
5802   struct bgp_table *table;
5803   struct bgp_table *rib;
5804
5805   /* BGP structure lookup. */
5806   if (view_name)
5807     {
5808       bgp = bgp_lookup_by_name (view_name);
5809       if (bgp == NULL)
5810         {
5811           vty_out (vty, "%% Can't find BGP instance %s%s", view_name, VTY_NEWLINE);
5812           return CMD_WARNING;
5813         }
5814     }
5815   else
5816     {
5817       bgp = bgp_get_default ();
5818       if (bgp == NULL)
5819         {
5820           vty_out (vty, "%% No BGP process is configured%s", VTY_NEWLINE);
5821           return CMD_WARNING;
5822         }
5823     }
5824
5825   /* Check IP address argument. */
5826   ret = str2prefix (ip_str, &match);
5827   if (! ret)
5828     {
5829       vty_out (vty, "%% address is malformed%s", VTY_NEWLINE);
5830       return CMD_WARNING;
5831     }
5832
5833   match.family = afi2family (afi);
5834   rib = bgp->rib[afi][safi];
5835
5836   if (safi == SAFI_MPLS_VPN)
5837     {
5838       for (rn = bgp_table_top (rib); rn; rn = bgp_route_next (rn))
5839         {
5840           if (prd && memcmp (rn->p.u.val, prd->val, 8) != 0)
5841             continue;
5842
5843           if ((table = rn->info) != NULL)
5844             {
5845               if ((rm = bgp_node_match (table, &match)) != NULL)
5846                 {
5847                   if (rm->p.prefixlen == match.prefixlen)
5848                     {
5849                       SET_FLAG (rn->flags, BGP_NODE_USER_CLEAR);
5850                       bgp_process (bgp, rm, afi, safi);
5851                     }
5852                   bgp_unlock_node (rm);
5853                 }
5854             }
5855         }
5856     }
5857   else
5858     {
5859       if ((rn = bgp_node_match (rib, &match)) != NULL)
5860         {
5861           if (rn->p.prefixlen == match.prefixlen)
5862             {
5863               SET_FLAG (rn->flags, BGP_NODE_USER_CLEAR);
5864               bgp_process (bgp, rn, afi, safi);
5865             }
5866           bgp_unlock_node (rn);
5867         }
5868     }
5869
5870   return CMD_SUCCESS;
5871 }
5872
5873 /* one clear bgp command to rule them all */
5874 DEFUN (clear_ip_bgp_all,
5875        clear_ip_bgp_all_cmd,
5876        "clear [ip] bgp [<view|vrf> WORD] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group WORD> [<soft [<in|out>]|in [prefix-filter]|out>]",
5877        CLEAR_STR
5878        IP_STR
5879        BGP_STR
5880        BGP_INSTANCE_HELP_STR
5881        "Clear all peers\n"
5882        "BGP neighbor address to clear\n"
5883        "BGP IPv6 neighbor to clear\n"
5884        "BGP neighbor on interface to clear\n"
5885        "Clear peers with the AS number\n"
5886        "Clear all external peers\n"
5887        "Clear all members of peer-group\n"
5888        "BGP peer-group name\n"
5889        BGP_AFI_HELP_STR
5890        BGP_SAFI_HELP_STR
5891        BGP_SOFT_STR
5892        BGP_SOFT_IN_STR
5893        BGP_SOFT_OUT_STR
5894        BGP_SOFT_IN_STR
5895        "Push out prefix-list ORF and do inbound soft reconfig\n"
5896        BGP_SOFT_OUT_STR)
5897 {
5898   VTY_DECLVAR_CONTEXT(bgp, bgp);
5899   char *vrf = NULL;
5900
5901   afi_t afi = AFI_IP6;
5902   safi_t safi = SAFI_UNICAST;
5903   enum clear_sort clr_sort = clear_peer;
5904   enum bgp_clear_type clr_type;
5905   char *clr_arg = NULL;
5906
5907   int idx = 0;
5908
5909   /* clear [ip] bgp */
5910   if (argv_find (argv, argc, "ip", &idx))
5911     afi = AFI_IP;
5912   /* [<view|vrf> WORD] */
5913   if (argv_find (argv, argc, "view", &idx) || argv_find (argv, argc, "vrf", &idx))
5914     {
5915       vrf = argv[idx + 1]->arg;
5916       idx += 2;
5917     }
5918   /* <*|A.B.C.D|X:X::X:X|WORD|(1-4294967295)|external|peer-group WORD> */
5919   if (argv_find (argv, argc, "*", &idx))
5920     {
5921       clr_sort = clear_all;
5922     }
5923   else if (argv_find (argv, argc, "A.B.C.D", &idx))
5924     {
5925       clr_sort = clear_peer;
5926       clr_arg = argv[idx]->arg;
5927     }
5928   else if (argv_find (argv, argc, "X:X::X:X", &idx))
5929     {
5930       clr_sort = clear_peer;
5931       clr_arg = argv[idx]->arg;
5932     }
5933   else if (argv_find (argv, argc, "peer-group", &idx))
5934     {
5935       clr_sort = clear_group;
5936       idx++;
5937       clr_arg = argv[idx]->arg;
5938
5939       if (! peer_group_lookup (bgp, clr_arg))
5940         {
5941           vty_out (vty, "%% No such peer-group%s", VTY_NEWLINE);
5942           return CMD_WARNING;
5943         }
5944     }
5945   else if (argv_find (argv, argc, "WORD", &idx))
5946     {
5947       if (peer_lookup_by_conf_if (bgp, argv[idx]->arg))
5948         {
5949           clr_sort = clear_peer;
5950           clr_arg = argv[idx]->arg;
5951         }
5952       else
5953         {
5954           vty_out (vty, "%% No such neighbor%s", VTY_NEWLINE);
5955           return CMD_WARNING;
5956         }
5957     }
5958   else if (argv_find (argv, argc, "(1-4294967295)", &idx))
5959     {
5960       clr_sort = clear_as;
5961       clr_arg = argv[idx]->arg;
5962     }
5963   else if (argv_find (argv, argc, "external", &idx))
5964     {
5965       clr_sort = clear_external;
5966     }
5967   /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
5968   if (argv_find_and_parse_afi (argv, argc, &idx, &afi))
5969     {
5970       argv_find_and_parse_safi (argv, argc, &idx, &safi);
5971     }
5972   /* [<soft [<in|out>]|in [prefix-filter]|out>] */
5973   if (argv_find (argv, argc, "soft", &idx))
5974     {
5975       if (argv_find (argv, argc, "in", &idx) || argv_find (argv, argc, "out", &idx))
5976         clr_type = strmatch (argv[idx]->text, "in") ? BGP_CLEAR_SOFT_IN : BGP_CLEAR_SOFT_OUT;
5977       else
5978         clr_type = BGP_CLEAR_SOFT_BOTH;
5979     }
5980   else if (argv_find (argv, argc, "in", &idx))
5981     {
5982       clr_type = argv_find (argv, argc, "prefix-filter", &idx) ? BGP_CLEAR_SOFT_IN_ORF_PREFIX : BGP_CLEAR_SOFT_IN;
5983     }
5984   else if (argv_find (argv, argc, "out", &idx))
5985     {
5986       clr_type = BGP_CLEAR_SOFT_OUT;
5987     }
5988   else
5989     clr_type = BGP_CLEAR_SOFT_NONE;
5990
5991   return bgp_clear_vty (vty, vrf, afi, safi, clr_sort, clr_type, clr_arg);
5992 }
5993
5994 DEFUN (clear_ip_bgp_prefix,
5995        clear_ip_bgp_prefix_cmd,
5996        "clear [ip] bgp [<view|vrf> WORD] prefix A.B.C.D/M",
5997        CLEAR_STR
5998        IP_STR
5999        BGP_STR
6000        BGP_INSTANCE_HELP_STR
6001        "Clear bestpath and re-advertise\n"
6002        "IPv4 prefix\n")
6003 {
6004   char *vrf = NULL;
6005   char *prefix = NULL;
6006
6007   int idx = 0;
6008
6009   /* [<view|vrf> WORD] */
6010   if (argv_find (argv, argc, "WORD", &idx))
6011     vrf = argv[idx]->arg;
6012
6013   prefix = argv[argc-1]->arg;
6014
6015   return bgp_clear_prefix (vty, vrf, prefix, AFI_IP, SAFI_UNICAST, NULL);
6016 }
6017
6018 DEFUN (clear_bgp_ipv6_safi_prefix,
6019        clear_bgp_ipv6_safi_prefix_cmd,
6020        "clear [ip] bgp ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
6021        CLEAR_STR
6022        IP_STR
6023        BGP_STR
6024        "Address Family\n"
6025        BGP_SAFI_HELP_STR
6026        "Clear bestpath and re-advertise\n"
6027        "IPv6 prefix\n")
6028 {
6029   int idx_safi = 3;
6030   int idx_ipv6_prefixlen = 5;
6031   return bgp_clear_prefix (vty, NULL, argv[idx_ipv6_prefixlen]->arg, AFI_IP6,
6032                            bgp_vty_safi_from_arg(argv[idx_safi]->arg), NULL);
6033 }
6034
6035 DEFUN (clear_bgp_instance_ipv6_safi_prefix,
6036        clear_bgp_instance_ipv6_safi_prefix_cmd,
6037        "clear [ip] bgp <view|vrf> WORD ipv6 "BGP_SAFI_CMD_STR" prefix X:X::X:X/M",
6038        CLEAR_STR
6039        IP_STR
6040        BGP_STR
6041        BGP_INSTANCE_HELP_STR
6042        "Address Family\n"
6043        BGP_SAFI_HELP_STR
6044        "Clear bestpath and re-advertise\n"
6045        "IPv6 prefix\n")
6046 {
6047   int idx_word = 3;
6048   int idx_safi = 5;
6049   int idx_ipv6_prefixlen = 7;
6050   return bgp_clear_prefix (vty, argv[idx_word]->arg, argv[idx_ipv6_prefixlen]->arg, AFI_IP6,
6051                            bgp_vty_safi_from_arg(argv[idx_safi]->arg), NULL);
6052 }
6053
6054 DEFUN (show_bgp_views,
6055        show_bgp_views_cmd,
6056        "show [ip] bgp views",
6057        SHOW_STR
6058        IP_STR
6059        BGP_STR
6060        "Show the defined BGP views\n")
6061 {
6062   struct list *inst = bm->bgp;
6063   struct listnode *node;
6064   struct bgp *bgp;
6065
6066   if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
6067     {
6068       vty_out (vty, "BGP Multiple Instance is not enabled%s", VTY_NEWLINE);
6069       return CMD_WARNING;
6070     }
6071
6072   vty_out (vty, "Defined BGP views:%s", VTY_NEWLINE);
6073   for (ALL_LIST_ELEMENTS_RO(inst, node, bgp))
6074     {
6075       /* Skip VRFs. */
6076       if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
6077         continue;
6078       vty_out (vty, "\t%s (AS%u)%s",
6079                bgp->name ? bgp->name : "(null)",
6080                bgp->as, VTY_NEWLINE);
6081     }
6082
6083   return CMD_SUCCESS;
6084 }
6085
6086 DEFUN (show_bgp_vrfs,
6087        show_bgp_vrfs_cmd,
6088        "show [ip] bgp vrfs [json]",
6089        SHOW_STR
6090        IP_STR
6091        BGP_STR
6092        "Show BGP VRFs\n"
6093        JSON_STR)
6094 {
6095   struct list *inst = bm->bgp;
6096   struct listnode *node;
6097   struct bgp *bgp;
6098   u_char uj = use_json(argc, argv);
6099   json_object *json = NULL;
6100   json_object *json_vrfs = NULL;
6101   int count = 0;
6102   static char header[] = "Type  Id     RouterId          #PeersCfg  #PeersEstb  Name";
6103
6104   if (!bgp_option_check (BGP_OPT_MULTIPLE_INSTANCE))
6105     {
6106       vty_out (vty, "BGP Multiple Instance is not enabled%s", VTY_NEWLINE);
6107       return CMD_WARNING;
6108     }
6109
6110   if (uj)
6111     {
6112       json = json_object_new_object();
6113       json_vrfs = json_object_new_object();
6114     }
6115
6116   for (ALL_LIST_ELEMENTS_RO(inst, node, bgp))
6117     {
6118       const char *name, *type;
6119       struct peer *peer;
6120       struct listnode *node, *nnode;
6121       int peers_cfg, peers_estb;
6122       json_object *json_vrf = NULL;
6123       int vrf_id_ui;
6124
6125       /* Skip Views. */
6126       if (bgp->inst_type == BGP_INSTANCE_TYPE_VIEW)
6127         continue;
6128
6129       count++;
6130       if (!uj && count == 1)
6131         vty_out (vty, "%s%s", header, VTY_NEWLINE);
6132
6133       peers_cfg = peers_estb = 0;
6134       if (uj)
6135         json_vrf = json_object_new_object();
6136
6137
6138       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
6139         {
6140           if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
6141             continue;
6142           peers_cfg++;
6143           if (peer->status == Established)
6144             peers_estb++;
6145         }
6146
6147       if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
6148         {
6149           name = "Default";
6150           type = "DFLT";
6151         }
6152       else
6153         {
6154           name = bgp->name;
6155           type = "VRF";
6156         }
6157
6158       vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN) ? -1 : bgp->vrf_id;
6159       if (uj)
6160         {
6161           json_object_string_add(json_vrf, "type", type);
6162           json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
6163           json_object_string_add(json_vrf, "routerId", inet_ntoa (bgp->router_id));
6164           json_object_int_add(json_vrf, "numConfiguredPeers", peers_cfg);
6165           json_object_int_add(json_vrf, "numEstablishedPeers", peers_estb);
6166
6167           json_object_object_add(json_vrfs, name, json_vrf);
6168         }
6169       else
6170         vty_out (vty, "%4s  %-5d  %-16s  %9u  %10u  %s%s",
6171                  type, vrf_id_ui, inet_ntoa (bgp->router_id),
6172                  peers_cfg, peers_estb, name,
6173                  VTY_NEWLINE);
6174     }
6175
6176   if (uj)
6177     {
6178       json_object_object_add(json, "vrfs", json_vrfs);
6179
6180       json_object_int_add(json, "totalVrfs", count);
6181
6182       vty_out (vty, "%s%s", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY), VTY_NEWLINE);
6183       json_object_free(json);
6184     }
6185   else
6186     {
6187       if (count)
6188         vty_out (vty, "%sTotal number of VRFs (including default): %d%s",
6189                  VTY_NEWLINE, count, VTY_NEWLINE);
6190     }
6191
6192   return CMD_SUCCESS;
6193 }
6194
6195 DEFUN (show_bgp_memory,
6196        show_bgp_memory_cmd,
6197        "show [ip] bgp memory",
6198        SHOW_STR
6199        IP_STR
6200        BGP_STR
6201        "Global BGP memory statistics\n")
6202 {
6203   char memstrbuf[MTYPE_MEMSTR_LEN];
6204   unsigned long count;
6205
6206   /* RIB related usage stats */
6207   count = mtype_stats_alloc (MTYPE_BGP_NODE);
6208   vty_out (vty, "%ld RIB nodes, using %s of memory%s", count,
6209            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6210                          count * sizeof (struct bgp_node)),
6211            VTY_NEWLINE);
6212
6213   count = mtype_stats_alloc (MTYPE_BGP_ROUTE);
6214   vty_out (vty, "%ld BGP routes, using %s of memory%s", count,
6215            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6216                          count * sizeof (struct bgp_info)),
6217            VTY_NEWLINE);
6218   if ((count = mtype_stats_alloc (MTYPE_BGP_ROUTE_EXTRA)))
6219     vty_out (vty, "%ld BGP route ancillaries, using %s of memory%s", count,
6220              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6221                            count * sizeof (struct bgp_info_extra)),
6222              VTY_NEWLINE);
6223
6224   if ((count = mtype_stats_alloc (MTYPE_BGP_STATIC)))
6225     vty_out (vty, "%ld Static routes, using %s of memory%s", count,
6226              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6227                          count * sizeof (struct bgp_static)),
6228              VTY_NEWLINE);
6229
6230   if ((count = mtype_stats_alloc (MTYPE_BGP_PACKET)))
6231     vty_out (vty, "%ld Packets, using %s of memory%s", count,
6232              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6233                          count * sizeof (struct bpacket)),
6234              VTY_NEWLINE);
6235
6236   /* Adj-In/Out */
6237   if ((count = mtype_stats_alloc (MTYPE_BGP_ADJ_IN)))
6238     vty_out (vty, "%ld Adj-In entries, using %s of memory%s", count,
6239              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6240                            count * sizeof (struct bgp_adj_in)),
6241              VTY_NEWLINE);
6242   if ((count = mtype_stats_alloc (MTYPE_BGP_ADJ_OUT)))
6243     vty_out (vty, "%ld Adj-Out entries, using %s of memory%s", count,
6244              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6245                            count * sizeof (struct bgp_adj_out)),
6246              VTY_NEWLINE);
6247
6248   if ((count = mtype_stats_alloc (MTYPE_BGP_NEXTHOP_CACHE)))
6249     vty_out (vty, "%ld Nexthop cache entries, using %s of memory%s", count,
6250              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6251                          count * sizeof (struct bgp_nexthop_cache)),
6252              VTY_NEWLINE);
6253
6254   if ((count = mtype_stats_alloc (MTYPE_BGP_DAMP_INFO)))
6255     vty_out (vty, "%ld Dampening entries, using %s of memory%s", count,
6256              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6257                          count * sizeof (struct bgp_damp_info)),
6258              VTY_NEWLINE);
6259
6260   /* Attributes */
6261   count = attr_count();
6262   vty_out (vty, "%ld BGP attributes, using %s of memory%s", count,
6263            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6264                          count * sizeof(struct attr)),
6265            VTY_NEWLINE);
6266   if ((count = mtype_stats_alloc (MTYPE_ATTR_EXTRA)))
6267     vty_out (vty, "%ld BGP extra attributes, using %s of memory%s", count,
6268              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6269                            count * sizeof(struct attr_extra)),
6270              VTY_NEWLINE);
6271
6272   if ((count = attr_unknown_count()))
6273     vty_out (vty, "%ld unknown attributes%s", count, VTY_NEWLINE);
6274
6275   /* AS_PATH attributes */
6276   count = aspath_count ();
6277   vty_out (vty, "%ld BGP AS-PATH entries, using %s of memory%s", count,
6278            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6279                          count * sizeof (struct aspath)),
6280            VTY_NEWLINE);
6281
6282   count = mtype_stats_alloc (MTYPE_AS_SEG);
6283   vty_out (vty, "%ld BGP AS-PATH segments, using %s of memory%s", count,
6284            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6285                          count * sizeof (struct assegment)),
6286            VTY_NEWLINE);
6287
6288   /* Other attributes */
6289   if ((count = community_count ()))
6290     vty_out (vty, "%ld BGP community entries, using %s of memory%s", count,
6291              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6292                          count * sizeof (struct community)),
6293              VTY_NEWLINE);
6294   if ((count = mtype_stats_alloc (MTYPE_ECOMMUNITY)))
6295     vty_out (vty, "%ld BGP community entries, using %s of memory%s", count,
6296              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6297                          count * sizeof (struct ecommunity)),
6298              VTY_NEWLINE);
6299   if ((count = mtype_stats_alloc (MTYPE_LCOMMUNITY)))
6300     vty_out (vty, "%ld BGP large-community entries, using %s of memory%s",
6301              count,
6302              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6303                          count * sizeof (struct lcommunity)),
6304              VTY_NEWLINE);
6305
6306   if ((count = mtype_stats_alloc (MTYPE_CLUSTER)))
6307     vty_out (vty, "%ld Cluster lists, using %s of memory%s", count,
6308              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6309                          count * sizeof (struct cluster_list)),
6310              VTY_NEWLINE);
6311
6312   /* Peer related usage */
6313   count = mtype_stats_alloc (MTYPE_BGP_PEER);
6314   vty_out (vty, "%ld peers, using %s of memory%s", count,
6315            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6316                          count * sizeof (struct peer)),
6317            VTY_NEWLINE);
6318
6319   if ((count = mtype_stats_alloc (MTYPE_PEER_GROUP)))
6320     vty_out (vty, "%ld peer groups, using %s of memory%s", count,
6321              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6322                            count * sizeof (struct peer_group)),
6323              VTY_NEWLINE);
6324
6325   /* Other */
6326   if ((count = mtype_stats_alloc (MTYPE_HASH)))
6327     vty_out (vty, "%ld hash tables, using %s of memory%s", count,
6328              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6329                            count * sizeof (struct hash)),
6330              VTY_NEWLINE);
6331   if ((count = mtype_stats_alloc (MTYPE_HASH_BACKET)))
6332     vty_out (vty, "%ld hash buckets, using %s of memory%s", count,
6333              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6334                            count * sizeof (struct hash_backet)),
6335              VTY_NEWLINE);
6336   if ((count = mtype_stats_alloc (MTYPE_BGP_REGEXP)))
6337     vty_out (vty, "%ld compiled regexes, using %s of memory%s", count,
6338              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6339                            count * sizeof (regex_t)),
6340              VTY_NEWLINE);
6341   return CMD_SUCCESS;
6342 }
6343
6344 /* Show BGP peer's summary information. */
6345 static int
6346 bgp_show_summary (struct vty *vty, struct bgp *bgp, int afi, int safi,
6347                   u_char use_json, json_object *json)
6348 {
6349   struct peer *peer;
6350   struct listnode *node, *nnode;
6351   unsigned int count = 0, dn_count = 0;
6352   char timebuf[BGP_UPTIME_LEN], dn_flag[2];
6353   char neighbor_buf[VTY_BUFSIZ];
6354   int neighbor_col_default_width = 16;
6355   int len;
6356   int max_neighbor_width = 0;
6357   json_object *json_peer = NULL;
6358   json_object *json_peers = NULL;
6359
6360   if (use_json)
6361     {
6362       if (json == NULL)
6363         json = json_object_new_object();
6364
6365       json_peers = json_object_new_object();
6366     }
6367   else
6368     {
6369       /* Loop over all neighbors that will be displayed to determine how many
6370        * characters are needed for the Neighbor column
6371        */
6372       for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
6373         {
6374           if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
6375             continue;
6376
6377           if (peer->afc[afi][safi])
6378             {
6379               memset(dn_flag, '\0', sizeof(dn_flag));
6380               if (peer_dynamic_neighbor(peer))
6381                 dn_flag[0] = '*';
6382
6383               if (peer->hostname && bgp_flag_check(bgp, BGP_FLAG_SHOW_HOSTNAME))
6384                 sprintf(neighbor_buf, "%s%s(%s) ", dn_flag, peer->hostname, peer->host);
6385               else
6386                 sprintf(neighbor_buf, "%s%s ", dn_flag, peer->host);
6387
6388               len = strlen(neighbor_buf);
6389
6390               if (len > max_neighbor_width)
6391                 max_neighbor_width = len;
6392             }
6393         }
6394
6395         /* Originally we displayed the Neighbor column as 16
6396          * characters wide so make that the default
6397          */
6398         if (max_neighbor_width < neighbor_col_default_width)
6399           max_neighbor_width = neighbor_col_default_width;
6400     }
6401
6402   for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
6403     {
6404       if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
6405         continue;
6406
6407       if (peer->afc[afi][safi])
6408         {
6409           if (!count)
6410             {
6411               unsigned long ents;
6412               char memstrbuf[MTYPE_MEMSTR_LEN];
6413               int vrf_id_ui;
6414
6415               vrf_id_ui = (bgp->vrf_id == VRF_UNKNOWN) ? -1 : bgp->vrf_id;
6416
6417               /* Usage summary and header */
6418               if (use_json)
6419                 {
6420                   json_object_string_add(json, "routerId", inet_ntoa (bgp->router_id));
6421                   json_object_int_add(json, "as", bgp->as);
6422                   json_object_int_add(json, "vrfId", vrf_id_ui);
6423                   json_object_string_add(json, "vrfName",
6424                                          (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
6425                                          ? "Default" : bgp->name);
6426                 }
6427               else
6428                 {
6429                   vty_out (vty,
6430                            "BGP router identifier %s, local AS number %u vrf-id %d",
6431                            inet_ntoa (bgp->router_id), bgp->as, vrf_id_ui);
6432                   vty_out (vty, "%s", VTY_NEWLINE);
6433                 }
6434
6435               if (bgp_update_delay_configured(bgp))
6436                 {
6437                   if (use_json)
6438                     {
6439                       json_object_int_add(json, "updateDelayLimit", bgp->v_update_delay);
6440
6441                       if (bgp->v_update_delay != bgp->v_establish_wait)
6442                         json_object_int_add(json, "updateDelayEstablishWait", bgp->v_establish_wait);
6443
6444                       if (bgp_update_delay_active(bgp))
6445                         {
6446                           json_object_string_add(json, "updateDelayFirstNeighbor", bgp->update_delay_begin_time);
6447                           json_object_boolean_true_add(json, "updateDelayInProgress");
6448                         }
6449                       else
6450                         {
6451                           if (bgp->update_delay_over)
6452                             {
6453                               json_object_string_add(json, "updateDelayFirstNeighbor",
6454                                                      bgp->update_delay_begin_time);
6455                               json_object_string_add(json, "updateDelayBestpathResumed",
6456                                                      bgp->update_delay_end_time);
6457                               json_object_string_add(json, "updateDelayZebraUpdateResume",
6458                                                      bgp->update_delay_zebra_resume_time);
6459                               json_object_string_add(json, "updateDelayPeerUpdateResume",
6460                                                      bgp->update_delay_peers_resume_time);
6461                             }
6462                         }
6463                     }
6464                   else
6465                     {
6466                       vty_out (vty, "Read-only mode update-delay limit: %d seconds%s",
6467                                bgp->v_update_delay, VTY_NEWLINE);
6468                       if (bgp->v_update_delay != bgp->v_establish_wait)
6469                         vty_out (vty, "                   Establish wait: %d seconds%s",
6470                                  bgp->v_establish_wait, VTY_NEWLINE);
6471
6472                       if (bgp_update_delay_active(bgp))
6473                         {
6474                           vty_out (vty, "  First neighbor established: %s%s",
6475                                    bgp->update_delay_begin_time, VTY_NEWLINE);
6476                           vty_out (vty, "  Delay in progress%s", VTY_NEWLINE);
6477                         }
6478                       else
6479                         {
6480                           if (bgp->update_delay_over)
6481                             {
6482                               vty_out (vty, "  First neighbor established: %s%s",
6483                                        bgp->update_delay_begin_time, VTY_NEWLINE);
6484                               vty_out (vty, "          Best-paths resumed: %s%s",
6485                                        bgp->update_delay_end_time, VTY_NEWLINE);
6486                               vty_out (vty, "        zebra update resumed: %s%s",
6487                                        bgp->update_delay_zebra_resume_time, VTY_NEWLINE);
6488                               vty_out (vty, "        peers update resumed: %s%s",
6489                                        bgp->update_delay_peers_resume_time, VTY_NEWLINE);
6490                             }
6491                         }
6492                     }
6493                 }
6494
6495               if (use_json)
6496                 {
6497                   if (bgp_maxmed_onstartup_configured(bgp) && bgp->maxmed_active)
6498                     json_object_boolean_true_add(json, "maxMedOnStartup");
6499                   if (bgp->v_maxmed_admin)
6500                     json_object_boolean_true_add(json, "maxMedAdministrative");
6501
6502                   json_object_int_add(json, "tableVersion", bgp_table_version(bgp->rib[afi][safi]));
6503
6504                   ents = bgp_table_count (bgp->rib[afi][safi]);
6505                   json_object_int_add(json, "ribCount", ents);
6506                   json_object_int_add(json, "ribMemory", ents * sizeof (struct bgp_node));
6507
6508                   ents = listcount (bgp->peer);
6509                   json_object_int_add(json, "peerCount", ents);
6510                   json_object_int_add(json, "peerMemory", ents * sizeof (struct peer));
6511
6512                   if ((ents = listcount (bgp->group)))
6513                     {
6514                       json_object_int_add(json, "peerGroupCount", ents);
6515                       json_object_int_add(json, "peerGroupMemory", ents * sizeof (struct peer_group));
6516                     }
6517
6518                   if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
6519                     json_object_boolean_true_add(json, "dampeningEnabled");
6520                 }
6521               else
6522                 {
6523                   if (bgp_maxmed_onstartup_configured(bgp) && bgp->maxmed_active)
6524                     vty_out (vty, "Max-med on-startup active%s", VTY_NEWLINE);
6525                   if (bgp->v_maxmed_admin)
6526                     vty_out (vty, "Max-med administrative active%s", VTY_NEWLINE);
6527
6528                  vty_out(vty, "BGP table version %" PRIu64 "%s",
6529                          bgp_table_version(bgp->rib[afi][safi]), VTY_NEWLINE);
6530
6531                   ents = bgp_table_count (bgp->rib[afi][safi]);
6532                   vty_out (vty, "RIB entries %ld, using %s of memory%s", ents,
6533                            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6534                                          ents * sizeof (struct bgp_node)),
6535                            VTY_NEWLINE);
6536
6537                   /* Peer related usage */
6538                   ents = listcount (bgp->peer);
6539                   vty_out (vty, "Peers %ld, using %s of memory%s",
6540                            ents,
6541                            mtype_memstr (memstrbuf, sizeof (memstrbuf),
6542                                          ents * sizeof (struct peer)),
6543                            VTY_NEWLINE);
6544
6545                   if ((ents = listcount (bgp->group)))
6546                     vty_out (vty, "Peer groups %ld, using %s of memory%s", ents,
6547                              mtype_memstr (memstrbuf, sizeof (memstrbuf),
6548                                            ents * sizeof (struct peer_group)),
6549                              VTY_NEWLINE);
6550
6551                   if (CHECK_FLAG (bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING))
6552                     vty_out (vty, "Dampening enabled.%s", VTY_NEWLINE);
6553                   vty_out (vty, "%s", VTY_NEWLINE);
6554
6555                   /* Subtract 8 here because 'Neighbor' is 8 characters */
6556                   vty_out (vty, "Neighbor");
6557                   vty_out (vty, "%*s", max_neighbor_width - 8, " ");
6558                   vty_out (vty, "V         AS MsgRcvd MsgSent   TblVer  InQ OutQ  Up/Down State/PfxRcd%s", VTY_NEWLINE);
6559                 }
6560             }
6561
6562           count++;
6563
6564           if (use_json)
6565             {
6566               json_peer = json_object_new_object();
6567
6568               if (peer_dynamic_neighbor(peer))
6569                 json_object_boolean_true_add(json_peer, "dynamicPeer");
6570
6571               if (peer->hostname)
6572                 json_object_string_add(json_peer, "hostname", peer->hostname);
6573
6574               if (peer->domainname)
6575                 json_object_string_add(json_peer, "domainname", peer->domainname);
6576
6577               json_object_int_add(json_peer, "remoteAs", peer->as);
6578               json_object_int_add(json_peer, "version", 4);
6579               json_object_int_add(json_peer, "msgRcvd",
6580                                   peer->open_in + peer->update_in + peer->keepalive_in
6581                                   + peer->notify_in + peer->refresh_in
6582                                   + peer->dynamic_cap_in);
6583               json_object_int_add(json_peer, "msgSent",
6584                                   peer->open_out + peer->update_out + peer->keepalive_out
6585                                   + peer->notify_out + peer->refresh_out
6586                                   + peer->dynamic_cap_out);
6587
6588               json_object_int_add(json_peer, "tableVersion", peer->version[afi][safi]);
6589               json_object_int_add(json_peer, "outq", peer->obuf->count);
6590               json_object_int_add(json_peer, "inq", 0);
6591               peer_uptime (peer->uptime, timebuf, BGP_UPTIME_LEN, use_json, json_peer);
6592               json_object_int_add(json_peer, "prefixReceivedCount", peer->pcount[afi][safi]);
6593
6594               if (CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
6595                 json_object_string_add(json_peer, "state", "Idle (Admin)");
6596               else if (CHECK_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW))
6597                 json_object_string_add(json_peer, "state", "Idle (PfxCt)");
6598               else
6599                 json_object_string_add(json_peer, "state", LOOKUP(bgp_status_msg, peer->status));
6600
6601               if (peer->conf_if)
6602                 json_object_string_add(json_peer, "idType", "interface");
6603               else if (peer->su.sa.sa_family == AF_INET)
6604                 json_object_string_add(json_peer, "idType", "ipv4");
6605               else if (peer->su.sa.sa_family == AF_INET6)
6606                 json_object_string_add(json_peer, "idType", "ipv6");
6607
6608               json_object_object_add(json_peers, peer->host, json_peer);
6609             }
6610           else
6611             {
6612               memset(dn_flag, '\0', sizeof(dn_flag));
6613               if (peer_dynamic_neighbor(peer))
6614                 {
6615                   dn_count++;
6616                   dn_flag[0] = '*';
6617                 }
6618
6619               if (peer->hostname && bgp_flag_check(bgp, BGP_FLAG_SHOW_HOSTNAME))
6620                 len = vty_out (vty, "%s%s(%s)", dn_flag, peer->hostname,
6621                                peer->host);
6622               else
6623                 len = vty_out (vty, "%s%s", dn_flag, peer->host);
6624
6625               /* pad the neighbor column with spaces */
6626               if (len < max_neighbor_width)
6627                 vty_out (vty, "%*s", max_neighbor_width - len, " ");
6628
6629               vty_out (vty, "4 %10u %7d %7d %8" PRIu64 " %4d %4zd %8s",
6630                        peer->as,
6631                        peer->open_in + peer->update_in + peer->keepalive_in
6632                        + peer->notify_in + peer->refresh_in
6633                        + peer->dynamic_cap_in,
6634                        peer->open_out + peer->update_out + peer->keepalive_out
6635                        + peer->notify_out + peer->refresh_out
6636                        + peer->dynamic_cap_out,
6637                        peer->version[afi][safi],
6638                        0,
6639                        peer->obuf->count,
6640                        peer_uptime (peer->uptime, timebuf, BGP_UPTIME_LEN, 0, NULL));
6641
6642               if (peer->status == Established)
6643                   vty_out (vty, " %12ld", peer->pcount[afi][safi]);
6644               else
6645                 {
6646                   if (CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
6647                     vty_out (vty, " Idle (Admin)");
6648                   else if (CHECK_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW))
6649                     vty_out (vty, " Idle (PfxCt)");
6650                   else
6651                     vty_out (vty, " %12s", LOOKUP(bgp_status_msg, peer->status));
6652                 }
6653               vty_out (vty, "%s", VTY_NEWLINE);
6654             }
6655         }
6656     }
6657
6658   if (use_json)
6659     {
6660       json_object_object_add(json, "peers", json_peers);
6661
6662       json_object_int_add(json, "totalPeers", count);
6663       json_object_int_add(json, "dynamicPeers", dn_count);
6664
6665       vty_out (vty, "%s%s", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY), VTY_NEWLINE);
6666       json_object_free(json);
6667     }
6668   else
6669     {
6670       if (count)
6671         vty_out (vty, "%sTotal number of neighbors %d%s", VTY_NEWLINE,
6672                 count, VTY_NEWLINE);
6673       else
6674         {
6675           if (use_json)
6676             vty_out(vty, "{\"error\": {\"message\": \"No %s neighbor configured\"}}%s",
6677                     afi_safi_print(afi, safi), VTY_NEWLINE);
6678           else
6679             vty_out (vty, "No %s neighbor is configured%s",
6680                      afi_safi_print(afi, safi), VTY_NEWLINE);
6681         }
6682
6683       if (dn_count && ! use_json)
6684         {
6685           vty_out(vty, "* - dynamic neighbor%s", VTY_NEWLINE);
6686           vty_out(vty,
6687                   "%d dynamic neighbor(s), limit %d%s",
6688                   dn_count, bgp->dynamic_neighbors_limit, VTY_NEWLINE);
6689         }
6690     }
6691
6692   return CMD_SUCCESS;
6693 }
6694
6695 static void
6696 bgp_show_summary_afi_safi (struct vty *vty, struct bgp *bgp, int afi, int safi,
6697                   u_char use_json, json_object *json)
6698 {
6699   int is_first      = 1;
6700   int afi_wildcard  = (afi == AFI_MAX);
6701   int safi_wildcard = (safi == SAFI_MAX);
6702   int is_wildcard   = (afi_wildcard || safi_wildcard);
6703   if (use_json && is_wildcard)
6704     vty_out (vty, "{%s", VTY_NEWLINE);
6705   if (afi_wildcard)
6706     afi = 1;                    /* AFI_IP */
6707   while (afi < AFI_MAX)
6708     {
6709       if (safi_wildcard)
6710         safi = 1;                 /* SAFI_UNICAST */
6711       while (safi < SAFI_MAX)
6712         {
6713           if (is_wildcard)
6714             {
6715               if (use_json)
6716                 {
6717                   json = json_object_new_object();
6718
6719                   if (! is_first)
6720                     vty_out (vty, ",%s", VTY_NEWLINE);
6721                   else
6722                     is_first = 0;
6723
6724                   vty_out(vty, "\"%s\":", afi_safi_json(afi, safi));
6725                 }
6726               else
6727                 {
6728                   vty_out (vty, "%s%s Summary:%s",
6729                            VTY_NEWLINE, afi_safi_print(afi, safi), VTY_NEWLINE);
6730                 }
6731             }
6732           bgp_show_summary (vty, bgp, afi, safi, use_json, json);
6733           safi++;
6734           if (safi == SAFI_RESERVED_4 ||
6735               safi == SAFI_RESERVED_5) /* handle special cases to match zebra.h */
6736             safi++;
6737           if (! safi_wildcard)
6738             safi = SAFI_MAX;
6739         }
6740       afi++;
6741       if (! afi_wildcard ||
6742           afi == AFI_L2VPN)       /* special case, not handled yet */
6743         afi = AFI_MAX;
6744     }
6745
6746   if (use_json && is_wildcard)
6747     vty_out (vty, "}%s", VTY_NEWLINE);
6748
6749 }
6750
6751 static void
6752 bgp_show_all_instances_summary_vty (struct vty *vty, afi_t afi, safi_t safi,
6753                                     u_char use_json)
6754 {
6755   struct listnode *node, *nnode;
6756   struct bgp *bgp;
6757   json_object *json = NULL;
6758   int is_first = 1;
6759
6760   if (use_json)
6761     vty_out (vty, "{%s", VTY_NEWLINE);
6762
6763   for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
6764     {
6765       if (use_json)
6766         {
6767           json = json_object_new_object();
6768
6769           if (! is_first)
6770             vty_out (vty, ",%s", VTY_NEWLINE);
6771           else
6772             is_first = 0;
6773
6774           vty_out(vty, "\"%s\":", (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
6775                   ? "Default" : bgp->name);
6776         }
6777       else
6778         {
6779           vty_out (vty, "%sInstance %s:%s",
6780                    VTY_NEWLINE,
6781                    (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
6782                    ? "Default" : bgp->name, VTY_NEWLINE);
6783         }
6784       bgp_show_summary_afi_safi (vty, bgp, afi, safi, use_json, json);
6785     }
6786
6787   if (use_json)
6788     vty_out (vty, "}%s", VTY_NEWLINE);
6789
6790 }
6791
6792 static int
6793 bgp_show_summary_vty (struct vty *vty, const char *name,
6794                       afi_t afi, safi_t safi, u_char use_json)
6795 {
6796   struct bgp *bgp;
6797
6798   if (name)
6799     {
6800       if (strmatch(name, "all"))
6801         {
6802           bgp_show_all_instances_summary_vty (vty, afi, safi, use_json);
6803           return CMD_SUCCESS;
6804         }
6805       else
6806         {
6807           bgp = bgp_lookup_by_name (name);
6808
6809           if (! bgp)
6810             {
6811               if (use_json)
6812                 vty_out (vty, "{}%s", VTY_NEWLINE);
6813               else
6814                 vty_out (vty, "%% No such BGP instance exist%s", VTY_NEWLINE);
6815               return CMD_WARNING;
6816             }
6817
6818           bgp_show_summary_afi_safi (vty, bgp, afi, safi, use_json, NULL);
6819           return CMD_SUCCESS;
6820         }
6821     }
6822
6823   bgp = bgp_get_default ();
6824
6825   if (bgp)
6826     bgp_show_summary_afi_safi (vty, bgp, afi, safi, use_json, NULL);
6827
6828   return CMD_SUCCESS;
6829 }
6830
6831 /* `show [ip] bgp summary' commands. */
6832 DEFUN (show_ip_bgp_summary,
6833        show_ip_bgp_summary_cmd,
6834        "show [ip] bgp [<view|vrf> WORD] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] summary [json]",
6835        SHOW_STR
6836        IP_STR
6837        BGP_STR
6838        BGP_INSTANCE_HELP_STR
6839        BGP_AFI_HELP_STR
6840        BGP_SAFI_HELP_STR
6841        "Summary of BGP neighbor status\n"
6842        JSON_STR)
6843 {
6844   char *vrf = NULL;
6845   afi_t afi = AFI_MAX;
6846   safi_t safi = SAFI_MAX;
6847
6848   int idx = 0;
6849
6850   /* show [ip] bgp */
6851   if (argv_find (argv, argc, "ip", &idx))
6852     afi = AFI_IP;
6853   /* [<view|vrf> WORD] */
6854   if (argv_find (argv, argc, "view", &idx) || argv_find (argv, argc, "vrf", &idx))
6855     vrf = argv[++idx]->arg;
6856   /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
6857   if (argv_find_and_parse_afi (argv, argc, &idx, &afi))
6858   {
6859     argv_find_and_parse_safi (argv, argc, &idx, &safi);
6860   }
6861
6862   int uj = use_json (argc, argv);
6863
6864   return bgp_show_summary_vty (vty, vrf, afi, safi, uj);
6865 }
6866
6867 const char *
6868 afi_safi_print (afi_t afi, safi_t safi)
6869 {
6870   if (afi == AFI_IP && safi == SAFI_UNICAST)
6871     return "IPv4 Unicast";
6872   else if (afi == AFI_IP && safi == SAFI_MULTICAST)
6873     return "IPv4 Multicast";
6874   else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
6875     return "IPv4 VPN";
6876   else if (afi == AFI_IP && safi == SAFI_ENCAP)
6877     return "IPv4 Encap";
6878   else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
6879     return "IPv6 Unicast";
6880   else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
6881     return "IPv6 Multicast";
6882   else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
6883     return "IPv6 VPN";
6884   else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
6885     return "IPv6 Encap";
6886   else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
6887     return "L2VPN EVPN";
6888   else
6889     return "Unknown";
6890 }
6891
6892 const char *
6893 afi_safi_json (afi_t afi, safi_t safi)
6894 {
6895   if (afi == AFI_IP && safi == SAFI_UNICAST)
6896     return "IPv4Unicast";
6897   else if (afi == AFI_IP && safi == SAFI_MULTICAST)
6898     return "IPv4Multicast";
6899   else if (afi == AFI_IP && safi == SAFI_MPLS_VPN)
6900     return "IPv4VPN";
6901   else if (afi == AFI_IP && safi == SAFI_ENCAP)
6902     return "IPv4Encap";
6903   else if (afi == AFI_IP6 && safi == SAFI_UNICAST)
6904     return "IPv6Unicast";
6905   else if (afi == AFI_IP6 && safi == SAFI_MULTICAST)
6906     return "IPv6Multicast";
6907   else if (afi == AFI_IP6 && safi == SAFI_MPLS_VPN)
6908     return "IPv6VPN";
6909   else if (afi == AFI_IP6 && safi == SAFI_ENCAP)
6910     return "IPv6Encap";
6911   else if (afi == AFI_L2VPN && safi == SAFI_EVPN)
6912     return "L2VPN EVPN";
6913   else
6914     return "Unknown";
6915 }
6916
6917 /* Show BGP peer's information. */
6918 enum show_type
6919 {
6920   show_all,
6921   show_peer
6922 };
6923
6924 static void
6925 bgp_show_peer_afi_orf_cap (struct vty *vty, struct peer *p, afi_t afi, safi_t safi,
6926                            u_int16_t adv_smcap, u_int16_t adv_rmcap, u_int16_t rcv_smcap,
6927                            u_int16_t rcv_rmcap, u_char use_json, json_object *json_pref)
6928 {
6929   /* Send-Mode */
6930   if (CHECK_FLAG (p->af_cap[afi][safi], adv_smcap)
6931       || CHECK_FLAG (p->af_cap[afi][safi], rcv_smcap))
6932     {
6933       if (use_json)
6934         {
6935           if (CHECK_FLAG (p->af_cap[afi][safi], adv_smcap) && CHECK_FLAG (p->af_cap[afi][safi], rcv_smcap))
6936             json_object_string_add(json_pref, "sendMode", "advertisedAndReceived");
6937           else if (CHECK_FLAG (p->af_cap[afi][safi], adv_smcap))
6938             json_object_string_add(json_pref, "sendMode", "advertised");
6939           else if (CHECK_FLAG (p->af_cap[afi][safi], rcv_smcap))
6940             json_object_string_add(json_pref, "sendMode", "received");
6941         }
6942       else
6943         {
6944           vty_out (vty, "      Send-mode: ");
6945           if (CHECK_FLAG (p->af_cap[afi][safi], adv_smcap))
6946             vty_out (vty, "advertised");
6947           if (CHECK_FLAG (p->af_cap[afi][safi], rcv_smcap))
6948             vty_out (vty, "%sreceived",
6949                      CHECK_FLAG (p->af_cap[afi][safi], adv_smcap) ?
6950                      ", " : "");
6951           vty_out (vty, "%s", VTY_NEWLINE);
6952         }
6953     }
6954
6955   /* Receive-Mode */
6956   if (CHECK_FLAG (p->af_cap[afi][safi], adv_rmcap)
6957       || CHECK_FLAG (p->af_cap[afi][safi], rcv_rmcap))
6958     {
6959       if (use_json)
6960         {
6961           if (CHECK_FLAG (p->af_cap[afi][safi], adv_rmcap) && CHECK_FLAG (p->af_cap[afi][safi], rcv_rmcap))
6962             json_object_string_add(json_pref, "recvMode", "advertisedAndReceived");
6963           else if (CHECK_FLAG (p->af_cap[afi][safi], adv_rmcap))
6964             json_object_string_add(json_pref, "recvMode", "advertised");
6965           else if (CHECK_FLAG (p->af_cap[afi][safi], rcv_rmcap))
6966             json_object_string_add(json_pref, "recvMode", "received");
6967         }
6968       else
6969         {
6970           vty_out (vty, "      Receive-mode: ");
6971           if (CHECK_FLAG (p->af_cap[afi][safi], adv_rmcap))
6972             vty_out (vty, "advertised");
6973           if (CHECK_FLAG (p->af_cap[afi][safi], rcv_rmcap))
6974             vty_out (vty, "%sreceived",
6975                      CHECK_FLAG (p->af_cap[afi][safi], adv_rmcap) ?
6976                      ", " : "");
6977           vty_out (vty, "%s", VTY_NEWLINE);
6978         }
6979     }
6980 }
6981
6982 static void
6983 bgp_show_peer_afi (struct vty *vty, struct peer *p, afi_t afi, safi_t safi,
6984                    u_char use_json, json_object *json_neigh)
6985 {
6986   struct bgp_filter *filter;
6987   struct peer_af *paf;
6988   char orf_pfx_name[BUFSIZ];
6989   int orf_pfx_count;
6990   json_object *json_af = NULL;
6991   json_object *json_prefA = NULL;
6992   json_object *json_prefB = NULL;
6993   json_object *json_addr = NULL;
6994
6995   if (use_json)
6996     {
6997       json_addr = json_object_new_object();
6998       json_af = json_object_new_object();
6999       filter = &p->filter[afi][safi];
7000
7001       if (peer_group_active(p))
7002         json_object_string_add(json_addr, "peerGroupMember", p->group->name);
7003
7004       paf = peer_af_find(p, afi, safi);
7005       if (paf && PAF_SUBGRP(paf))
7006         {
7007           json_object_int_add(json_addr, "updateGroupId", PAF_UPDGRP(paf)->id);
7008           json_object_int_add(json_addr, "subGroupId", PAF_SUBGRP(paf)->id);
7009           json_object_int_add(json_addr, "packetQueueLength", bpacket_queue_virtual_length(paf));
7010         }
7011
7012       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7013           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
7014           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7015           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
7016         {
7017           json_object_int_add(json_af, "orfType", ORF_TYPE_PREFIX);
7018           json_prefA = json_object_new_object();
7019           bgp_show_peer_afi_orf_cap (vty, p, afi, safi,
7020                                      PEER_CAP_ORF_PREFIX_SM_ADV,
7021                                      PEER_CAP_ORF_PREFIX_RM_ADV,
7022                                      PEER_CAP_ORF_PREFIX_SM_RCV,
7023                                      PEER_CAP_ORF_PREFIX_RM_RCV, use_json, json_prefA);
7024           json_object_object_add(json_af, "orfPrefixList", json_prefA);
7025         }
7026
7027       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7028           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
7029           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7030           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
7031         {
7032           json_object_int_add(json_af, "orfOldType", ORF_TYPE_PREFIX_OLD);
7033           json_prefB = json_object_new_object();
7034           bgp_show_peer_afi_orf_cap (vty, p, afi, safi,
7035                                      PEER_CAP_ORF_PREFIX_SM_ADV,
7036                                      PEER_CAP_ORF_PREFIX_RM_ADV,
7037                                      PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
7038                                      PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, json_prefB);
7039           json_object_object_add(json_af, "orfOldPrefixList", json_prefB);
7040         }
7041
7042       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7043           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
7044           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
7045           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7046           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV)
7047           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
7048         json_object_object_add(json_addr, "afDependentCap", json_af);
7049       else
7050         json_object_free(json_af);
7051
7052       sprintf (orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
7053       orf_pfx_count =  prefix_bgp_show_prefix_list (NULL, afi, orf_pfx_name, use_json);
7054
7055       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND)
7056           || orf_pfx_count)
7057         {
7058           if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
7059             json_object_boolean_true_add(json_neigh, "orfSent");
7060           if (orf_pfx_count)
7061             json_object_int_add(json_addr, "orfRecvCounter", orf_pfx_count);
7062         }
7063       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH))
7064         json_object_string_add(json_addr, "orfFirstUpdate", "deferredUntilORFOrRouteRefreshRecvd");
7065
7066       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REFLECTOR_CLIENT))
7067         json_object_boolean_true_add(json_addr, "routeReflectorClient");
7068       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT))
7069         json_object_boolean_true_add(json_addr, "routeServerClient");
7070       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
7071         json_object_boolean_true_add(json_addr, "inboundSoftConfigPermit");
7072
7073       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
7074         json_object_boolean_true_add(json_addr, "privateAsNumsAllReplacedInUpdatesToNbr");
7075       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
7076         json_object_boolean_true_add(json_addr, "privateAsNumsReplacedInUpdatesToNbr");
7077       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
7078         json_object_boolean_true_add(json_addr, "privateAsNumsAllRemovedInUpdatesToNbr");
7079       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS))
7080         json_object_boolean_true_add(json_addr, "privateAsNumsRemovedInUpdatesToNbr");
7081
7082       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_ADDPATH_TX_ALL_PATHS))
7083         json_object_boolean_true_add(json_addr, "addpathTxAllPaths");
7084
7085       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS))
7086         json_object_boolean_true_add(json_addr, "addpathTxBestpathPerAS");
7087
7088       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
7089         json_object_string_add(json_addr, "overrideASNsInOutboundUpdates", "ifAspathEqualRemoteAs");
7090
7091       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF) ||
7092           CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_FORCE_NEXTHOP_SELF))
7093         json_object_boolean_true_add(json_addr, "routerAlwaysNextHop");
7094       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED))
7095         json_object_boolean_true_add(json_addr, "unchangedAsPathPropogatedToNbr");
7096       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED))
7097         json_object_boolean_true_add(json_addr, "unchangedNextHopPropogatedToNbr");
7098       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
7099         json_object_boolean_true_add(json_addr, "unchangedMedPropogatedToNbr");
7100       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
7101           || CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY))
7102         {
7103           if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
7104               && CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY))
7105             json_object_string_add(json_addr, "commAttriSentToNbr", "extendedAndStandard");
7106           else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY))
7107             json_object_string_add(json_addr, "commAttriSentToNbr", "extended");
7108           else
7109             json_object_string_add(json_addr, "commAttriSentToNbr", "standard");
7110         }
7111       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE))
7112         {
7113           if (p->default_rmap[afi][safi].name)
7114             json_object_string_add(json_addr, "defaultRouteMap", p->default_rmap[afi][safi].name);
7115
7116           if (paf && PAF_SUBGRP(paf) && CHECK_FLAG(PAF_SUBGRP(paf)->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE))
7117             json_object_boolean_true_add(json_addr, "defaultSent");
7118           else
7119             json_object_boolean_true_add(json_addr, "defaultNotSent");
7120         }
7121
7122       if (filter->plist[FILTER_IN].name
7123           || filter->dlist[FILTER_IN].name
7124           || filter->aslist[FILTER_IN].name
7125           || filter->map[RMAP_IN].name)
7126         json_object_boolean_true_add(json_addr, "inboundPathPolicyConfig");
7127       if (filter->plist[FILTER_OUT].name
7128           || filter->dlist[FILTER_OUT].name
7129           || filter->aslist[FILTER_OUT].name
7130           || filter->map[RMAP_OUT].name
7131           || filter->usmap.name)
7132         json_object_boolean_true_add(json_addr, "outboundPathPolicyConfig");
7133
7134       /* prefix-list */
7135       if (filter->plist[FILTER_IN].name)
7136         json_object_string_add(json_addr, "incomingUpdatePrefixFilterList", filter->plist[FILTER_IN].name);
7137       if (filter->plist[FILTER_OUT].name)
7138         json_object_string_add(json_addr, "outgoingUpdatePrefixFilterList", filter->plist[FILTER_OUT].name);
7139
7140       /* distribute-list */
7141       if (filter->dlist[FILTER_IN].name)
7142         json_object_string_add(json_addr, "incomingUpdateNetworkFilterList", filter->dlist[FILTER_IN].name);
7143       if (filter->dlist[FILTER_OUT].name)
7144         json_object_string_add(json_addr, "outgoingUpdateNetworkFilterList", filter->dlist[FILTER_OUT].name);
7145
7146       /* filter-list. */
7147       if (filter->aslist[FILTER_IN].name)
7148         json_object_string_add(json_addr, "incomingUpdateAsPathFilterList", filter->aslist[FILTER_IN].name);
7149       if (filter->aslist[FILTER_OUT].name)
7150         json_object_string_add(json_addr, "outgoingUpdateAsPathFilterList", filter->aslist[FILTER_OUT].name);
7151
7152       /* route-map. */
7153       if (filter->map[RMAP_IN].name)
7154         json_object_string_add(json_addr, "routeMapForIncomingAdvertisements", filter->map[RMAP_IN].name);
7155       if (filter->map[RMAP_OUT].name)
7156         json_object_string_add(json_addr, "routeMapForOutgoingAdvertisements", filter->map[RMAP_OUT].name);
7157
7158       /* unsuppress-map */
7159       if (filter->usmap.name)
7160         json_object_string_add(json_addr, "selectiveUnsuppressRouteMap", filter->usmap.name);
7161
7162       /* Receive prefix count */
7163       json_object_int_add(json_addr, "acceptedPrefixCounter", p->pcount[afi][safi]);
7164
7165       /* Maximum prefix */
7166       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX))
7167         {
7168           json_object_int_add(json_addr, "prefixAllowedMax", p->pmax[afi][safi]);
7169           if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING))
7170             json_object_boolean_true_add(json_addr, "prefixAllowedMaxWarning");
7171           json_object_int_add(json_addr, "prefixAllowedWarningThresh", p->pmax_threshold[afi][safi]);
7172           if (p->pmax_restart[afi][safi])
7173             json_object_int_add(json_addr, "prefixAllowedRestartIntervalMsecs", p->pmax_restart[afi][safi] * 60000);
7174         }
7175       json_object_object_add(json_neigh, afi_safi_print (afi, safi), json_addr);
7176
7177     }
7178   else
7179     {
7180       filter = &p->filter[afi][safi];
7181
7182       vty_out (vty, " For address family: %s%s", afi_safi_print (afi, safi),
7183                VTY_NEWLINE);
7184
7185       if (peer_group_active(p))
7186         vty_out (vty, "  %s peer-group member%s", p->group->name, VTY_NEWLINE);
7187
7188       paf = peer_af_find(p, afi, safi);
7189       if (paf && PAF_SUBGRP(paf))
7190         {
7191           vty_out (vty, "  Update group %" PRIu64 ", subgroup %" PRIu64 "%s",
7192                    PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id, VTY_NEWLINE);
7193           vty_out (vty, "  Packet Queue length %d%s",
7194                    bpacket_queue_virtual_length(paf), VTY_NEWLINE);
7195         }
7196       else
7197         {
7198           vty_out(vty, "  Not part of any update group%s", VTY_NEWLINE);
7199         }
7200       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7201           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
7202           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
7203           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7204           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV)
7205           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
7206         vty_out (vty, "  AF-dependant capabilities:%s", VTY_NEWLINE);
7207
7208       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7209           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV)
7210           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7211           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_RCV))
7212         {
7213           vty_out (vty, "    Outbound Route Filter (ORF) type (%d) Prefix-list:%s",
7214                    ORF_TYPE_PREFIX, VTY_NEWLINE);
7215           bgp_show_peer_afi_orf_cap (vty, p, afi, safi,
7216                                      PEER_CAP_ORF_PREFIX_SM_ADV,
7217                                      PEER_CAP_ORF_PREFIX_RM_ADV,
7218                                      PEER_CAP_ORF_PREFIX_SM_RCV,
7219                                      PEER_CAP_ORF_PREFIX_RM_RCV, use_json, NULL);
7220         }
7221       if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV)
7222           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_OLD_RCV)
7223           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV)
7224           || CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_OLD_RCV))
7225         {
7226           vty_out (vty, "    Outbound Route Filter (ORF) type (%d) Prefix-list:%s",
7227                    ORF_TYPE_PREFIX_OLD, VTY_NEWLINE);
7228           bgp_show_peer_afi_orf_cap (vty, p, afi, safi,
7229                                      PEER_CAP_ORF_PREFIX_SM_ADV,
7230                                      PEER_CAP_ORF_PREFIX_RM_ADV,
7231                                      PEER_CAP_ORF_PREFIX_SM_OLD_RCV,
7232                                      PEER_CAP_ORF_PREFIX_RM_OLD_RCV, use_json, NULL);
7233         }
7234
7235       sprintf (orf_pfx_name, "%s.%d.%d", p->host, afi, safi);
7236       orf_pfx_count =  prefix_bgp_show_prefix_list (NULL, afi, orf_pfx_name, use_json);
7237
7238       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND)
7239           || orf_pfx_count)
7240         {
7241           vty_out (vty, "  Outbound Route Filter (ORF):");
7242           if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_PREFIX_SEND))
7243               vty_out (vty, " sent;");
7244           if (orf_pfx_count)
7245             vty_out (vty, " received (%d entries)", orf_pfx_count);
7246           vty_out (vty, "%s", VTY_NEWLINE);
7247         }
7248       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_ORF_WAIT_REFRESH))
7249           vty_out (vty, "  First update is deferred until ORF or ROUTE-REFRESH is received%s", VTY_NEWLINE);
7250
7251       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REFLECTOR_CLIENT))
7252         vty_out (vty, "  Route-Reflector Client%s", VTY_NEWLINE);
7253       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT))
7254         vty_out (vty, "  Route-Server Client%s", VTY_NEWLINE);
7255       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
7256         vty_out (vty, "  Inbound soft reconfiguration allowed%s", VTY_NEWLINE);
7257
7258       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
7259         vty_out (vty, "  Private AS numbers (all) replaced in updates to this neighbor%s", VTY_NEWLINE);
7260       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
7261         vty_out (vty, "  Private AS numbers replaced in updates to this neighbor%s", VTY_NEWLINE);
7262       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS_ALL))
7263         vty_out (vty, "  Private AS numbers (all) removed in updates to this neighbor%s", VTY_NEWLINE);
7264       else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_REMOVE_PRIVATE_AS))
7265         vty_out (vty, "  Private AS numbers removed in updates to this neighbor%s", VTY_NEWLINE);
7266
7267       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_ADDPATH_TX_ALL_PATHS))
7268         vty_out (vty, "  Advertise all paths via addpath%s", VTY_NEWLINE);
7269
7270       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS))
7271         vty_out (vty, "  Advertise bestpath per AS via addpath%s", VTY_NEWLINE);
7272
7273       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_AS_OVERRIDE))
7274         vty_out (vty, "  Override ASNs in outbound updates if aspath equals remote-as%s", VTY_NEWLINE);
7275
7276       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_SELF) ||
7277           CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_FORCE_NEXTHOP_SELF))
7278         vty_out (vty, "  NEXT_HOP is always this router%s", VTY_NEWLINE);
7279       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED))
7280         vty_out (vty, "  AS_PATH is propagated unchanged to this neighbor%s", VTY_NEWLINE);
7281       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_NEXTHOP_UNCHANGED))
7282         vty_out (vty, "  NEXT_HOP is propagated unchanged to this neighbor%s", VTY_NEWLINE);
7283       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MED_UNCHANGED))
7284         vty_out (vty, "  MED is propagated unchanged to this neighbor%s", VTY_NEWLINE);
7285       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
7286           || CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY)
7287           || CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY))
7288         {
7289           vty_out (vty, "  Community attribute sent to this neighbor");
7290           if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
7291               && CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY)
7292               && CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY))
7293             vty_out (vty, "(all)%s", VTY_NEWLINE);
7294           else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY))
7295             vty_out (vty, "(large)%s", VTY_NEWLINE);
7296           else if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY))
7297             vty_out (vty, "(extended)%s", VTY_NEWLINE);
7298           else
7299             vty_out (vty, "(standard)%s", VTY_NEWLINE);
7300         }
7301       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE))
7302         {
7303           vty_out (vty, "  Default information originate,");
7304
7305           if (p->default_rmap[afi][safi].name)
7306             vty_out (vty, " default route-map %s%s,",
7307                      p->default_rmap[afi][safi].map ? "*" : "",
7308                      p->default_rmap[afi][safi].name);
7309           if (paf && PAF_SUBGRP(paf) && CHECK_FLAG(PAF_SUBGRP(paf)->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE))
7310             vty_out (vty, " default sent%s", VTY_NEWLINE);
7311           else
7312             vty_out (vty, " default not sent%s", VTY_NEWLINE);
7313         }
7314
7315       if (filter->plist[FILTER_IN].name
7316           || filter->dlist[FILTER_IN].name
7317           || filter->aslist[FILTER_IN].name
7318           || filter->map[RMAP_IN].name)
7319         vty_out (vty, "  Inbound path policy configured%s", VTY_NEWLINE);
7320       if (filter->plist[FILTER_OUT].name
7321           || filter->dlist[FILTER_OUT].name
7322           || filter->aslist[FILTER_OUT].name
7323           || filter->map[RMAP_OUT].name
7324           || filter->usmap.name)
7325         vty_out (vty, "  Outbound path policy configured%s", VTY_NEWLINE);
7326
7327       /* prefix-list */
7328       if (filter->plist[FILTER_IN].name)
7329         vty_out (vty, "  Incoming update prefix filter list is %s%s%s",
7330                  filter->plist[FILTER_IN].plist ? "*" : "",
7331                  filter->plist[FILTER_IN].name,
7332                  VTY_NEWLINE);
7333       if (filter->plist[FILTER_OUT].name)
7334         vty_out (vty, "  Outgoing update prefix filter list is %s%s%s",
7335                  filter->plist[FILTER_OUT].plist ? "*" : "",
7336                  filter->plist[FILTER_OUT].name,
7337                  VTY_NEWLINE);
7338
7339       /* distribute-list */
7340       if (filter->dlist[FILTER_IN].name)
7341         vty_out (vty, "  Incoming update network filter list is %s%s%s",
7342                  filter->dlist[FILTER_IN].alist ? "*" : "",
7343                  filter->dlist[FILTER_IN].name,
7344                  VTY_NEWLINE);
7345       if (filter->dlist[FILTER_OUT].name)
7346         vty_out (vty, "  Outgoing update network filter list is %s%s%s",
7347                  filter->dlist[FILTER_OUT].alist ? "*" : "",
7348                  filter->dlist[FILTER_OUT].name,
7349                  VTY_NEWLINE);
7350
7351       /* filter-list. */
7352       if (filter->aslist[FILTER_IN].name)
7353         vty_out (vty, "  Incoming update AS path filter list is %s%s%s",
7354                  filter->aslist[FILTER_IN].aslist ? "*" : "",
7355                  filter->aslist[FILTER_IN].name,
7356                  VTY_NEWLINE);
7357       if (filter->aslist[FILTER_OUT].name)
7358         vty_out (vty, "  Outgoing update AS path filter list is %s%s%s",
7359                  filter->aslist[FILTER_OUT].aslist ? "*" : "",
7360                  filter->aslist[FILTER_OUT].name,
7361                  VTY_NEWLINE);
7362
7363       /* route-map. */
7364       if (filter->map[RMAP_IN].name)
7365         vty_out (vty, "  Route map for incoming advertisements is %s%s%s",
7366                  filter->map[RMAP_IN].map ? "*" : "",
7367                  filter->map[RMAP_IN].name,
7368                  VTY_NEWLINE);
7369       if (filter->map[RMAP_OUT].name)
7370         vty_out (vty, "  Route map for outgoing advertisements is %s%s%s",
7371                  filter->map[RMAP_OUT].map ? "*" : "",
7372                  filter->map[RMAP_OUT].name,
7373                  VTY_NEWLINE);
7374
7375       /* unsuppress-map */
7376       if (filter->usmap.name)
7377         vty_out (vty, "  Route map for selective unsuppress is %s%s%s",
7378                  filter->usmap.map ? "*" : "",
7379                  filter->usmap.name, VTY_NEWLINE);
7380
7381       /* Receive prefix count */
7382       vty_out (vty, "  %ld accepted prefixes%s", p->pcount[afi][safi], VTY_NEWLINE);
7383
7384       /* Maximum prefix */
7385       if (CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX))
7386         {
7387           vty_out (vty, "  Maximum prefixes allowed %ld%s%s", p->pmax[afi][safi],
7388                    CHECK_FLAG (p->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_WARNING)
7389                    ? " (warning-only)" : "", VTY_NEWLINE);
7390           vty_out (vty, "  Threshold for warning message %d%%",
7391                    p->pmax_threshold[afi][safi]);
7392           if (p->pmax_restart[afi][safi])
7393             vty_out (vty, ", restart interval %d min", p->pmax_restart[afi][safi]);
7394           vty_out (vty, "%s", VTY_NEWLINE);
7395         }
7396
7397       vty_out (vty, "%s", VTY_NEWLINE);
7398     }
7399 }
7400
7401 static void
7402 bgp_show_peer (struct vty *vty, struct peer *p, u_char use_json, json_object *json)
7403 {
7404   struct bgp *bgp;
7405   char buf1[PREFIX2STR_BUFFER], buf[SU_ADDRSTRLEN];
7406   char timebuf[BGP_UPTIME_LEN];
7407   char dn_flag[2];
7408   const char *subcode_str;
7409   const char *code_str;
7410   afi_t afi;
7411   safi_t safi;
7412   u_int16_t i;
7413   u_char *msg;
7414   json_object *json_neigh = NULL;
7415
7416   bgp = p->bgp;
7417
7418   if (use_json)
7419     json_neigh = json_object_new_object();
7420
7421   memset (dn_flag, '\0', sizeof (dn_flag));
7422   if (!p->conf_if && peer_dynamic_neighbor (p))
7423     dn_flag[0] = '*';
7424
7425   if (!use_json)
7426     {
7427       if (p->conf_if) /* Configured interface name. */
7428         vty_out (vty, "BGP neighbor on %s: %s, ", p->conf_if,
7429                  BGP_PEER_SU_UNSPEC(p) ? "None" :
7430                  sockunion2str (&p->su, buf, SU_ADDRSTRLEN));
7431       else /* Configured IP address. */
7432         vty_out (vty, "BGP neighbor is %s%s, ", dn_flag, p->host);
7433     }
7434
7435   if (use_json)
7436     {
7437       if (p->conf_if && BGP_PEER_SU_UNSPEC(p))
7438         json_object_string_add(json_neigh, "bgpNeighborAddr", "none");
7439       else if (p->conf_if && !BGP_PEER_SU_UNSPEC(p))
7440         json_object_string_add(json_neigh, "bgpNeighborAddr", sockunion2str (&p->su, buf, SU_ADDRSTRLEN));
7441
7442       json_object_int_add(json_neigh, "remoteAs", p->as);
7443
7444       if (p->change_local_as)
7445         json_object_int_add(json_neigh, "localAs", p->change_local_as);
7446       else
7447         json_object_int_add(json_neigh, "localAs", p->local_as);
7448
7449       if (CHECK_FLAG (p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
7450         json_object_boolean_true_add(json_neigh, "localAsNoPrepend");
7451
7452       if (CHECK_FLAG (p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS))
7453         json_object_boolean_true_add(json_neigh, "localAsReplaceAs");
7454     }
7455   else
7456     {
7457       if ((p->as_type == AS_SPECIFIED) ||
7458           (p->as_type == AS_EXTERNAL) ||
7459           (p->as_type == AS_INTERNAL))
7460         vty_out (vty, "remote AS %u, ", p->as);
7461       else
7462         vty_out (vty, "remote AS Unspecified, ");
7463       vty_out (vty, "local AS %u%s%s, ",
7464                p->change_local_as ? p->change_local_as : p->local_as,
7465                CHECK_FLAG (p->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND) ?
7466                " no-prepend" : "",
7467                CHECK_FLAG (p->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS) ?
7468                " replace-as" : "");
7469     }
7470   /* peer type internal, external, confed-internal or confed-external */
7471   if (p->as == p->local_as)
7472     {
7473       if (use_json)
7474         {
7475           if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
7476             json_object_boolean_true_add(json_neigh, "nbrConfedInternalLink");
7477           else
7478             json_object_boolean_true_add(json_neigh, "nbrInternalLink");
7479         }
7480       else
7481         {
7482           if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
7483             vty_out (vty, "confed-internal link%s", VTY_NEWLINE);
7484           else
7485             vty_out (vty, "internal link%s", VTY_NEWLINE);
7486         }
7487     }
7488   else
7489     {
7490       if (use_json)
7491         {
7492           if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
7493             json_object_boolean_true_add(json_neigh, "nbrConfedExternalLink");
7494           else
7495             json_object_boolean_true_add(json_neigh, "nbrExternalLink");
7496         }
7497       else
7498         {
7499          if (bgp_confederation_peers_check(bgp, p->as))
7500            vty_out (vty, "confed-external link%s", VTY_NEWLINE);
7501          else
7502            vty_out (vty, "external link%s", VTY_NEWLINE);
7503         }
7504     }
7505
7506   /* Description. */
7507   if (p->desc)
7508     {
7509       if (use_json)
7510         json_object_string_add(json_neigh, "nbrDesc", p->desc);
7511       else
7512         vty_out (vty, " Description: %s%s", p->desc, VTY_NEWLINE);
7513     }
7514
7515   if (p->hostname)
7516     {
7517       if (use_json)
7518         {
7519           if (p->hostname)
7520             json_object_string_add(json_neigh, "hostname", p->hostname);
7521
7522           if (p->domainname)
7523             json_object_string_add(json_neigh, "domainname", p->domainname);
7524         }
7525       else
7526         {
7527           if (p->domainname && (p->domainname[0] != '\0'))
7528             vty_out(vty, "Hostname: %s.%s%s", p->hostname, p->domainname,
7529                     VTY_NEWLINE);
7530           else
7531             vty_out(vty, "Hostname: %s%s", p->hostname, VTY_NEWLINE);
7532         }
7533
7534     }
7535
7536   /* Peer-group */
7537   if (p->group)
7538     {
7539       if (use_json)
7540         {
7541           json_object_string_add(json_neigh, "peerGroup", p->group->name);
7542
7543           if (dn_flag[0])
7544             {
7545               struct prefix prefix, *range = NULL;
7546
7547               sockunion2hostprefix(&(p->su), &prefix);
7548               range = peer_group_lookup_dynamic_neighbor_range (p->group, &prefix);
7549
7550               if (range)
7551                 {
7552                   prefix2str(range, buf1, sizeof(buf1));
7553                   json_object_string_add(json_neigh, "peerSubnetRangeGroup", buf1);
7554                 }
7555             }
7556         }
7557       else
7558         {
7559           vty_out (vty, " Member of peer-group %s for session parameters%s",
7560                    p->group->name, VTY_NEWLINE);
7561
7562           if (dn_flag[0])
7563             {
7564               struct prefix prefix, *range = NULL;
7565
7566               sockunion2hostprefix(&(p->su), &prefix);
7567               range = peer_group_lookup_dynamic_neighbor_range (p->group, &prefix);
7568
7569               if (range)
7570                 {
7571                   prefix2str(range, buf1, sizeof(buf1));
7572                   vty_out (vty, " Belongs to the subnet range group: %s%s", buf1, VTY_NEWLINE);
7573                 }
7574             }
7575         }
7576     }
7577
7578   if (use_json)
7579     {
7580       /* Administrative shutdown. */
7581       if (CHECK_FLAG (p->flags, PEER_FLAG_SHUTDOWN))
7582         json_object_boolean_true_add(json_neigh, "adminShutDown");
7583
7584       /* BGP Version. */
7585       json_object_int_add(json_neigh, "bgpVersion", 4);
7586       json_object_string_add(json_neigh, "remoteRouterId",
7587                              inet_ntop (AF_INET, &p->remote_id, buf1, sizeof(buf1)));
7588
7589       /* Confederation */
7590       if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION) && bgp_confederation_peers_check (bgp, p->as))
7591         json_object_boolean_true_add(json_neigh, "nbrCommonAdmin");
7592
7593       /* Status. */
7594       json_object_string_add(json_neigh, "bgpState", LOOKUP (bgp_status_msg, p->status));
7595
7596       if (p->status == Established)
7597         {
7598           time_t uptime;
7599           struct tm *tm;
7600
7601           uptime = bgp_clock();
7602           uptime -= p->uptime;
7603           tm = gmtime(&uptime);
7604
7605           json_object_int_add(json_neigh, "bgpTimerUp", (tm->tm_sec * 1000) + (tm->tm_min * 60000) + (tm->tm_hour * 3600000));
7606         }
7607
7608       else if (p->status == Active)
7609         {
7610           if (CHECK_FLAG (p->flags, PEER_FLAG_PASSIVE))
7611             json_object_string_add(json_neigh, "bgpStateIs", "passive");
7612           else if (CHECK_FLAG (p->sflags, PEER_STATUS_NSF_WAIT))
7613             json_object_string_add(json_neigh, "bgpStateIs", "passiveNSF");
7614         }
7615
7616       /* read timer */
7617       time_t uptime;
7618       struct tm *tm;
7619
7620       uptime = bgp_clock();
7621       uptime -= p->readtime;
7622       tm = gmtime(&uptime);
7623       json_object_int_add(json_neigh, "bgpTimerLastRead", (tm->tm_sec * 1000) + (tm->tm_min * 60000) + (tm->tm_hour * 3600000));
7624
7625       uptime = bgp_clock();
7626       uptime -= p->last_write;
7627       tm = gmtime(&uptime);
7628       json_object_int_add(json_neigh, "bgpTimerLastWrite", (tm->tm_sec * 1000) + (tm->tm_min * 60000) + (tm->tm_hour * 3600000));
7629
7630       uptime = bgp_clock();
7631       uptime -= p->update_time;
7632       tm = gmtime(&uptime);
7633       json_object_int_add(json_neigh, "bgpInUpdateElapsedTimeMsecs",
7634                           (tm->tm_sec * 1000) + (tm->tm_min * 60000) + (tm->tm_hour * 3600000));
7635
7636       /* Configured timer values. */
7637       json_object_int_add(json_neigh, "bgpTimerHoldTimeMsecs", p->v_holdtime * 1000);
7638       json_object_int_add(json_neigh, "bgpTimerKeepAliveIntervalMsecs", p->v_keepalive * 1000);
7639
7640       if (CHECK_FLAG (p->config, PEER_CONFIG_TIMER))
7641         {
7642           json_object_int_add(json_neigh, "bgpTimerConfiguredHoldTimeMsecs", p->holdtime * 1000);
7643           json_object_int_add(json_neigh, "bgpTimerConfiguredKeepAliveIntervalMsecs", p->keepalive * 1000);
7644         }
7645     }
7646   else
7647     {
7648       /* Administrative shutdown. */
7649       if (CHECK_FLAG (p->flags, PEER_FLAG_SHUTDOWN))
7650         vty_out (vty, " Administratively shut down%s", VTY_NEWLINE);
7651
7652       /* BGP Version. */
7653       vty_out (vty, "  BGP version 4");
7654       vty_out (vty, ", remote router ID %s%s",
7655                inet_ntop (AF_INET, &p->remote_id, buf1, sizeof(buf1)),
7656                VTY_NEWLINE);
7657
7658       /* Confederation */
7659       if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION)
7660           && bgp_confederation_peers_check (bgp, p->as))
7661         vty_out (vty, "  Neighbor under common administration%s", VTY_NEWLINE);
7662
7663       /* Status. */
7664       vty_out (vty, "  BGP state = %s", LOOKUP (bgp_status_msg, p->status));
7665
7666       if (p->status == Established)
7667         vty_out (vty, ", up for %8s", peer_uptime (p->uptime, timebuf, BGP_UPTIME_LEN, 0, NULL));
7668
7669       else if (p->status == Active)
7670         {
7671           if (CHECK_FLAG (p->flags, PEER_FLAG_PASSIVE))
7672             vty_out (vty, " (passive)");
7673         else if (CHECK_FLAG (p->sflags, PEER_STATUS_NSF_WAIT))
7674                vty_out (vty, " (NSF passive)");
7675         }
7676       vty_out (vty, "%s", VTY_NEWLINE);
7677
7678       /* read timer */
7679       vty_out (vty, "  Last read %s", peer_uptime (p->readtime, timebuf, BGP_UPTIME_LEN, 0, NULL));
7680       vty_out (vty, ", Last write %s%s",
7681                peer_uptime (p->last_write, timebuf, BGP_UPTIME_LEN, 0, NULL), VTY_NEWLINE);
7682
7683       /* Configured timer values. */
7684       vty_out (vty, "  Hold time is %d, keepalive interval is %d seconds%s",
7685                p->v_holdtime, p->v_keepalive, VTY_NEWLINE);
7686       if (CHECK_FLAG (p->config, PEER_CONFIG_TIMER))
7687         {
7688           vty_out (vty, "  Configured hold time is %d", p->holdtime);
7689           vty_out (vty, ", keepalive interval is %d seconds%s",
7690                    p->keepalive, VTY_NEWLINE);
7691         }
7692     }
7693   /* Capability. */
7694   if (p->status == Established)
7695     {
7696       if (p->cap
7697           || p->afc_adv[AFI_IP][SAFI_UNICAST]
7698           || p->afc_recv[AFI_IP][SAFI_UNICAST]
7699           || p->afc_adv[AFI_IP][SAFI_MULTICAST]
7700           || p->afc_recv[AFI_IP][SAFI_MULTICAST]
7701           || p->afc_adv[AFI_IP6][SAFI_UNICAST]
7702           || p->afc_recv[AFI_IP6][SAFI_UNICAST]
7703           || p->afc_adv[AFI_IP6][SAFI_MULTICAST]
7704           || p->afc_recv[AFI_IP6][SAFI_MULTICAST]
7705           || p->afc_adv[AFI_IP6][SAFI_MPLS_VPN]
7706           || p->afc_recv[AFI_IP6][SAFI_MPLS_VPN]
7707           || p->afc_adv[AFI_IP6][SAFI_ENCAP]
7708           || p->afc_recv[AFI_IP6][SAFI_ENCAP]
7709           || p->afc_adv[AFI_IP][SAFI_ENCAP]
7710           || p->afc_recv[AFI_IP][SAFI_ENCAP]
7711           || p->afc_adv[AFI_IP][SAFI_MPLS_VPN]
7712           || p->afc_recv[AFI_IP][SAFI_MPLS_VPN])
7713         {
7714           if (use_json)
7715             {
7716               json_object *json_cap = NULL;
7717
7718               json_cap = json_object_new_object();
7719
7720               /* AS4 */
7721               if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV)
7722                   || CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
7723                 {
7724                   if (CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV) && CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV))
7725                     json_object_string_add(json_cap, "4byteAs", "advertisedAndReceived");
7726                   else if (CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
7727                     json_object_string_add(json_cap, "4byteAs", "advertised");
7728                   else if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV))
7729                     json_object_string_add(json_cap, "4byteAs", "received");
7730                 }
7731
7732               /* AddPath */
7733               if (CHECK_FLAG (p->cap, PEER_CAP_ADDPATH_RCV)
7734                   || CHECK_FLAG (p->cap, PEER_CAP_ADDPATH_ADV))
7735                 {
7736                   json_object *json_add = NULL;
7737                   const char *print_store;
7738
7739                   json_add = json_object_new_object();
7740
7741                   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
7742                     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
7743                       {
7744                         json_object *json_sub = NULL;
7745                         json_sub = json_object_new_object();
7746                         print_store = afi_safi_print (afi, safi);
7747
7748                         if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV) ||
7749                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV))
7750                           {
7751                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV) && CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV))
7752                               json_object_boolean_true_add(json_sub, "txAdvertisedAndReceived");
7753                             else if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV))
7754                               json_object_boolean_true_add(json_sub, "txAdvertised");
7755                             else if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV))
7756                               json_object_boolean_true_add(json_sub, "txReceived");
7757                           }
7758
7759                         if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) ||
7760                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7761                           {
7762                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) && CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7763                               json_object_boolean_true_add(json_sub, "rxAdvertisedAndReceived");
7764                             else if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV))
7765                               json_object_boolean_true_add(json_sub, "rxAdvertised");
7766                             else if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7767                               json_object_boolean_true_add(json_sub, "rxReceived");
7768                           }
7769
7770                         if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV) ||
7771                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV) ||
7772                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) ||
7773                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7774                           json_object_object_add(json_add, print_store, json_sub);
7775                         else
7776                           json_object_free(json_sub);
7777                       }
7778
7779                   json_object_object_add(json_cap, "addPath", json_add);
7780                 }
7781
7782               /* Dynamic */
7783               if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV)
7784                   || CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV))
7785                 {
7786                   if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV) && CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV))
7787                     json_object_string_add(json_cap, "dynamic", "advertisedAndReceived");
7788                   else if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV))
7789                     json_object_string_add(json_cap, "dynamic", "advertised");
7790                   else if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV))
7791                     json_object_string_add(json_cap, "dynamic", "received");
7792                 }
7793
7794               /* Extended nexthop */
7795               if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV)
7796                   || CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV))
7797                 {
7798                   json_object *json_nxt = NULL;
7799                   const char *print_store;
7800
7801
7802                   if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV) && CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV))
7803                     json_object_string_add(json_cap, "extendedNexthop", "advertisedAndReceived");
7804                   else if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV))
7805                     json_object_string_add(json_cap, "extendedNexthop", "advertised");
7806                   else if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV))
7807                     json_object_string_add(json_cap, "extendedNexthop", "received");
7808
7809                   if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV))
7810                     {
7811                       json_nxt = json_object_new_object();
7812
7813                       for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
7814                         {
7815                           if (CHECK_FLAG (p->af_cap[AFI_IP][safi], PEER_CAP_ENHE_AF_RCV))
7816                             {
7817                               print_store = afi_safi_print (AFI_IP, safi);
7818                               json_object_string_add(json_nxt, print_store, "recieved");
7819                             }
7820                         }
7821                       json_object_object_add(json_cap, "extendedNexthopFamililesByPeer", json_nxt);
7822                     }
7823                 }
7824
7825               /* Route Refresh */
7826               if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV)
7827                   || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV)
7828                   || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV))
7829                 {
7830                   if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV) && (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV) || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV)))
7831                     {
7832                       if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV) && CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV))
7833                         json_object_string_add(json_cap, "routeRefresh", "advertisedAndReceivedOldNew");
7834                       else
7835                         {
7836                           if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV))
7837                             json_object_string_add(json_cap, "routeRefresh", "advertisedAndReceivedOld");
7838                           else
7839                             json_object_string_add(json_cap, "routeRefresh", "advertisedAndReceivedNew");
7840                         }
7841                     }
7842                   else if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV))
7843                     json_object_string_add(json_cap, "routeRefresh", "advertised");
7844                   else if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV) || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV))
7845                     json_object_string_add(json_cap, "routeRefresh", "received");
7846                 }
7847
7848               /* Multiprotocol Extensions */
7849               json_object *json_multi = NULL;
7850               json_multi = json_object_new_object();
7851
7852               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
7853                 {
7854                   for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
7855                     {
7856                       if (p->afc_adv[afi][safi] || p->afc_recv[afi][safi])
7857                         {
7858                           json_object *json_exten = NULL;
7859                           json_exten = json_object_new_object();
7860
7861                           if (p->afc_adv[afi][safi] && p->afc_recv[afi][safi])
7862                             json_object_boolean_true_add(json_exten, "advertisedAndReceived");
7863                           else if (p->afc_adv[afi][safi])
7864                             json_object_boolean_true_add(json_exten, "advertised");
7865                           else if (p->afc_recv[afi][safi])
7866                             json_object_boolean_true_add(json_exten, "received");
7867
7868                           json_object_object_add(json_multi, afi_safi_print (afi, safi), json_exten);
7869                         }
7870                     }
7871                 }
7872               json_object_object_add(json_cap, "multiprotocolExtensions", json_multi);
7873
7874               /* Gracefull Restart */
7875               if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV)
7876                   || CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV))
7877                 {
7878                   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV) && CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV))
7879                     json_object_string_add(json_cap, "gracefulRestart", "advertisedAndReceived");
7880                   else if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV))
7881                     json_object_string_add(json_cap, "gracefulRestartCapability", "advertised");
7882                   else if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV))
7883                     json_object_string_add(json_cap, "gracefulRestartCapability", "received");
7884
7885                   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV))
7886                     {
7887                       int restart_af_count = 0;
7888                       json_object *json_restart = NULL;
7889                       json_restart = json_object_new_object();
7890
7891                       json_object_int_add(json_cap, "gracefulRestartRemoteTimerMsecs", p->v_gr_restart * 1000);
7892
7893                       for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
7894                         {
7895                           for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
7896                             {
7897                               if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_RESTART_AF_RCV))
7898                                 {
7899                                   json_object *json_sub = NULL;
7900                                   json_sub = json_object_new_object();
7901
7902                                   if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_RESTART_AF_PRESERVE_RCV))
7903                                     json_object_boolean_true_add(json_sub, "preserved");
7904                                   restart_af_count++;
7905                                   json_object_object_add(json_restart, afi_safi_print (afi, safi), json_sub);
7906                                 }
7907                             }
7908                         }
7909                       if (! restart_af_count)
7910                         {
7911                         json_object_string_add(json_cap, "addressFamiliesByPeer", "none");
7912                           json_object_free(json_restart);
7913                         }
7914                       else
7915                         json_object_object_add(json_cap, "addressFamiliesByPeer", json_restart);
7916                     }
7917                 }
7918               json_object_object_add(json_neigh, "neighborCapabilities", json_cap);
7919             }
7920           else
7921             {
7922               vty_out (vty, "  Neighbor capabilities:%s", VTY_NEWLINE);
7923
7924               /* AS4 */
7925               if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV)
7926                   || CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
7927                 {
7928                   vty_out (vty, "    4 Byte AS:");
7929                   if (CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV))
7930                     vty_out (vty, " advertised");
7931                   if (CHECK_FLAG (p->cap, PEER_CAP_AS4_RCV))
7932                     vty_out (vty, " %sreceived",
7933                              CHECK_FLAG (p->cap, PEER_CAP_AS4_ADV) ? "and " : "");
7934                   vty_out (vty, "%s", VTY_NEWLINE);
7935                 }
7936
7937               /* AddPath */
7938               if (CHECK_FLAG (p->cap, PEER_CAP_ADDPATH_RCV)
7939                   || CHECK_FLAG (p->cap, PEER_CAP_ADDPATH_ADV))
7940                 {
7941                   vty_out (vty, "    AddPath:%s", VTY_NEWLINE);
7942
7943                   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
7944                     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
7945                       {
7946                         if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV) ||
7947                             CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV))
7948                           {
7949                             vty_out (vty, "      %s: TX ", afi_safi_print (afi, safi));
7950
7951                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV))
7952                               vty_out (vty, "advertised %s", afi_safi_print (afi, safi));
7953
7954                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_RCV))
7955                               vty_out (vty, "%sreceived", CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_TX_ADV) ? " and " : "" );
7956
7957                             vty_out (vty, "%s", VTY_NEWLINE);
7958                           }
7959
7960                         if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) ||
7961                         CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7962                           {
7963                             vty_out (vty, "      %s: RX ", afi_safi_print (afi, safi));
7964
7965                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV))
7966                               vty_out (vty, "advertised %s", afi_safi_print (afi, safi));
7967
7968                             if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_RCV))
7969                               vty_out (vty, "%sreceived", CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV) ? " and " : "" );
7970
7971                             vty_out (vty, "%s", VTY_NEWLINE);
7972                           }
7973                       }
7974                 }
7975
7976               /* Dynamic */
7977               if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV)
7978                   || CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV))
7979                 {
7980                   vty_out (vty, "    Dynamic:");
7981                   if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV))
7982                     vty_out (vty, " advertised");
7983                   if (CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_RCV))
7984                     vty_out (vty, " %sreceived",
7985                              CHECK_FLAG (p->cap, PEER_CAP_DYNAMIC_ADV) ? "and " : "");
7986                   vty_out (vty, "%s", VTY_NEWLINE);
7987                 }
7988
7989               /* Extended nexthop */
7990               if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV)
7991                   || CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV))
7992                 {
7993                   vty_out (vty, "    Extended nexthop:");
7994                   if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV))
7995                     vty_out (vty, " advertised");
7996                   if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV))
7997                     vty_out (vty, " %sreceived",
7998                              CHECK_FLAG (p->cap, PEER_CAP_ENHE_ADV) ? "and " : "");
7999                   vty_out (vty, "%s", VTY_NEWLINE);
8000
8001                   if (CHECK_FLAG (p->cap, PEER_CAP_ENHE_RCV))
8002                     {
8003                       vty_out (vty, "      Address families by peer:%s        ", VTY_NEWLINE);
8004                       for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8005                         if (CHECK_FLAG (p->af_cap[AFI_IP][safi], PEER_CAP_ENHE_AF_RCV))
8006                           vty_out (vty, "           %s%s",
8007                                    afi_safi_print (AFI_IP, safi), VTY_NEWLINE);
8008                     }
8009                 }
8010
8011               /* Route Refresh */
8012               if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV)
8013                   || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV)
8014                   || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV))
8015                 {
8016                   vty_out (vty, "    Route refresh:");
8017                   if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV))
8018                     vty_out (vty, " advertised");
8019                   if (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV)
8020                       || CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV))
8021                     vty_out (vty, " %sreceived(%s)",
8022                              CHECK_FLAG (p->cap, PEER_CAP_REFRESH_ADV) ? "and " : "",
8023                              (CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV)
8024                              && CHECK_FLAG (p->cap, PEER_CAP_REFRESH_NEW_RCV)) ?
8025                              "old & new" : CHECK_FLAG (p->cap, PEER_CAP_REFRESH_OLD_RCV) ? "old" : "new");
8026
8027                   vty_out (vty, "%s", VTY_NEWLINE);
8028                 }
8029
8030               /* Multiprotocol Extensions */
8031               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8032                 for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8033                   if (p->afc_adv[afi][safi] || p->afc_recv[afi][safi])
8034                     {
8035                       vty_out (vty, "    Address Family %s:", afi_safi_print (afi, safi));
8036                       if (p->afc_adv[afi][safi])
8037                         vty_out (vty, " advertised");
8038                       if (p->afc_recv[afi][safi])
8039                         vty_out (vty, " %sreceived", p->afc_adv[afi][safi] ? "and " : "");
8040                       vty_out (vty, "%s", VTY_NEWLINE);
8041                     }
8042
8043               /* Hostname capability */
8044               if (CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_ADV) ||
8045                   CHECK_FLAG(p->cap, PEER_CAP_HOSTNAME_RCV))
8046                 {
8047                   vty_out (vty, "    Hostname Capability:");
8048                   if (CHECK_FLAG (p->cap, PEER_CAP_HOSTNAME_ADV))
8049                     vty_out (vty, " advertised");
8050                   if (CHECK_FLAG (p->cap, PEER_CAP_HOSTNAME_RCV))
8051                     vty_out (vty, " %sreceived",
8052                              CHECK_FLAG (p->cap, PEER_CAP_HOSTNAME_ADV) ? "and " : "");
8053                   vty_out (vty, "%s", VTY_NEWLINE);
8054                 }
8055
8056               /* Gracefull Restart */
8057               if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV)
8058                   || CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV))
8059                 {
8060                   vty_out (vty, "    Graceful Restart Capabilty:");
8061                   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV))
8062                     vty_out (vty, " advertised");
8063                   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV))
8064                     vty_out (vty, " %sreceived",
8065                              CHECK_FLAG (p->cap, PEER_CAP_RESTART_ADV) ? "and " : "");
8066                   vty_out (vty, "%s", VTY_NEWLINE);
8067
8068                   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV))
8069                     {
8070                       int restart_af_count = 0;
8071
8072                       vty_out (vty, "      Remote Restart timer is %d seconds%s",
8073                                p->v_gr_restart, VTY_NEWLINE);
8074                       vty_out (vty, "      Address families by peer:%s        ", VTY_NEWLINE);
8075
8076                       for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8077                         for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8078                           if (CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_RESTART_AF_RCV))
8079                             {
8080                               vty_out (vty, "%s%s(%s)", restart_af_count ? ", " : "",
8081                                        afi_safi_print (afi, safi),
8082                                        CHECK_FLAG (p->af_cap[afi][safi], PEER_CAP_RESTART_AF_PRESERVE_RCV) ?
8083                                        "preserved" : "not preserved");
8084                               restart_af_count++;
8085                             }
8086                       if (! restart_af_count)
8087                         vty_out (vty, "none");
8088                       vty_out (vty, "%s", VTY_NEWLINE);
8089                     }
8090                 }
8091             }
8092         }
8093     }
8094
8095   /* graceful restart information */
8096   if (CHECK_FLAG (p->cap, PEER_CAP_RESTART_RCV)
8097       || p->t_gr_restart
8098       || p->t_gr_stale)
8099     {
8100       json_object *json_grace = NULL;
8101       json_object *json_grace_send = NULL;
8102       json_object *json_grace_recv = NULL;
8103       int eor_send_af_count = 0;
8104       int eor_receive_af_count = 0;
8105
8106       if (use_json)
8107         {
8108           json_grace = json_object_new_object();
8109           json_grace_send = json_object_new_object();
8110           json_grace_recv = json_object_new_object();
8111
8112           if (p->status == Established)
8113             {
8114               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8115                 {
8116                   for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8117                     {
8118                       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_EOR_SEND))
8119                         {
8120                           json_object_boolean_true_add(json_grace_send, afi_safi_print (afi, safi));
8121                           eor_send_af_count++;
8122                         }
8123                     }
8124                 }
8125               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8126                 {
8127                   for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8128                     {
8129                       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_EOR_RECEIVED))
8130                         {
8131                           json_object_boolean_true_add(json_grace_recv, afi_safi_print (afi, safi));
8132                           eor_receive_af_count++;
8133                         }
8134                     }
8135                 }
8136             }
8137
8138           json_object_object_add(json_grace, "endOfRibSend", json_grace_send);
8139           json_object_object_add(json_grace, "endOfRibRecv", json_grace_recv);
8140
8141           if (p->t_gr_restart)
8142             json_object_int_add(json_grace, "gracefulRestartTimerMsecs", thread_timer_remain_second (p->t_gr_restart) * 1000);
8143
8144           if (p->t_gr_stale)
8145             json_object_int_add(json_grace, "gracefulStalepathTimerMsecs", thread_timer_remain_second (p->t_gr_stale) * 1000);
8146
8147           json_object_object_add(json_neigh, "gracefulRestartInfo", json_grace);
8148         }
8149       else
8150         {
8151           vty_out (vty, "  Graceful restart informations:%s", VTY_NEWLINE);
8152           if (p->status == Established)
8153             {
8154               vty_out (vty, "    End-of-RIB send: ");
8155               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8156                 {
8157                   for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8158                     {
8159                       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_EOR_SEND))
8160                         {
8161                           vty_out (vty, "%s%s", eor_send_af_count ? ", " : "",
8162                                    afi_safi_print (afi, safi));
8163                           eor_send_af_count++;
8164                         }
8165                     }
8166                 }
8167               vty_out (vty, "%s", VTY_NEWLINE);
8168               vty_out (vty, "    End-of-RIB received: ");
8169               for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8170                 {
8171                   for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8172                     {
8173                       if (CHECK_FLAG (p->af_sflags[afi][safi], PEER_STATUS_EOR_RECEIVED))
8174                         {
8175                           vty_out (vty, "%s%s", eor_receive_af_count ? ", " : "",
8176                                    afi_safi_print (afi, safi));
8177                           eor_receive_af_count++;
8178                         }
8179                     }
8180                 }
8181               vty_out (vty, "%s", VTY_NEWLINE);
8182             }
8183
8184           if (p->t_gr_restart)
8185             vty_out (vty, "    The remaining time of restart timer is %ld%s",
8186                      thread_timer_remain_second (p->t_gr_restart), VTY_NEWLINE);
8187
8188           if (p->t_gr_stale)
8189             vty_out (vty, "    The remaining time of stalepath timer is %ld%s",
8190                      thread_timer_remain_second (p->t_gr_stale), VTY_NEWLINE);
8191         }
8192     }
8193   if (use_json)
8194     {
8195       json_object *json_stat = NULL;
8196       json_stat = json_object_new_object();
8197       /* Packet counts. */
8198       json_object_int_add(json_stat, "depthInq", 0);
8199       json_object_int_add(json_stat, "depthOutq", (unsigned long) p->obuf->count);
8200       json_object_int_add(json_stat, "opensSent",  p->open_out);
8201       json_object_int_add(json_stat, "opensRecv", p->open_in);
8202       json_object_int_add(json_stat, "notificationsSent", p->notify_out);
8203       json_object_int_add(json_stat, "notificationsRecv", p->notify_in);
8204       json_object_int_add(json_stat, "updatesSent", p->update_out);
8205       json_object_int_add(json_stat, "updatesRecv", p->update_in);
8206       json_object_int_add(json_stat, "keepalivesSent", p->keepalive_out);
8207       json_object_int_add(json_stat, "keepalivesRecv", p->keepalive_in);
8208       json_object_int_add(json_stat, "routeRefreshSent", p->refresh_out);
8209       json_object_int_add(json_stat, "routeRefreshRecv", p->refresh_in);
8210       json_object_int_add(json_stat, "capabilitySent", p->dynamic_cap_out);
8211       json_object_int_add(json_stat, "capabilityRecv", p->dynamic_cap_in);
8212       json_object_int_add(json_stat, "totalSent", p->open_out + p->notify_out + p->update_out + p->keepalive_out + p->refresh_out + p->dynamic_cap_out);
8213       json_object_int_add(json_stat, "totalRecv", p->open_in + p->notify_in + p->update_in + p->keepalive_in + p->refresh_in + p->dynamic_cap_in);
8214       json_object_object_add(json_neigh, "messageStats", json_stat);
8215     }
8216   else
8217     {
8218       /* Packet counts. */
8219       vty_out (vty, "  Message statistics:%s", VTY_NEWLINE);
8220       vty_out (vty, "    Inq depth is 0%s", VTY_NEWLINE);
8221       vty_out (vty, "    Outq depth is %lu%s", (unsigned long) p->obuf->count, VTY_NEWLINE);
8222       vty_out (vty, "                         Sent       Rcvd%s", VTY_NEWLINE);
8223       vty_out (vty, "    Opens:         %10d %10d%s", p->open_out, p->open_in, VTY_NEWLINE);
8224       vty_out (vty, "    Notifications: %10d %10d%s", p->notify_out, p->notify_in, VTY_NEWLINE);
8225       vty_out (vty, "    Updates:       %10d %10d%s", p->update_out, p->update_in, VTY_NEWLINE);
8226       vty_out (vty, "    Keepalives:    %10d %10d%s", p->keepalive_out, p->keepalive_in, VTY_NEWLINE);
8227       vty_out (vty, "    Route Refresh: %10d %10d%s", p->refresh_out, p->refresh_in, VTY_NEWLINE);
8228       vty_out (vty, "    Capability:    %10d %10d%s", p->dynamic_cap_out, p->dynamic_cap_in, VTY_NEWLINE);
8229       vty_out (vty, "    Total:         %10d %10d%s", p->open_out + p->notify_out +
8230                p->update_out + p->keepalive_out + p->refresh_out + p->dynamic_cap_out,
8231                p->open_in + p->notify_in + p->update_in + p->keepalive_in + p->refresh_in +
8232                p->dynamic_cap_in, VTY_NEWLINE);
8233     }
8234
8235   if (use_json)
8236     {
8237       /* advertisement-interval */
8238       json_object_int_add(json_neigh, "minBtwnAdvertisementRunsTimerMsecs", p->v_routeadv * 1000);
8239
8240       /* Update-source. */
8241       if (p->update_if || p->update_source)
8242         {
8243           if (p->update_if)
8244             json_object_string_add(json_neigh, "updateSource", p->update_if);
8245           else if (p->update_source)
8246             json_object_string_add(json_neigh, "updateSource", sockunion2str (p->update_source, buf1, SU_ADDRSTRLEN));
8247         }
8248     }
8249   else
8250     {
8251       /* advertisement-interval */
8252       vty_out (vty, "  Minimum time between advertisement runs is %d seconds%s",
8253                p->v_routeadv, VTY_NEWLINE);
8254
8255       /* Update-source. */
8256       if (p->update_if || p->update_source)
8257         {
8258           vty_out (vty, "  Update source is ");
8259           if (p->update_if)
8260             vty_out (vty, "%s", p->update_if);
8261           else if (p->update_source)
8262             vty_out (vty, "%s", sockunion2str (p->update_source, buf1, SU_ADDRSTRLEN));
8263           vty_out (vty, "%s", VTY_NEWLINE);
8264         }
8265
8266       vty_out (vty, "%s", VTY_NEWLINE);
8267     }
8268
8269   /* Address Family Information */
8270   json_object *json_hold = NULL;
8271
8272   if (use_json)
8273     json_hold = json_object_new_object();
8274
8275   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
8276     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
8277       if (p->afc[afi][safi])
8278         bgp_show_peer_afi (vty, p, afi, safi, use_json, json_hold);
8279
8280   if (use_json)
8281     {
8282       json_object_object_add(json_neigh, "addressFamilyInfo", json_hold);
8283       json_object_int_add(json_neigh, "connectionsEstablished", p->established);
8284       json_object_int_add(json_neigh, "connectionsDropped", p->dropped);
8285     }
8286   else
8287     vty_out (vty, "  Connections established %d; dropped %d%s", p->established, p->dropped,
8288              VTY_NEWLINE);
8289
8290   if (! p->last_reset)
8291     {
8292       if (use_json)
8293         json_object_string_add(json_neigh, "lastReset", "never");
8294       else
8295         vty_out (vty, "  Last reset never%s", VTY_NEWLINE);
8296     }
8297   else
8298     {
8299       if (use_json)
8300         {
8301           time_t uptime;
8302           struct tm *tm;
8303
8304           uptime = bgp_clock();
8305           uptime -= p->resettime;
8306           tm = gmtime(&uptime);
8307           json_object_int_add(json_neigh, "lastResetTimerMsecs", (tm->tm_sec * 1000) + (tm->tm_min * 60000) + (tm->tm_hour * 3600000));
8308           json_object_string_add(json_neigh, "lastResetDueTo", peer_down_str[(int) p->last_reset]);
8309           if (p->last_reset == PEER_DOWN_NOTIFY_SEND ||
8310               p->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
8311             {
8312               char errorcodesubcode_hexstr[5];
8313               char errorcodesubcode_str[256];
8314
8315               code_str = bgp_notify_code_str(p->notify.code);
8316               subcode_str = bgp_notify_subcode_str(p->notify.code, p->notify.subcode);
8317
8318               sprintf(errorcodesubcode_hexstr, "%02X%02X", p->notify.code, p->notify.subcode);
8319               json_object_string_add(json_neigh, "lastErrorCodeSubcode", errorcodesubcode_hexstr);
8320               snprintf(errorcodesubcode_str, 255, "%s%s", code_str, subcode_str);
8321               json_object_string_add(json_neigh, "lastNotificationReason", errorcodesubcode_str);
8322               if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
8323                   && p->notify.code == BGP_NOTIFY_CEASE
8324                   && (p->notify.subcode == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
8325                       || p->notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)
8326                   && p->notify.length)
8327                 {
8328                   char msgbuf[1024];
8329                   const char *msg_str;
8330
8331                   msg_str = bgp_notify_admin_message(msgbuf, sizeof(msgbuf),
8332                                                      (u_char*)p->notify.data, p->notify.length);
8333                   if (msg_str)
8334                     json_object_string_add(json_neigh, "lastShutdownDescription", msg_str);
8335                 }
8336             }
8337         }
8338       else
8339         {
8340           vty_out (vty, "  Last reset %s, ",
8341                    peer_uptime (p->resettime, timebuf, BGP_UPTIME_LEN, 0, NULL));
8342
8343           if (p->last_reset == PEER_DOWN_NOTIFY_SEND ||
8344               p->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
8345             {
8346               code_str = bgp_notify_code_str(p->notify.code);
8347               subcode_str = bgp_notify_subcode_str(p->notify.code, p->notify.subcode);
8348               vty_out (vty, "due to NOTIFICATION %s (%s%s)%s",
8349                        p->last_reset == PEER_DOWN_NOTIFY_SEND ? "sent" : "received",
8350                        code_str, subcode_str, VTY_NEWLINE);
8351               if (p->last_reset == PEER_DOWN_NOTIFY_RECEIVED
8352                   && p->notify.code == BGP_NOTIFY_CEASE
8353                   && (p->notify.subcode == BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN
8354                       || p->notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)
8355                   && p->notify.length)
8356                 {
8357                   char msgbuf[1024];
8358                   const char *msg_str;
8359
8360                   msg_str = bgp_notify_admin_message(msgbuf, sizeof(msgbuf),
8361                                                      (u_char*)p->notify.data, p->notify.length);
8362                   if (msg_str)
8363                     vty_out (vty, "    Message: \"%s\"%s", msg_str, VTY_NEWLINE);
8364                 }
8365             }
8366           else
8367             {
8368               vty_out (vty, "due to %s%s",
8369                        peer_down_str[(int) p->last_reset], VTY_NEWLINE);
8370             }
8371
8372           if (p->last_reset_cause_size)
8373             {
8374               msg = p->last_reset_cause;
8375               vty_out(vty, "  Message received that caused BGP to send a NOTIFICATION:%s    ", VTY_NEWLINE);
8376               for (i = 1; i <= p->last_reset_cause_size; i++)
8377                 {
8378                   vty_out(vty, "%02X", *msg++);
8379
8380                   if (i != p->last_reset_cause_size)
8381                     {
8382                       if (i % 16 == 0)
8383                         {
8384                           vty_out(vty, "%s    ", VTY_NEWLINE);
8385                         }
8386                       else if (i % 4 == 0)
8387                         {
8388                           vty_out(vty, " ");
8389                         }
8390                     }
8391                 }
8392               vty_out(vty, "%s", VTY_NEWLINE);
8393             }
8394         }
8395     }
8396
8397   if (CHECK_FLAG (p->sflags, PEER_STATUS_PREFIX_OVERFLOW))
8398     {
8399       if (use_json)
8400         json_object_boolean_true_add(json_neigh, "prefixesConfigExceedMax");
8401       else
8402         vty_out (vty, "  Peer had exceeded the max. no. of prefixes configured.%s", VTY_NEWLINE);
8403
8404       if (p->t_pmax_restart)
8405         {
8406           if (use_json)
8407             {
8408               json_object_boolean_true_add(json_neigh, "reducePrefixNumFrom");
8409               json_object_int_add(json_neigh, "restartInTimerMsec", thread_timer_remain_second (p->t_pmax_restart) * 1000);
8410             }
8411           else
8412             vty_out (vty, "  Reduce the no. of prefix from %s, will restart in %ld seconds%s",
8413                      p->host, thread_timer_remain_second (p->t_pmax_restart),
8414                      VTY_NEWLINE);
8415         }
8416       else
8417         {
8418           if (use_json)
8419             json_object_boolean_true_add(json_neigh, "reducePrefixNumAndClearIpBgp");
8420           else
8421             vty_out (vty, "  Reduce the no. of prefix and clear ip bgp %s to restore peering%s",
8422                      p->host, VTY_NEWLINE);
8423         }
8424     }
8425
8426   /* EBGP Multihop and GTSM */
8427   if (p->sort != BGP_PEER_IBGP)
8428     {
8429       if (use_json)
8430         {
8431           if (p->gtsm_hops > 0)
8432             json_object_int_add(json_neigh, "externalBgpNbrMaxHopsAway", p->gtsm_hops);
8433           else if (p->ttl > 1)
8434             json_object_int_add(json_neigh, "externalBgpNbrMaxHopsAway", p->ttl);
8435         }
8436       else
8437         {
8438           if (p->gtsm_hops > 0)
8439             vty_out (vty, "  External BGP neighbor may be up to %d hops away.%s",
8440                      p->gtsm_hops, VTY_NEWLINE);
8441           else if (p->ttl > 1)
8442             vty_out (vty, "  External BGP neighbor may be up to %d hops away.%s",
8443                      p->ttl, VTY_NEWLINE);
8444         }
8445     }
8446   else
8447     {
8448       if (p->gtsm_hops > 0)
8449         {
8450           if (use_json)
8451             json_object_int_add(json_neigh, "internalBgpNbrMaxHopsAway", p->gtsm_hops);
8452           else
8453             vty_out (vty, "  Internal BGP neighbor may be up to %d hops away.%s",
8454                      p->gtsm_hops, VTY_NEWLINE);
8455         }
8456     }
8457
8458   /* Local address. */
8459   if (p->su_local)
8460     {
8461       if (use_json)
8462         {
8463           json_object_string_add(json_neigh, "hostLocal", sockunion2str (p->su_local, buf1, SU_ADDRSTRLEN));
8464           json_object_int_add(json_neigh, "portLocal", ntohs (p->su_local->sin.sin_port));
8465         }
8466       else
8467         vty_out (vty, "Local host: %s, Local port: %d%s",
8468                  sockunion2str (p->su_local, buf1, SU_ADDRSTRLEN),
8469                  ntohs (p->su_local->sin.sin_port),
8470                  VTY_NEWLINE);
8471     }
8472
8473   /* Remote address. */
8474   if (p->su_remote)
8475     {
8476       if (use_json)
8477         {
8478           json_object_string_add(json_neigh, "hostForeign", sockunion2str (p->su_remote, buf1, SU_ADDRSTRLEN));
8479           json_object_int_add(json_neigh, "portForeign", ntohs (p->su_remote->sin.sin_port));
8480         }
8481       else
8482         vty_out (vty, "Foreign host: %s, Foreign port: %d%s",
8483                sockunion2str (p->su_remote, buf1, SU_ADDRSTRLEN),
8484                ntohs (p->su_remote->sin.sin_port),
8485                VTY_NEWLINE);
8486     }
8487
8488   /* Nexthop display. */
8489   if (p->su_local)
8490     {
8491       if (use_json)
8492         {
8493           json_object_string_add(json_neigh, "nexthop",
8494                                  inet_ntop (AF_INET, &p->nexthop.v4, buf1, sizeof(buf1)));
8495           json_object_string_add(json_neigh, "nexthopGlobal",
8496                                  inet_ntop (AF_INET6, &p->nexthop.v6_global, buf1, sizeof(buf1)));
8497           json_object_string_add(json_neigh, "nexthopLocal",
8498                                  inet_ntop (AF_INET6, &p->nexthop.v6_local, buf1, sizeof(buf1)));
8499           if (p->shared_network)
8500             json_object_string_add(json_neigh, "bgpConnection", "sharedNetwork");
8501           else
8502             json_object_string_add(json_neigh, "bgpConnection", "nonSharedNetwork");
8503         }
8504       else
8505         {
8506           vty_out (vty, "Nexthop: %s%s",
8507                    inet_ntop (AF_INET, &p->nexthop.v4, buf1, sizeof(buf1)),
8508                    VTY_NEWLINE);
8509           vty_out (vty, "Nexthop global: %s%s",
8510                    inet_ntop (AF_INET6, &p->nexthop.v6_global, buf1, sizeof(buf1)),
8511                    VTY_NEWLINE);
8512           vty_out (vty, "Nexthop local: %s%s",
8513                    inet_ntop (AF_INET6, &p->nexthop.v6_local, buf1, sizeof(buf1)),
8514                    VTY_NEWLINE);
8515           vty_out (vty, "BGP connection: %s%s",
8516                    p->shared_network ? "shared network" : "non shared network",
8517                    VTY_NEWLINE);
8518         }
8519     }
8520
8521   /* Timer information. */
8522   if (use_json)
8523     {
8524       json_object_int_add(json_neigh, "connectRetryTimer", p->v_connect);
8525       if (p->status == Established && p->rtt)
8526         json_object_int_add(json_neigh, "estimatedRttInMsecs", p->rtt);
8527       if (p->t_start)
8528         json_object_int_add(json_neigh, "nextStartTimerDueInMsecs", thread_timer_remain_second (p->t_start) * 1000);
8529       if (p->t_connect)
8530         json_object_int_add(json_neigh, "nextConnectTimerDueInMsecs", thread_timer_remain_second (p->t_connect) * 1000);
8531       if (p->t_routeadv)
8532         {
8533           json_object_int_add(json_neigh, "mraiInterval", p->v_routeadv);
8534           json_object_int_add(json_neigh, "mraiTimerExpireInMsecs", thread_timer_remain_second (p->t_routeadv) * 1000);
8535         }
8536
8537       if (p->t_read)
8538         json_object_string_add(json_neigh, "readThread", "on");
8539       else
8540         json_object_string_add(json_neigh, "readThread", "off");
8541       if (p->t_write)
8542         json_object_string_add(json_neigh, "writeThread", "on");
8543       else
8544         json_object_string_add(json_neigh, "writeThread", "off");
8545     }
8546   else
8547     {
8548       vty_out (vty, "BGP Connect Retry Timer in Seconds: %d%s",
8549                p->v_connect, VTY_NEWLINE);
8550       if (p->status == Established && p->rtt)
8551         vty_out (vty, "Estimated round trip time: %d ms%s",
8552                  p->rtt, VTY_NEWLINE);
8553       if (p->t_start)
8554         vty_out (vty, "Next start timer due in %ld seconds%s",
8555                  thread_timer_remain_second (p->t_start), VTY_NEWLINE);
8556       if (p->t_connect)
8557         vty_out (vty, "Next connect timer due in %ld seconds%s",
8558                  thread_timer_remain_second (p->t_connect), VTY_NEWLINE);
8559       if (p->t_routeadv)
8560         vty_out (vty, "MRAI (interval %u) timer expires in %ld seconds%s",
8561                  p->v_routeadv, thread_timer_remain_second (p->t_routeadv),
8562                  VTY_NEWLINE);
8563
8564       vty_out (vty, "Read thread: %s  Write thread: %s%s",
8565                p->t_read ? "on" : "off",
8566                p->t_write ? "on" : "off",
8567                VTY_NEWLINE);
8568     }
8569
8570   if (p->notify.code == BGP_NOTIFY_OPEN_ERR
8571       && p->notify.subcode == BGP_NOTIFY_OPEN_UNSUP_CAPBL)
8572     bgp_capability_vty_out (vty, p, use_json, json_neigh);
8573
8574   if (!use_json)
8575     vty_out (vty, "%s", VTY_NEWLINE);
8576
8577   /* BFD information. */
8578   bgp_bfd_show_info(vty, p, use_json, json_neigh);
8579
8580   if (use_json)
8581     {
8582       if (p->conf_if) /* Configured interface name. */
8583         json_object_object_add(json, p->conf_if, json_neigh);
8584       else /* Configured IP address. */
8585         json_object_object_add(json, p->host, json_neigh);
8586     }
8587 }
8588
8589 static int
8590 bgp_show_neighbor (struct vty *vty, struct bgp *bgp, enum show_type type,
8591                    union sockunion *su, const char *conf_if, u_char use_json, json_object *json)
8592 {
8593   struct listnode *node, *nnode;
8594   struct peer *peer;
8595   int find = 0;
8596
8597   for (ALL_LIST_ELEMENTS (bgp->peer, node, nnode, peer))
8598     {
8599       if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
8600         continue;
8601
8602       switch (type)
8603         {
8604           case show_all:
8605             bgp_show_peer (vty, peer, use_json, json);
8606           break;
8607           case show_peer:
8608             if (conf_if)
8609               {
8610                 if ((peer->conf_if && !strcmp(peer->conf_if, conf_if)) ||
8611                     (peer->hostname && !strcmp(peer->hostname, conf_if)))
8612                   {
8613                     find = 1;
8614                     bgp_show_peer (vty, peer, use_json, json);
8615                   }
8616               }
8617             else
8618               {
8619                if (sockunion_same (&peer->su, su))
8620                  {
8621                    find = 1;
8622                    bgp_show_peer (vty, peer, use_json, json);
8623                  }
8624               }
8625           break;
8626         }
8627     }
8628
8629   if (type == show_peer && ! find)
8630     {
8631       if (use_json)
8632         json_object_boolean_true_add(json, "bgpNoSuchNeighbor");
8633       else
8634         vty_out (vty, "%% No such neighbor%s", VTY_NEWLINE);
8635     }
8636
8637   if (use_json)
8638     {
8639       vty_out (vty, "%s%s", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY), VTY_NEWLINE);
8640       json_object_free(json);
8641     }
8642   else
8643     {
8644       vty_out (vty, "%s", VTY_NEWLINE);
8645     }
8646
8647   return CMD_SUCCESS;
8648 }
8649
8650 static void
8651 bgp_show_all_instances_neighbors_vty (struct vty *vty, u_char use_json)
8652 {
8653   struct listnode *node, *nnode;
8654   struct bgp *bgp;
8655   json_object *json = NULL;
8656   int is_first = 1;
8657
8658   if (use_json)
8659     vty_out (vty, "{%s", VTY_NEWLINE);
8660
8661   for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
8662     {
8663       if (use_json)
8664         {
8665           if (!(json = json_object_new_object()))
8666             {
8667               zlog_err("Unable to allocate memory for JSON object");
8668               vty_out (vty,
8669                        "{\"error\": {\"message:\": \"Unable to allocate memory for JSON object\"}}}%s",
8670                        VTY_NEWLINE);
8671               return;
8672             }
8673
8674           json_object_int_add(json, "vrfId",
8675                               (bgp->vrf_id == VRF_UNKNOWN)
8676                               ? -1 : bgp->vrf_id);
8677           json_object_string_add(json, "vrfName",
8678                                  (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8679                                  ? "Default" : bgp->name);
8680
8681           if (! is_first)
8682             vty_out (vty, ",%s", VTY_NEWLINE);
8683           else
8684             is_first = 0;
8685
8686           vty_out(vty, "\"%s\":", (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8687                   ? "Default" : bgp->name);
8688         }
8689       else
8690         {
8691           vty_out (vty, "%sInstance %s:%s",
8692                    VTY_NEWLINE,
8693                    (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
8694                    ? "Default" : bgp->name,
8695                    VTY_NEWLINE);
8696         }
8697       bgp_show_neighbor (vty, bgp, show_all, NULL, NULL, use_json, json);
8698     }
8699
8700   if (use_json)
8701     vty_out (vty, "}%s", VTY_NEWLINE);
8702 }
8703
8704 static int
8705 bgp_show_neighbor_vty (struct vty *vty, const char *name,
8706                        enum show_type type, const char *ip_str, u_char use_json)
8707 {
8708   int ret;
8709   struct bgp *bgp;
8710   union sockunion su;
8711   json_object *json = NULL;
8712
8713   if (use_json)
8714     json = json_object_new_object();
8715
8716   if (name)
8717     {
8718       if (strmatch(name, "all"))
8719         {
8720           bgp_show_all_instances_neighbors_vty (vty, use_json);
8721           return CMD_SUCCESS;
8722         }
8723       else
8724         {
8725           bgp = bgp_lookup_by_name (name);
8726           if (! bgp)
8727             {
8728               if (use_json)
8729                 {
8730                   json_object_boolean_true_add(json, "bgpNoSuchInstance");
8731                   vty_out (vty, "%s%s", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY), VTY_NEWLINE);
8732                   json_object_free(json);
8733                 }
8734               else
8735                 vty_out (vty, "%% No such BGP instance exist%s", VTY_NEWLINE);
8736
8737               return CMD_WARNING;
8738             }
8739           }
8740     }
8741   else
8742     {
8743       bgp = bgp_get_default ();
8744     }
8745
8746   if (bgp)
8747     {
8748       if (ip_str)
8749         {
8750           ret = str2sockunion (ip_str, &su);
8751           if (ret < 0)
8752             bgp_show_neighbor (vty, bgp, type, NULL, ip_str, use_json, json);
8753           else
8754             bgp_show_neighbor (vty, bgp, type, &su, NULL, use_json, json);
8755         }
8756       else
8757         {
8758           bgp_show_neighbor (vty, bgp, type, NULL, NULL, use_json, json);
8759         }
8760     }
8761
8762   return CMD_SUCCESS;
8763 }
8764
8765 /* "show [ip] bgp neighbors" commands.  */
8766 DEFUN (show_ip_bgp_neighbors,
8767        show_ip_bgp_neighbors_cmd,
8768        "show [ip] bgp [<view|vrf> WORD] [<ipv4|ipv6|vpnv4 <all|rd ASN:nn_or_IP-address:nn>>] neighbors [<A.B.C.D|X:X::X:X|WORD>] [json]",
8769        SHOW_STR
8770        IP_STR
8771        BGP_STR
8772        BGP_INSTANCE_HELP_STR
8773        "Address Family\n"
8774        "Address Family\n"
8775        "Address Family\n"
8776        "Display information about all VPNv4 NLRIs\n"
8777        "Display information for a route distinguisher\n"
8778        "VPN Route Distinguisher\n"
8779        "Detailed information on TCP and BGP neighbor connections\n"
8780        "Neighbor to display information about\n"
8781        "Neighbor to display information about\n"
8782        "Neighbor on BGP configured interface\n"
8783        JSON_STR)
8784 {
8785   char *vrf = NULL;
8786   char *sh_arg = NULL;
8787   enum show_type sh_type;
8788
8789   u_char uj = use_json(argc, argv);
8790
8791   int idx = 0;
8792
8793   if (argv_find (argv, argc, "WORD", &idx))
8794     vrf = argv[idx]->arg;
8795
8796   if (argv_find (argv, argc, "A.B.C.D", &idx) ||
8797       argv_find (argv, argc, "X:X::X:X", &idx) ||
8798       argv_find (argv, argc, "WORD", &idx))
8799   {
8800     sh_type = show_peer;
8801     sh_arg = argv[idx]->arg;
8802   }
8803   else
8804     sh_type = show_all;
8805
8806   return bgp_show_neighbor_vty (vty, vrf, sh_type, sh_arg, uj);
8807 }
8808
8809 /* Show BGP's AS paths internal data.  There are both `show [ip] bgp
8810    paths' and `show ip mbgp paths'.  Those functions results are the
8811    same.*/
8812 DEFUN (show_ip_bgp_paths,
8813        show_ip_bgp_paths_cmd,
8814        "show [ip] bgp ["BGP_SAFI_CMD_STR"] paths",
8815        SHOW_STR
8816        IP_STR
8817        BGP_STR
8818        BGP_SAFI_HELP_STR
8819        "Path information\n")
8820 {
8821   vty_out (vty, "Address Refcnt Path%s", VTY_NEWLINE);
8822   aspath_print_all_vty (vty);
8823   return CMD_SUCCESS;
8824 }
8825
8826 #include "hash.h"
8827
8828 static void
8829 community_show_all_iterator (struct hash_backet *backet, struct vty *vty)
8830 {
8831   struct community *com;
8832
8833   com = (struct community *) backet->data;
8834   vty_out (vty, "[%p] (%ld) %s%s", (void *)backet, com->refcnt,
8835            community_str (com), VTY_NEWLINE);
8836 }
8837
8838 /* Show BGP's community internal data. */
8839 DEFUN (show_ip_bgp_community_info,
8840        show_ip_bgp_community_info_cmd,
8841        "show [ip] bgp community-info",
8842        SHOW_STR
8843        IP_STR
8844        BGP_STR
8845        "List all bgp community information\n")
8846 {
8847   vty_out (vty, "Address Refcnt Community%s", VTY_NEWLINE);
8848
8849   hash_iterate (community_hash (),
8850                 (void (*) (struct hash_backet *, void *))
8851                 community_show_all_iterator,
8852                 vty);
8853
8854   return CMD_SUCCESS;
8855 }
8856
8857 static void
8858 lcommunity_show_all_iterator (struct hash_backet *backet, struct vty *vty)
8859 {
8860   struct lcommunity *lcom;
8861
8862   lcom = (struct lcommunity *) backet->data;
8863   vty_out (vty, "[%p] (%ld) %s%s", (void *)backet, lcom->refcnt,
8864            lcommunity_str (lcom), VTY_NEWLINE);
8865 }
8866
8867 /* Show BGP's community internal data. */
8868 DEFUN (show_ip_bgp_lcommunity_info,
8869        show_ip_bgp_lcommunity_info_cmd,
8870        "show ip bgp large-community-info",
8871        SHOW_STR
8872        IP_STR
8873        BGP_STR
8874        "List all bgp large-community information\n")
8875 {
8876   vty_out (vty, "Address Refcnt Large-community%s", VTY_NEWLINE);
8877
8878   hash_iterate (lcommunity_hash (),
8879                 (void (*) (struct hash_backet *, void *))
8880                 lcommunity_show_all_iterator,
8881                 vty);
8882
8883   return CMD_SUCCESS;
8884 }
8885
8886
8887 DEFUN (show_ip_bgp_attr_info,
8888        show_ip_bgp_attr_info_cmd,
8889        "show [ip] bgp attribute-info",
8890        SHOW_STR
8891        IP_STR
8892        BGP_STR
8893        "List all bgp attribute information\n")
8894 {
8895   attr_show_all (vty);
8896   return CMD_SUCCESS;
8897 }
8898
8899 static void
8900 bgp_show_all_instances_updgrps_vty (struct vty *vty, afi_t afi, safi_t safi)
8901 {
8902   struct listnode *node, *nnode;
8903   struct bgp *bgp;
8904
8905   for (ALL_LIST_ELEMENTS (bm->bgp, node, nnode, bgp))
8906     {
8907       vty_out (vty, "%sInstance %s:%s",
8908                VTY_NEWLINE,
8909                (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) ? "Default" : bgp->name,
8910                VTY_NEWLINE);
8911       update_group_show(bgp, afi, safi, vty, 0);
8912     }
8913 }
8914
8915 static int
8916 bgp_show_update_groups(struct vty *vty, const char *name,
8917                        int afi, int safi,
8918                        uint64_t subgrp_id)
8919 {
8920   struct bgp *bgp;
8921
8922   if (name)
8923     {
8924       if (strmatch (name, "all"))
8925         {
8926           bgp_show_all_instances_updgrps_vty (vty, afi, safi);
8927           return CMD_SUCCESS;
8928         }
8929       else
8930         {
8931           bgp = bgp_lookup_by_name (name);
8932         }
8933     }
8934   else
8935     {
8936       bgp = bgp_get_default ();
8937     }
8938
8939   if (bgp)
8940     update_group_show(bgp, afi, safi, vty, subgrp_id);
8941   return CMD_SUCCESS;
8942 }
8943
8944 DEFUN (show_ip_bgp_updgrps,
8945        show_ip_bgp_updgrps_cmd,
8946        "show [ip] bgp [<view|vrf> WORD] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] update-groups [SUBGROUP-ID]",
8947        SHOW_STR
8948        IP_STR
8949        BGP_STR
8950        BGP_INSTANCE_HELP_STR
8951        BGP_AFI_HELP_STR
8952        BGP_SAFI_HELP_STR
8953        "Detailed info about dynamic update groups\n"
8954        "Specific subgroup to display detailed info for\n")
8955 {
8956   char *vrf = NULL;
8957   afi_t afi = AFI_IP6;
8958   safi_t safi = SAFI_UNICAST;
8959   uint64_t subgrp_id = 0;
8960
8961   int idx = 0;
8962
8963   /* show [ip] bgp */
8964   if (argv_find (argv, argc, "ip", &idx))
8965     afi = AFI_IP;
8966   /* [<view|vrf> WORD] */
8967   if (argv_find (argv, argc, "view", &idx) || argv_find (argv, argc, "vrf", &idx))
8968     vrf = argv[++idx]->arg;
8969   /* ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] */
8970   if (argv_find_and_parse_afi (argv, argc, &idx, &afi))
8971     {
8972       argv_find_and_parse_safi (argv, argc, &idx, &safi);
8973     }
8974
8975   /* get subgroup id, if provided */
8976   idx = argc - 1;
8977   if (argv[idx]->type == VARIABLE_TKN)
8978     VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx]->arg);
8979
8980   return (bgp_show_update_groups(vty, vrf, afi, safi, subgrp_id));
8981 }
8982
8983 DEFUN (show_bgp_instance_all_ipv6_updgrps,
8984        show_bgp_instance_all_ipv6_updgrps_cmd,
8985        "show [ip] bgp <view|vrf> all update-groups",
8986        SHOW_STR
8987        IP_STR
8988        BGP_STR
8989        BGP_INSTANCE_ALL_HELP_STR
8990        "Detailed info about dynamic update groups\n")
8991 {
8992   bgp_show_all_instances_updgrps_vty (vty, AFI_IP6, SAFI_UNICAST);
8993   return CMD_SUCCESS;
8994 }
8995
8996 DEFUN (show_bgp_updgrps_stats,
8997        show_bgp_updgrps_stats_cmd,
8998        "show [ip] bgp update-groups statistics",
8999        SHOW_STR
9000        IP_STR
9001        BGP_STR
9002        "Detailed info about dynamic update groups\n"
9003        "Statistics\n")
9004 {
9005   struct bgp *bgp;
9006
9007   bgp = bgp_get_default();
9008   if (bgp)
9009     update_group_show_stats(bgp, vty);
9010
9011   return CMD_SUCCESS;
9012 }
9013
9014 DEFUN (show_bgp_instance_updgrps_stats,
9015        show_bgp_instance_updgrps_stats_cmd,
9016        "show [ip] bgp <view|vrf> WORD update-groups statistics",
9017        SHOW_STR
9018        IP_STR
9019        BGP_STR
9020        BGP_INSTANCE_HELP_STR
9021        "Detailed info about dynamic update groups\n"
9022        "Statistics\n")
9023 {
9024   int idx_word = 3;
9025   struct bgp *bgp;
9026
9027   bgp = bgp_lookup_by_name (argv[idx_word]->arg);
9028   if (bgp)
9029     update_group_show_stats(bgp, vty);
9030
9031   return CMD_SUCCESS;
9032 }
9033
9034 static void
9035 show_bgp_updgrps_adj_info_aux (struct vty *vty, const char *name,
9036                                afi_t afi, safi_t safi,
9037                                const char *what, uint64_t subgrp_id)
9038 {
9039   struct bgp *bgp;
9040
9041  if (name)
9042     bgp = bgp_lookup_by_name (name);
9043   else
9044     bgp = bgp_get_default ();
9045
9046   if (bgp)
9047     {
9048       if (!strcmp(what, "advertise-queue"))
9049         update_group_show_adj_queue(bgp, afi, safi, vty, subgrp_id);
9050       else if (!strcmp(what, "advertised-routes"))
9051         update_group_show_advertised(bgp, afi, safi, vty, subgrp_id);
9052       else if (!strcmp(what, "packet-queue"))
9053         update_group_show_packet_queue(bgp, afi, safi, vty, subgrp_id);
9054     }
9055 }
9056
9057 DEFUN (show_ip_bgp_updgrps_adj,
9058        show_ip_bgp_updgrps_adj_cmd,
9059        "show [ip] bgp update-groups <advertise-queue|advertised-routes|packet-queue>",
9060        SHOW_STR
9061        IP_STR
9062        BGP_STR
9063        "Detailed info about dynamic update groups\n"
9064        "Advertisement queue\n"
9065        "Announced routes\n"
9066        "Packet queue\n")
9067
9068 {
9069   int idx_type = 4;
9070   show_bgp_updgrps_adj_info_aux(vty, NULL, AFI_IP, SAFI_UNICAST, argv[idx_type]->arg, 0);
9071   return CMD_SUCCESS;
9072 }
9073
9074 DEFUN (show_ip_bgp_instance_updgrps_adj,
9075        show_ip_bgp_instance_updgrps_adj_cmd,
9076        "show [ip] bgp <view|vrf> WORD update-groups <advertise-queue|advertised-routes|packet-queue>",
9077        SHOW_STR
9078        IP_STR
9079        BGP_STR
9080        BGP_INSTANCE_HELP_STR
9081        "Detailed info about dynamic update groups\n"
9082        "Advertisement queue\n"
9083        "Announced routes\n"
9084        "Packet queue\n")
9085
9086 {
9087   int idx_word = 4;
9088   int idx_type = 6;
9089   show_bgp_updgrps_adj_info_aux(vty, argv[idx_word]->arg, AFI_IP, SAFI_UNICAST, argv[idx_type]->arg, 0);
9090   return CMD_SUCCESS;
9091 }
9092
9093 DEFUN (show_bgp_updgrps_afi_adj,
9094        show_bgp_updgrps_afi_adj_cmd,
9095        "show [ip] bgp "BGP_AFI_SAFI_CMD_STR" update-groups <advertise-queue|advertised-routes|packet-queue>",
9096        SHOW_STR
9097        IP_STR
9098        BGP_STR
9099        BGP_AFI_SAFI_HELP_STR
9100        "Detailed info about dynamic update groups\n"
9101        "Advertisement queue\n"
9102        "Announced routes\n"
9103        "Packet queue\n"
9104        "Specific subgroup info wanted for\n")
9105 {
9106   int idx_afi = 2;
9107   int idx_safi = 3;
9108   int idx_type = 5;
9109   show_bgp_updgrps_adj_info_aux(vty, NULL,
9110                                 bgp_vty_afi_from_arg(argv[idx_afi]->arg),
9111                                 bgp_vty_safi_from_arg(argv[idx_safi]->arg),
9112                                 argv[idx_type]->arg, 0);
9113   return CMD_SUCCESS;
9114 }
9115
9116 DEFUN (show_bgp_updgrps_adj,
9117        show_bgp_updgrps_adj_cmd,
9118        "show [ip] bgp update-groups <advertise-queue|advertised-routes|packet-queue>",
9119        SHOW_STR
9120        IP_STR
9121        BGP_STR
9122        "Detailed info about dynamic update groups\n"
9123        "Advertisement queue\n"
9124        "Announced routes\n"
9125        "Packet queue\n")
9126 {
9127   int idx_type = 3;
9128   show_bgp_updgrps_adj_info_aux(vty, NULL, AFI_IP6, SAFI_UNICAST, argv[idx_type]->arg, 0);
9129   return CMD_SUCCESS;
9130 }
9131
9132 DEFUN (show_bgp_instance_updgrps_adj,
9133        show_bgp_instance_updgrps_adj_cmd,
9134        "show [ip] bgp <view|vrf> WORD update-groups <advertise-queue|advertised-routes|packet-queue>",
9135        SHOW_STR
9136        IP_STR
9137        BGP_STR
9138        BGP_INSTANCE_HELP_STR
9139        "Detailed info about dynamic update groups\n"
9140        "Advertisement queue\n"
9141        "Announced routes\n"
9142        "Packet queue\n")
9143 {
9144   int idx_word = 3;
9145   int idx_type = 5;
9146   show_bgp_updgrps_adj_info_aux(vty, argv[idx_word]->arg, AFI_IP6, SAFI_UNICAST, argv[idx_type]->arg, 0);
9147   return CMD_SUCCESS;
9148 }
9149
9150 DEFUN (show_ip_bgp_updgrps_adj_s,
9151        show_ip_bgp_updgrps_adj_s_cmd,
9152        "show [ip] bgp update-groups SUBGROUP-ID <advertise-queue|advertised-routes|packet-queue>",
9153        SHOW_STR
9154        IP_STR
9155        BGP_STR
9156        "Detailed info about dynamic update groups\n"
9157        "Specific subgroup to display info for\n"
9158        "Advertisement queue\n"
9159        "Announced routes\n"
9160        "Packet queue\n")
9161
9162 {
9163   int idx_subgroup_id = 4;
9164   int idx_type = 5;
9165   uint64_t subgrp_id;
9166
9167   VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx_subgroup_id]->arg);
9168
9169   show_bgp_updgrps_adj_info_aux(vty, NULL, AFI_IP, SAFI_UNICAST, argv[idx_type]->arg, subgrp_id);
9170   return CMD_SUCCESS;
9171 }
9172
9173 DEFUN (show_ip_bgp_instance_updgrps_adj_s,
9174        show_ip_bgp_instance_updgrps_adj_s_cmd,
9175        "show [ip] bgp <view|vrf> WORD update-groups SUBGROUP-ID <advertise-queue|advertised-routes|packet-queue>",
9176        SHOW_STR
9177        IP_STR
9178        BGP_STR
9179        BGP_INSTANCE_HELP_STR
9180        "Detailed info about dynamic update groups\n"
9181        "Specific subgroup to display info for\n"
9182        "Advertisement queue\n"
9183        "Announced routes\n"
9184        "Packet queue\n")
9185
9186 {
9187   int idx_vrf = 4;
9188   int idx_subgroup_id = 6;
9189   int idx_type = 7;
9190   uint64_t subgrp_id;
9191
9192   VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx_subgroup_id]->arg);
9193
9194   show_bgp_updgrps_adj_info_aux(vty, argv[idx_vrf]->arg, AFI_IP, SAFI_UNICAST, argv[idx_type]->arg, subgrp_id);
9195   return CMD_SUCCESS;
9196 }
9197
9198 DEFUN (show_bgp_updgrps_afi_adj_s,
9199        show_bgp_updgrps_afi_adj_s_cmd,
9200        "show [ip] bgp "BGP_AFI_SAFI_CMD_STR" update-groups SUBGROUP-ID <advertise-queue|advertised-routes|packet-queue>",
9201        SHOW_STR
9202        IP_STR
9203        BGP_STR
9204        BGP_AFI_SAFI_HELP_STR
9205        "Detailed info about dynamic update groups\n"
9206        "Specific subgroup to display info for\n"
9207        "Advertisement queue\n"
9208        "Announced routes\n"
9209        "Packet queue\n"
9210        "Specific subgroup info wanted for\n")
9211 {
9212   int idx_afi = 2;
9213   int idx_safi = 3;
9214   int idx_subgroup_id = 5;
9215   int idx_type = 6;
9216   uint64_t subgrp_id;
9217
9218   VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx_subgroup_id]->arg);
9219
9220   show_bgp_updgrps_adj_info_aux(vty, NULL,
9221                                 bgp_vty_afi_from_arg(argv[idx_afi]->arg),
9222                                 bgp_vty_safi_from_arg(argv[idx_safi]->arg),
9223                                 argv[idx_type]->arg, subgrp_id);
9224   return CMD_SUCCESS;
9225 }
9226
9227 DEFUN (show_bgp_updgrps_adj_s,
9228        show_bgp_updgrps_adj_s_cmd,
9229        "show [ip] bgp update-groups SUBGROUP-ID <advertise-queue|advertised-routes|packet-queue>",
9230        SHOW_STR
9231        IP_STR
9232        BGP_STR
9233        "Detailed info about dynamic update groups\n"
9234        "Specific subgroup to display info for\n"
9235        "Advertisement queue\n"
9236        "Announced routes\n"
9237        "Packet queue\n")
9238 {
9239   int idx_subgroup_id = 3;
9240   int idx_type = 4;
9241   uint64_t subgrp_id;
9242
9243   VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx_subgroup_id]->arg);
9244
9245   show_bgp_updgrps_adj_info_aux(vty, NULL, AFI_IP6, SAFI_UNICAST, argv[idx_type]->arg, subgrp_id);
9246   return CMD_SUCCESS;
9247 }
9248
9249 DEFUN (show_bgp_instance_updgrps_adj_s,
9250        show_bgp_instance_updgrps_adj_s_cmd,
9251        "show [ip] bgp <view|vrf> WORD update-groups SUBGROUP-ID <advertise-queue|advertised-routes|packet-queue>",
9252        SHOW_STR
9253        IP_STR
9254        BGP_STR
9255        BGP_INSTANCE_HELP_STR
9256        "Detailed info about dynamic update groups\n"
9257        "Specific subgroup to display info for\n"
9258        "Advertisement queue\n"
9259        "Announced routes\n"
9260        "Packet queue\n")
9261 {
9262   int idx_vrf = 3;
9263   int idx_subgroup_id = 5;
9264   int idx_type = 6;
9265   uint64_t subgrp_id;
9266
9267   VTY_GET_ULL("subgroup-id", subgrp_id, argv[idx_subgroup_id]->arg);
9268
9269   show_bgp_updgrps_adj_info_aux(vty, argv[idx_vrf]->arg, AFI_IP6, SAFI_UNICAST, argv[idx_type]->arg, subgrp_id);
9270   return CMD_SUCCESS;
9271 }
9272
9273
9274
9275 static int
9276 bgp_show_one_peer_group (struct vty *vty, struct peer_group *group)
9277 {
9278   struct listnode *node, *nnode;
9279   struct prefix *range;
9280   struct peer *conf;
9281   struct peer *peer;
9282   char buf[PREFIX2STR_BUFFER];
9283   afi_t afi;
9284   safi_t safi;
9285   const char *peer_status;
9286   const char *af_str;
9287   int lr_count;
9288   int dynamic;
9289   int af_cfgd;
9290
9291   conf = group->conf;
9292
9293   if (conf->as_type == AS_SPECIFIED ||
9294       conf->as_type == AS_EXTERNAL) {
9295   vty_out (vty, "%sBGP peer-group %s, remote AS %d%s",
9296            VTY_NEWLINE, group->name, conf->as, VTY_NEWLINE);
9297   } else if (conf->as_type == AS_INTERNAL) {
9298     vty_out (vty, "%sBGP peer-group %s, remote AS %d%s",
9299              VTY_NEWLINE, group->name, group->bgp->as, VTY_NEWLINE);
9300   } else {
9301     vty_out (vty, "%sBGP peer-group %s%s",
9302              VTY_NEWLINE, group->name, VTY_NEWLINE);
9303   }
9304
9305   if ((group->bgp->as == conf->as) || (conf->as_type == AS_INTERNAL))
9306     vty_out (vty, "  Peer-group type is internal%s", VTY_NEWLINE);
9307   else
9308     vty_out (vty, "  Peer-group type is external%s", VTY_NEWLINE);
9309
9310   /* Display AFs configured. */
9311   vty_out (vty, "  Configured address-families:");
9312   for (afi = AFI_IP; afi < AFI_MAX; afi++)
9313     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
9314       {
9315         if (conf->afc[afi][safi])
9316           {
9317             af_cfgd = 1;
9318             vty_out (vty, " %s;", afi_safi_print(afi, safi));
9319           }
9320       }
9321   if (!af_cfgd)
9322     vty_out (vty, " none%s", VTY_NEWLINE);
9323   else
9324     vty_out (vty, "%s", VTY_NEWLINE);
9325
9326   /* Display listen ranges (for dynamic neighbors), if any */
9327   for (afi = AFI_IP; afi < AFI_MAX; afi++)
9328     {
9329       if (afi == AFI_IP)
9330         af_str = "IPv4";
9331       else if (afi == AFI_IP6)
9332         af_str = "IPv6";
9333       else
9334         af_str = "???";
9335       lr_count = listcount(group->listen_range[afi]);
9336       if (lr_count)
9337         {
9338           vty_out(vty,
9339                   "  %d %s listen range(s)%s",
9340                   lr_count, af_str, VTY_NEWLINE);
9341
9342
9343           for (ALL_LIST_ELEMENTS (group->listen_range[afi], node,
9344                                   nnode, range))
9345             {
9346               prefix2str(range, buf, sizeof(buf));
9347               vty_out(vty, "    %s%s", buf, VTY_NEWLINE);
9348             }
9349         }
9350     }
9351
9352   /* Display group members and their status */
9353   if (listcount(group->peer))
9354     {
9355       vty_out (vty, "  Peer-group members:%s", VTY_NEWLINE);
9356       for (ALL_LIST_ELEMENTS (group->peer, node, nnode, peer))
9357         {
9358           if (CHECK_FLAG (peer->flags, PEER_FLAG_SHUTDOWN))
9359             peer_status = "Idle (Admin)";
9360           else if (CHECK_FLAG (peer->sflags, PEER_STATUS_PREFIX_OVERFLOW))
9361             peer_status = "Idle (PfxCt)";
9362           else
9363             peer_status = LOOKUP(bgp_status_msg, peer->status);
9364
9365           dynamic = peer_dynamic_neighbor(peer);
9366           vty_out (vty, "    %s %s %s %s",
9367                    peer->host, dynamic ? "(dynamic)" : "",
9368                    peer_status, VTY_NEWLINE);
9369         }
9370     }
9371
9372   return CMD_SUCCESS;
9373 }
9374
9375 /* Show BGP peer group's information. */
9376 enum show_group_type
9377 {
9378   show_all_groups,
9379   show_peer_group
9380 };
9381
9382 static int
9383 bgp_show_peer_group (struct vty *vty, struct bgp *bgp,
9384                      enum show_group_type type, const char *group_name)
9385 {
9386   struct listnode *node, *nnode;
9387   struct peer_group *group;
9388   int find = 0;
9389
9390   for (ALL_LIST_ELEMENTS (bgp->group, node, nnode, group))
9391     {
9392       switch (type)
9393         {
9394         case show_all_groups:
9395           bgp_show_one_peer_group (vty, group);
9396           break;
9397         case show_peer_group:
9398           if (group_name && (strcmp(group->name, group_name) == 0))
9399             {
9400               find = 1;
9401               bgp_show_one_peer_group (vty, group);
9402             }
9403           break;
9404         }
9405     }
9406
9407   if (type == show_peer_group && ! find)
9408     vty_out (vty, "%% No such peer-group%s", VTY_NEWLINE);
9409
9410   return CMD_SUCCESS;
9411 }
9412
9413 static int
9414 bgp_show_peer_group_vty (struct vty *vty, const char *name,
9415                          enum show_group_type type, const char *group_name)
9416 {
9417   struct bgp *bgp;
9418   int ret = CMD_SUCCESS;
9419
9420   if (name)
9421     bgp = bgp_lookup_by_name (name);
9422   else
9423     bgp = bgp_get_default ();
9424
9425   if (! bgp)
9426     {
9427       vty_out (vty, "%% No such BGP instance exist%s", VTY_NEWLINE);
9428       return CMD_WARNING;
9429     }
9430
9431   ret = bgp_show_peer_group (vty, bgp, type, group_name);
9432
9433   return ret;
9434 }
9435
9436 DEFUN (show_ip_bgp_peer_groups,
9437        show_ip_bgp_peer_groups_cmd,
9438        "show [ip] bgp [<view|vrf> WORD] peer-group [PGNAME]",
9439        SHOW_STR
9440        IP_STR
9441        BGP_STR
9442        BGP_INSTANCE_HELP_STR
9443        "Detailed information on BGP peer groups\n"
9444        "Peer group name\n")
9445 {
9446   char *vrf, *pg;
9447   vrf = pg = NULL;
9448   int idx = 0;
9449
9450   vrf = argv_find (argv, argc, "WORD", &idx) ? argv[idx]->arg : NULL;
9451   pg = argv_find (argv, argc, "PGNAME", &idx) ? argv[idx]->arg : NULL;
9452
9453   return bgp_show_peer_group_vty (vty, vrf, show_all_groups, pg);
9454 }
9455
9456
9457 /* Redistribute VTY commands.  */
9458
9459 DEFUN (bgp_redistribute_ipv4,
9460        bgp_redistribute_ipv4_cmd,
9461        "redistribute " FRR_IP_REDIST_STR_BGPD,
9462        "Redistribute information from another routing protocol\n"
9463        FRR_IP_REDIST_HELP_STR_BGPD)
9464 {
9465   VTY_DECLVAR_CONTEXT(bgp, bgp);
9466   int idx_protocol = 1;
9467   int type;
9468
9469   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9470   if (type < 0)
9471     {
9472       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9473       return CMD_WARNING;
9474     }
9475   bgp_redist_add(bgp, AFI_IP, type, 0);
9476   return bgp_redistribute_set (bgp, AFI_IP, type, 0);
9477 }
9478
9479 DEFUN (bgp_redistribute_ipv4_rmap,
9480        bgp_redistribute_ipv4_rmap_cmd,
9481        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD",
9482        "Redistribute information from another routing protocol\n"
9483        FRR_IP_REDIST_HELP_STR_BGPD
9484        "Route map reference\n"
9485        "Pointer to route-map entries\n")
9486 {
9487   VTY_DECLVAR_CONTEXT(bgp, bgp);
9488   int idx_protocol = 1;
9489   int idx_word = 3;
9490   int type;
9491   struct bgp_redist *red;
9492
9493   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9494   if (type < 0)
9495     {
9496       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9497       return CMD_WARNING;
9498     }
9499
9500   red = bgp_redist_add(bgp, AFI_IP, type, 0);
9501   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9502   return bgp_redistribute_set (bgp, AFI_IP, type, 0);
9503 }
9504
9505 DEFUN (bgp_redistribute_ipv4_metric,
9506        bgp_redistribute_ipv4_metric_cmd,
9507        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295)",
9508        "Redistribute information from another routing protocol\n"
9509        FRR_IP_REDIST_HELP_STR_BGPD
9510        "Metric for redistributed routes\n"
9511        "Default metric\n")
9512 {
9513   VTY_DECLVAR_CONTEXT(bgp, bgp);
9514   int idx_protocol = 1;
9515   int idx_number = 3;
9516   int type;
9517   u_int32_t metric;
9518   struct bgp_redist *red;
9519
9520   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9521   if (type < 0)
9522     {
9523       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9524       return CMD_WARNING;
9525     }
9526   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9527
9528   red = bgp_redist_add(bgp, AFI_IP, type, 0);
9529   bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
9530   return bgp_redistribute_set (bgp, AFI_IP, type, 0);
9531 }
9532
9533 DEFUN (bgp_redistribute_ipv4_rmap_metric,
9534        bgp_redistribute_ipv4_rmap_metric_cmd,
9535        "redistribute " FRR_IP_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
9536        "Redistribute information from another routing protocol\n"
9537        FRR_IP_REDIST_HELP_STR_BGPD
9538        "Route map reference\n"
9539        "Pointer to route-map entries\n"
9540        "Metric for redistributed routes\n"
9541        "Default metric\n")
9542 {
9543   VTY_DECLVAR_CONTEXT(bgp, bgp);
9544   int idx_protocol = 1;
9545   int idx_word = 3;
9546   int idx_number = 5;
9547   int type;
9548   u_int32_t metric;
9549   struct bgp_redist *red;
9550
9551   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9552   if (type < 0)
9553     {
9554       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9555       return CMD_WARNING;
9556     }
9557   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9558
9559   red = bgp_redist_add(bgp, AFI_IP, type, 0);
9560   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9561   bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
9562   return bgp_redistribute_set (bgp, AFI_IP, type, 0);
9563 }
9564
9565 DEFUN (bgp_redistribute_ipv4_metric_rmap,
9566        bgp_redistribute_ipv4_metric_rmap_cmd,
9567        "redistribute " FRR_IP_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
9568        "Redistribute information from another routing protocol\n"
9569        FRR_IP_REDIST_HELP_STR_BGPD
9570        "Metric for redistributed routes\n"
9571        "Default metric\n"
9572        "Route map reference\n"
9573        "Pointer to route-map entries\n")
9574 {
9575   VTY_DECLVAR_CONTEXT(bgp, bgp);
9576   int idx_protocol = 1;
9577   int idx_number = 3;
9578   int idx_word = 5;
9579   int type;
9580   u_int32_t metric;
9581   struct bgp_redist *red;
9582
9583   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9584   if (type < 0)
9585     {
9586       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9587       return CMD_WARNING;
9588     }
9589   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9590
9591   red = bgp_redist_add(bgp, AFI_IP, type, 0);
9592   bgp_redistribute_metric_set(bgp, red, AFI_IP, type, metric);
9593   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9594   return bgp_redistribute_set (bgp, AFI_IP, type, 0);
9595 }
9596
9597 DEFUN (bgp_redistribute_ipv4_ospf,
9598        bgp_redistribute_ipv4_ospf_cmd,
9599        "redistribute <ospf|table> (1-65535)",
9600        "Redistribute information from another routing protocol\n"
9601        "Open Shortest Path First (OSPFv2)\n"
9602        "Non-main Kernel Routing Table\n"
9603        "Instance ID/Table ID\n")
9604 {
9605   VTY_DECLVAR_CONTEXT(bgp, bgp);
9606   int idx_ospf_table = 1;
9607   int idx_number = 2;
9608   u_short instance;
9609   u_short protocol;
9610
9611   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9612
9613   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9614     protocol = ZEBRA_ROUTE_OSPF;
9615   else
9616     protocol = ZEBRA_ROUTE_TABLE;
9617
9618   bgp_redist_add(bgp, AFI_IP, protocol, instance);
9619   return bgp_redistribute_set (bgp, AFI_IP, protocol, instance);
9620 }
9621
9622 DEFUN (bgp_redistribute_ipv4_ospf_rmap,
9623        bgp_redistribute_ipv4_ospf_rmap_cmd,
9624        "redistribute <ospf|table> (1-65535) route-map WORD",
9625        "Redistribute information from another routing protocol\n"
9626        "Open Shortest Path First (OSPFv2)\n"
9627        "Non-main Kernel Routing Table\n"
9628        "Instance ID/Table ID\n"
9629        "Route map reference\n"
9630        "Pointer to route-map entries\n")
9631 {
9632   VTY_DECLVAR_CONTEXT(bgp, bgp);
9633   int idx_ospf_table = 1;
9634   int idx_number = 2;
9635   int idx_word = 4;
9636   struct bgp_redist *red;
9637   u_short instance;
9638   int protocol;
9639
9640   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9641     protocol = ZEBRA_ROUTE_OSPF;
9642   else
9643     protocol = ZEBRA_ROUTE_TABLE;
9644
9645   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9646   red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
9647   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9648   return bgp_redistribute_set (bgp, AFI_IP, protocol, instance);
9649 }
9650
9651 DEFUN (bgp_redistribute_ipv4_ospf_metric,
9652        bgp_redistribute_ipv4_ospf_metric_cmd,
9653        "redistribute <ospf|table> (1-65535) metric (0-4294967295)",
9654        "Redistribute information from another routing protocol\n"
9655        "Open Shortest Path First (OSPFv2)\n"
9656        "Non-main Kernel Routing Table\n"
9657        "Instance ID/Table ID\n"
9658        "Metric for redistributed routes\n"
9659        "Default metric\n")
9660 {
9661   VTY_DECLVAR_CONTEXT(bgp, bgp);
9662   int idx_ospf_table = 1;
9663   int idx_number = 2;
9664   int idx_number_2 = 4;
9665   u_int32_t metric;
9666   struct bgp_redist *red;
9667   u_short instance;
9668   int protocol;
9669
9670   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9671     protocol = ZEBRA_ROUTE_OSPF;
9672   else
9673     protocol = ZEBRA_ROUTE_TABLE;
9674
9675   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9676   VTY_GET_INTEGER ("metric", metric, argv[idx_number_2]->arg);
9677
9678   red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
9679   bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol, metric);
9680   return bgp_redistribute_set (bgp, AFI_IP, protocol, instance);
9681 }
9682
9683 DEFUN (bgp_redistribute_ipv4_ospf_rmap_metric,
9684        bgp_redistribute_ipv4_ospf_rmap_metric_cmd,
9685        "redistribute <ospf|table> (1-65535) route-map WORD metric (0-4294967295)",
9686        "Redistribute information from another routing protocol\n"
9687        "Open Shortest Path First (OSPFv2)\n"
9688        "Non-main Kernel Routing Table\n"
9689        "Instance ID/Table ID\n"
9690        "Route map reference\n"
9691        "Pointer to route-map entries\n"
9692        "Metric for redistributed routes\n"
9693        "Default metric\n")
9694 {
9695   VTY_DECLVAR_CONTEXT(bgp, bgp);
9696   int idx_ospf_table = 1;
9697   int idx_number = 2;
9698   int idx_word = 4;
9699   int idx_number_2 = 6;
9700   u_int32_t metric;
9701   struct bgp_redist *red;
9702   u_short instance;
9703   int protocol;
9704
9705   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9706     protocol = ZEBRA_ROUTE_OSPF;
9707   else
9708     protocol = ZEBRA_ROUTE_TABLE;
9709
9710   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9711   VTY_GET_INTEGER ("metric", metric, argv[idx_number_2]->arg);
9712
9713   red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
9714   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9715   bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol, metric);
9716   return bgp_redistribute_set (bgp, AFI_IP, protocol, instance);
9717 }
9718
9719 DEFUN (bgp_redistribute_ipv4_ospf_metric_rmap,
9720        bgp_redistribute_ipv4_ospf_metric_rmap_cmd,
9721        "redistribute <ospf|table> (1-65535) metric (0-4294967295) route-map WORD",
9722        "Redistribute information from another routing protocol\n"
9723        "Open Shortest Path First (OSPFv2)\n"
9724        "Non-main Kernel Routing Table\n"
9725        "Instance ID/Table ID\n"
9726        "Metric for redistributed routes\n"
9727        "Default metric\n"
9728        "Route map reference\n"
9729        "Pointer to route-map entries\n")
9730 {
9731   VTY_DECLVAR_CONTEXT(bgp, bgp);
9732   int idx_ospf_table = 1;
9733   int idx_number = 2;
9734   int idx_number_2 = 4;
9735   int idx_word = 6;
9736   u_int32_t metric;
9737   struct bgp_redist *red;
9738   u_short instance;
9739   int protocol;
9740
9741   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9742     protocol = ZEBRA_ROUTE_OSPF;
9743   else
9744     protocol = ZEBRA_ROUTE_TABLE;
9745
9746   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9747   VTY_GET_INTEGER ("metric", metric, argv[idx_number_2]->arg);
9748
9749   red = bgp_redist_add(bgp, AFI_IP, protocol, instance);
9750   bgp_redistribute_metric_set(bgp, red, AFI_IP, protocol, metric);
9751   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9752   return bgp_redistribute_set (bgp, AFI_IP, protocol, instance);
9753 }
9754
9755 DEFUN (no_bgp_redistribute_ipv4_ospf,
9756        no_bgp_redistribute_ipv4_ospf_cmd,
9757        "no redistribute <ospf|table> (1-65535) [metric (0-4294967295)] [route-map WORD]",
9758        NO_STR
9759        "Redistribute information from another routing protocol\n"
9760        "Open Shortest Path First (OSPFv2)\n"
9761        "Non-main Kernel Routing Table\n"
9762        "Instance ID/Table ID\n"
9763        "Metric for redistributed routes\n"
9764        "Default metric\n"
9765        "Route map reference\n"
9766        "Pointer to route-map entries\n")
9767 {
9768   VTY_DECLVAR_CONTEXT(bgp, bgp);
9769   int idx_ospf_table = 2;
9770   int idx_number = 3;
9771   u_short instance;
9772   int protocol;
9773
9774   if (strncmp(argv[idx_ospf_table]->arg, "o", 1) == 0)
9775     protocol = ZEBRA_ROUTE_OSPF;
9776   else
9777     protocol = ZEBRA_ROUTE_TABLE;
9778
9779   VTY_GET_INTEGER ("Instance ID", instance, argv[idx_number]->arg);
9780   return bgp_redistribute_unset (bgp, AFI_IP, protocol, instance);
9781 }
9782
9783 DEFUN (no_bgp_redistribute_ipv4,
9784        no_bgp_redistribute_ipv4_cmd,
9785        "no redistribute " FRR_IP_REDIST_STR_BGPD " [metric (0-4294967295)] [route-map WORD]",
9786        NO_STR
9787        "Redistribute information from another routing protocol\n"
9788        FRR_IP_REDIST_HELP_STR_BGPD
9789        "Metric for redistributed routes\n"
9790        "Default metric\n"
9791        "Route map reference\n"
9792        "Pointer to route-map entries\n")
9793 {
9794   VTY_DECLVAR_CONTEXT(bgp, bgp);
9795   int idx_protocol = 2;
9796   int type;
9797
9798   type = proto_redistnum (AFI_IP, argv[idx_protocol]->text);
9799   if (type < 0)
9800     {
9801       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9802       return CMD_WARNING;
9803     }
9804   return bgp_redistribute_unset (bgp, AFI_IP, type, 0);
9805 }
9806
9807 DEFUN (bgp_redistribute_ipv6,
9808        bgp_redistribute_ipv6_cmd,
9809        "redistribute " FRR_IP6_REDIST_STR_BGPD,
9810        "Redistribute information from another routing protocol\n"
9811        FRR_IP6_REDIST_HELP_STR_BGPD)
9812 {
9813   VTY_DECLVAR_CONTEXT(bgp, bgp);
9814   int idx_protocol = 1;
9815   int type;
9816
9817   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9818   if (type < 0)
9819     {
9820       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9821       return CMD_WARNING;
9822     }
9823
9824   bgp_redist_add(bgp, AFI_IP6, type, 0);
9825   return bgp_redistribute_set (bgp, AFI_IP6, type, 0);
9826 }
9827
9828 DEFUN (bgp_redistribute_ipv6_rmap,
9829        bgp_redistribute_ipv6_rmap_cmd,
9830        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD",
9831        "Redistribute information from another routing protocol\n"
9832        FRR_IP6_REDIST_HELP_STR_BGPD
9833        "Route map reference\n"
9834        "Pointer to route-map entries\n")
9835 {
9836   VTY_DECLVAR_CONTEXT(bgp, bgp);
9837   int idx_protocol = 1;
9838   int idx_word = 3;
9839   int type;
9840   struct bgp_redist *red;
9841
9842   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9843   if (type < 0)
9844     {
9845       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9846       return CMD_WARNING;
9847     }
9848
9849   red = bgp_redist_add(bgp, AFI_IP6, type, 0);
9850   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9851   return bgp_redistribute_set (bgp, AFI_IP6, type, 0);
9852 }
9853
9854 DEFUN (bgp_redistribute_ipv6_metric,
9855        bgp_redistribute_ipv6_metric_cmd,
9856        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295)",
9857        "Redistribute information from another routing protocol\n"
9858        FRR_IP6_REDIST_HELP_STR_BGPD
9859        "Metric for redistributed routes\n"
9860        "Default metric\n")
9861 {
9862   VTY_DECLVAR_CONTEXT(bgp, bgp);
9863   int idx_protocol = 1;
9864   int idx_number = 3;
9865   int type;
9866   u_int32_t metric;
9867   struct bgp_redist *red;
9868
9869   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9870   if (type < 0)
9871     {
9872       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9873       return CMD_WARNING;
9874     }
9875   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9876
9877   red = bgp_redist_add(bgp, AFI_IP6, type, 0);
9878   bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
9879   return bgp_redistribute_set (bgp, AFI_IP6, type, 0);
9880 }
9881
9882 DEFUN (bgp_redistribute_ipv6_rmap_metric,
9883        bgp_redistribute_ipv6_rmap_metric_cmd,
9884        "redistribute " FRR_IP6_REDIST_STR_BGPD " route-map WORD metric (0-4294967295)",
9885        "Redistribute information from another routing protocol\n"
9886        FRR_IP6_REDIST_HELP_STR_BGPD
9887        "Route map reference\n"
9888        "Pointer to route-map entries\n"
9889        "Metric for redistributed routes\n"
9890        "Default metric\n")
9891 {
9892   VTY_DECLVAR_CONTEXT(bgp, bgp);
9893   int idx_protocol = 1;
9894   int idx_word = 3;
9895   int idx_number = 5;
9896   int type;
9897   u_int32_t metric;
9898   struct bgp_redist *red;
9899
9900   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9901   if (type < 0)
9902     {
9903       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9904       return CMD_WARNING;
9905     }
9906   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9907
9908   red = bgp_redist_add(bgp, AFI_IP6, type, 0);
9909   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9910   bgp_redistribute_metric_set(bgp, red, AFI_IP6, type, metric);
9911   return bgp_redistribute_set (bgp, AFI_IP6, type, 0);
9912 }
9913
9914 DEFUN (bgp_redistribute_ipv6_metric_rmap,
9915        bgp_redistribute_ipv6_metric_rmap_cmd,
9916        "redistribute " FRR_IP6_REDIST_STR_BGPD " metric (0-4294967295) route-map WORD",
9917        "Redistribute information from another routing protocol\n"
9918        FRR_IP6_REDIST_HELP_STR_BGPD
9919        "Metric for redistributed routes\n"
9920        "Default metric\n"
9921        "Route map reference\n"
9922        "Pointer to route-map entries\n")
9923 {
9924   VTY_DECLVAR_CONTEXT(bgp, bgp);
9925   int idx_protocol = 1;
9926   int idx_number = 3;
9927   int idx_word = 5;
9928   int type;
9929   u_int32_t metric;
9930   struct bgp_redist *red;
9931
9932   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9933   if (type < 0)
9934     {
9935       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9936       return CMD_WARNING;
9937     }
9938   VTY_GET_INTEGER ("metric", metric, argv[idx_number]->arg);
9939
9940   red = bgp_redist_add(bgp, AFI_IP6, type, 0);
9941   bgp_redistribute_metric_set(bgp, red, AFI_IP6, SAFI_UNICAST, metric);
9942   bgp_redistribute_rmap_set (red, argv[idx_word]->arg);
9943   return bgp_redistribute_set (bgp, AFI_IP6, type, 0);
9944 }
9945
9946 DEFUN (no_bgp_redistribute_ipv6,
9947        no_bgp_redistribute_ipv6_cmd,
9948        "no redistribute " FRR_IP6_REDIST_STR_BGPD " [metric (0-4294967295)] [route-map WORD]",
9949        NO_STR
9950        "Redistribute information from another routing protocol\n"
9951        FRR_IP6_REDIST_HELP_STR_BGPD
9952        "Metric for redistributed routes\n"
9953        "Default metric\n"
9954        "Route map reference\n"
9955        "Pointer to route-map entries\n")
9956 {
9957   VTY_DECLVAR_CONTEXT(bgp, bgp);
9958   int idx_protocol = 2;
9959   int type;
9960
9961   type = proto_redistnum (AFI_IP6, argv[idx_protocol]->text);
9962   if (type < 0)
9963     {
9964       vty_out (vty, "%% Invalid route type%s", VTY_NEWLINE);
9965       return CMD_WARNING;
9966     }
9967
9968   return bgp_redistribute_unset (bgp, AFI_IP6, type, 0);
9969 }
9970
9971 int
9972 bgp_config_write_redistribute (struct vty *vty, struct bgp *bgp, afi_t afi,
9973                                safi_t safi, int *write)
9974 {
9975   int i;
9976
9977   /* Unicast redistribution only.  */
9978   if (safi != SAFI_UNICAST)
9979     return 0;
9980
9981   for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
9982     {
9983       /* Redistribute BGP does not make sense.  */
9984       if (i != ZEBRA_ROUTE_BGP)
9985         {
9986           struct list *red_list;
9987           struct listnode *node;
9988           struct bgp_redist *red;
9989
9990           red_list = bgp->redist[afi][i];
9991           if (!red_list)
9992             continue;
9993
9994           for (ALL_LIST_ELEMENTS_RO(red_list, node, red))
9995             {
9996               /* Display "address-family" when it is not yet diplayed.  */
9997               bgp_config_write_family_header (vty, afi, safi, write);
9998
9999               /* "redistribute" configuration.  */
10000               vty_out (vty, "  redistribute %s", zebra_route_string(i));
10001               if (red->instance)
10002                 vty_out (vty, " %d", red->instance);
10003               if (red->redist_metric_flag)
10004                 vty_out (vty, " metric %u", red->redist_metric);
10005               if (red->rmap.name)
10006                 vty_out (vty, " route-map %s", red->rmap.name);
10007               vty_out (vty, "%s", VTY_NEWLINE);
10008             }
10009         }
10010     }
10011   return *write;
10012 }
10013
10014 /* BGP node structure. */
10015 static struct cmd_node bgp_node =
10016 {
10017   BGP_NODE,
10018   "%s(config-router)# ",
10019   1,
10020 };
10021
10022 static struct cmd_node bgp_ipv4_unicast_node =
10023 {
10024   BGP_IPV4_NODE,
10025   "%s(config-router-af)# ",
10026   1,
10027 };
10028
10029 static struct cmd_node bgp_ipv4_multicast_node =
10030 {
10031   BGP_IPV4M_NODE,
10032   "%s(config-router-af)# ",
10033   1,
10034 };
10035
10036 static struct cmd_node bgp_ipv6_unicast_node =
10037 {
10038   BGP_IPV6_NODE,
10039   "%s(config-router-af)# ",
10040   1,
10041 };
10042
10043 static struct cmd_node bgp_ipv6_multicast_node =
10044 {
10045   BGP_IPV6M_NODE,
10046   "%s(config-router-af)# ",
10047   1,
10048 };
10049
10050 static struct cmd_node bgp_vpnv4_node =
10051 {
10052   BGP_VPNV4_NODE,
10053   "%s(config-router-af)# ",
10054   1
10055 };
10056
10057 static struct cmd_node bgp_vpnv6_node =
10058 {
10059   BGP_VPNV6_NODE,
10060   "%s(config-router-af-vpnv6)# ",
10061   1
10062 };
10063
10064 static struct cmd_node bgp_encap_node =
10065 {
10066   BGP_ENCAP_NODE,
10067   "%s(config-router-af-encap)# ",
10068   1
10069 };
10070
10071 static struct cmd_node bgp_encapv6_node =
10072 {
10073   BGP_ENCAPV6_NODE,
10074   "%s(config-router-af-encapv6)# ",
10075   1
10076 };
10077
10078 static struct cmd_node bgp_evpn_node =
10079 {
10080   BGP_EVPN_NODE,
10081   "%s(config-router-evpn)# ",
10082   1
10083 };
10084
10085 static void community_list_vty (void);
10086
10087 void
10088 bgp_vty_init (void)
10089 {
10090   /* Install bgp top node. */
10091   install_node (&bgp_node, bgp_config_write);
10092   install_node (&bgp_ipv4_unicast_node, NULL);
10093   install_node (&bgp_ipv4_multicast_node, NULL);
10094   install_node (&bgp_ipv6_unicast_node, NULL);
10095   install_node (&bgp_ipv6_multicast_node, NULL);
10096   install_node (&bgp_vpnv4_node, NULL);
10097   install_node (&bgp_vpnv6_node, NULL);
10098   install_node (&bgp_encap_node, NULL);
10099   install_node (&bgp_encapv6_node, NULL);
10100   install_node (&bgp_evpn_node, NULL);
10101
10102   /* Install default VTY commands to new nodes.  */
10103   install_default (BGP_NODE);
10104   install_default (BGP_IPV4_NODE);
10105   install_default (BGP_IPV4M_NODE);
10106   install_default (BGP_IPV6_NODE);
10107   install_default (BGP_IPV6M_NODE);
10108   install_default (BGP_VPNV4_NODE);
10109   install_default (BGP_VPNV6_NODE);
10110   install_default (BGP_ENCAP_NODE);
10111   install_default (BGP_ENCAPV6_NODE);
10112   install_default (BGP_EVPN_NODE);
10113
10114   /* "bgp multiple-instance" commands. */
10115   install_element (CONFIG_NODE, &bgp_multiple_instance_cmd);
10116   install_element (CONFIG_NODE, &no_bgp_multiple_instance_cmd);
10117
10118   /* "bgp config-type" commands. */
10119   install_element (CONFIG_NODE, &bgp_config_type_cmd);
10120   install_element (CONFIG_NODE, &no_bgp_config_type_cmd);
10121
10122   /* bgp route-map delay-timer commands. */
10123   install_element (CONFIG_NODE, &bgp_set_route_map_delay_timer_cmd);
10124   install_element (CONFIG_NODE, &no_bgp_set_route_map_delay_timer_cmd);
10125
10126   /* Dummy commands (Currently not supported) */
10127   install_element (BGP_NODE, &no_synchronization_cmd);
10128   install_element (BGP_NODE, &no_auto_summary_cmd);
10129
10130   /* "router bgp" commands. */
10131   install_element (CONFIG_NODE, &router_bgp_cmd);
10132
10133   /* "no router bgp" commands. */
10134   install_element (CONFIG_NODE, &no_router_bgp_cmd);
10135
10136   /* "bgp router-id" commands. */
10137   install_element (BGP_NODE, &bgp_router_id_cmd);
10138   install_element (BGP_NODE, &no_bgp_router_id_cmd);
10139
10140   /* "bgp cluster-id" commands. */
10141   install_element (BGP_NODE, &bgp_cluster_id_cmd);
10142   install_element (BGP_NODE, &no_bgp_cluster_id_cmd);
10143
10144   /* "bgp confederation" commands. */
10145   install_element (BGP_NODE, &bgp_confederation_identifier_cmd);
10146   install_element (BGP_NODE, &no_bgp_confederation_identifier_cmd);
10147
10148   /* "bgp confederation peers" commands. */
10149   install_element (BGP_NODE, &bgp_confederation_peers_cmd);
10150   install_element (BGP_NODE, &no_bgp_confederation_peers_cmd);
10151
10152   /* bgp max-med command */
10153   install_element (BGP_NODE, &bgp_maxmed_admin_cmd);
10154   install_element (BGP_NODE, &no_bgp_maxmed_admin_cmd);
10155   install_element (BGP_NODE, &bgp_maxmed_admin_medv_cmd);
10156   install_element (BGP_NODE, &bgp_maxmed_onstartup_cmd);
10157   install_element (BGP_NODE, &no_bgp_maxmed_onstartup_cmd);
10158   install_element (BGP_NODE, &bgp_maxmed_onstartup_medv_cmd);
10159
10160   /* bgp disable-ebgp-connected-nh-check */
10161   install_element (BGP_NODE, &bgp_disable_connected_route_check_cmd);
10162   install_element (BGP_NODE, &no_bgp_disable_connected_route_check_cmd);
10163
10164   /* bgp update-delay command */
10165   install_element (BGP_NODE, &bgp_update_delay_cmd);
10166   install_element (BGP_NODE, &no_bgp_update_delay_cmd);
10167   install_element (BGP_NODE, &bgp_update_delay_establish_wait_cmd);
10168
10169   install_element (BGP_NODE, &bgp_wpkt_quanta_cmd);
10170   install_element (BGP_NODE, &no_bgp_wpkt_quanta_cmd);
10171
10172   install_element (BGP_NODE, &bgp_coalesce_time_cmd);
10173   install_element (BGP_NODE, &no_bgp_coalesce_time_cmd);
10174
10175   /* "maximum-paths" commands. */
10176   install_element (BGP_NODE, &bgp_maxpaths_cmd);
10177   install_element (BGP_NODE, &no_bgp_maxpaths_cmd);
10178   install_element (BGP_IPV4_NODE, &bgp_maxpaths_cmd);
10179   install_element (BGP_IPV4_NODE, &no_bgp_maxpaths_cmd);
10180   install_element (BGP_IPV6_NODE, &bgp_maxpaths_cmd);
10181   install_element (BGP_IPV6_NODE, &no_bgp_maxpaths_cmd);
10182   install_element (BGP_NODE, &bgp_maxpaths_ibgp_cmd);
10183   install_element(BGP_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
10184   install_element (BGP_NODE, &no_bgp_maxpaths_ibgp_cmd);
10185   install_element (BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cmd);
10186   install_element(BGP_IPV4_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
10187   install_element (BGP_IPV4_NODE, &no_bgp_maxpaths_ibgp_cmd);
10188   install_element (BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cmd);
10189   install_element(BGP_IPV6_NODE, &bgp_maxpaths_ibgp_cluster_cmd);
10190   install_element (BGP_IPV6_NODE, &no_bgp_maxpaths_ibgp_cmd);
10191
10192   /* "timers bgp" commands. */
10193   install_element (BGP_NODE, &bgp_timers_cmd);
10194   install_element (BGP_NODE, &no_bgp_timers_cmd);
10195
10196   /* route-map delay-timer commands - per instance for backwards compat. */
10197   install_element (BGP_NODE, &bgp_set_route_map_delay_timer_cmd);
10198   install_element (BGP_NODE, &no_bgp_set_route_map_delay_timer_cmd);
10199
10200   /* "bgp client-to-client reflection" commands */
10201   install_element (BGP_NODE, &no_bgp_client_to_client_reflection_cmd);
10202   install_element (BGP_NODE, &bgp_client_to_client_reflection_cmd);
10203
10204   /* "bgp always-compare-med" commands */
10205   install_element (BGP_NODE, &bgp_always_compare_med_cmd);
10206   install_element (BGP_NODE, &no_bgp_always_compare_med_cmd);
10207
10208   /* "bgp deterministic-med" commands */
10209   install_element (BGP_NODE, &bgp_deterministic_med_cmd);
10210   install_element (BGP_NODE, &no_bgp_deterministic_med_cmd);
10211
10212   /* "bgp graceful-restart" commands */
10213   install_element (BGP_NODE, &bgp_graceful_restart_cmd);
10214   install_element (BGP_NODE, &no_bgp_graceful_restart_cmd);
10215   install_element (BGP_NODE, &bgp_graceful_restart_stalepath_time_cmd);
10216   install_element (BGP_NODE, &no_bgp_graceful_restart_stalepath_time_cmd);
10217   install_element (BGP_NODE, &bgp_graceful_restart_restart_time_cmd);
10218   install_element (BGP_NODE, &no_bgp_graceful_restart_restart_time_cmd);
10219
10220   install_element (BGP_NODE, &bgp_graceful_restart_preserve_fw_cmd);
10221   install_element (BGP_NODE, &no_bgp_graceful_restart_preserve_fw_cmd);
10222
10223   /* "bgp fast-external-failover" commands */
10224   install_element (BGP_NODE, &bgp_fast_external_failover_cmd);
10225   install_element (BGP_NODE, &no_bgp_fast_external_failover_cmd);
10226
10227   /* "bgp enforce-first-as" commands */
10228   install_element (BGP_NODE, &bgp_enforce_first_as_cmd);
10229   install_element (BGP_NODE, &no_bgp_enforce_first_as_cmd);
10230
10231   /* "bgp bestpath compare-routerid" commands */
10232   install_element (BGP_NODE, &bgp_bestpath_compare_router_id_cmd);
10233   install_element (BGP_NODE, &no_bgp_bestpath_compare_router_id_cmd);
10234
10235   /* "bgp bestpath as-path ignore" commands */
10236   install_element (BGP_NODE, &bgp_bestpath_aspath_ignore_cmd);
10237   install_element (BGP_NODE, &no_bgp_bestpath_aspath_ignore_cmd);
10238
10239   /* "bgp bestpath as-path confed" commands */
10240   install_element (BGP_NODE, &bgp_bestpath_aspath_confed_cmd);
10241   install_element (BGP_NODE, &no_bgp_bestpath_aspath_confed_cmd);
10242
10243   /* "bgp bestpath as-path multipath-relax" commands */
10244   install_element (BGP_NODE, &bgp_bestpath_aspath_multipath_relax_cmd);
10245   install_element (BGP_NODE, &no_bgp_bestpath_aspath_multipath_relax_cmd);
10246
10247   /* "bgp log-neighbor-changes" commands */
10248   install_element (BGP_NODE, &bgp_log_neighbor_changes_cmd);
10249   install_element (BGP_NODE, &no_bgp_log_neighbor_changes_cmd);
10250
10251   /* "bgp bestpath med" commands */
10252   install_element (BGP_NODE, &bgp_bestpath_med_cmd);
10253   install_element (BGP_NODE, &no_bgp_bestpath_med_cmd);
10254
10255   /* "no bgp default ipv4-unicast" commands. */
10256   install_element (BGP_NODE, &no_bgp_default_ipv4_unicast_cmd);
10257   install_element (BGP_NODE, &bgp_default_ipv4_unicast_cmd);
10258
10259   /* "bgp network import-check" commands. */
10260   install_element (BGP_NODE, &bgp_network_import_check_cmd);
10261   install_element (BGP_NODE, &bgp_network_import_check_exact_cmd);
10262   install_element (BGP_NODE, &no_bgp_network_import_check_cmd);
10263
10264   /* "bgp default local-preference" commands. */
10265   install_element (BGP_NODE, &bgp_default_local_preference_cmd);
10266   install_element (BGP_NODE, &no_bgp_default_local_preference_cmd);
10267
10268   /* bgp default show-hostname */
10269   install_element (BGP_NODE, &bgp_default_show_hostname_cmd);
10270   install_element (BGP_NODE, &no_bgp_default_show_hostname_cmd);
10271
10272   /* "bgp default subgroup-pkt-queue-max" commands. */
10273   install_element (BGP_NODE, &bgp_default_subgroup_pkt_queue_max_cmd);
10274   install_element (BGP_NODE, &no_bgp_default_subgroup_pkt_queue_max_cmd);
10275
10276   /* bgp ibgp-allow-policy-mods command */
10277   install_element (BGP_NODE, &bgp_rr_allow_outbound_policy_cmd);
10278   install_element (BGP_NODE, &no_bgp_rr_allow_outbound_policy_cmd);
10279
10280   /* "bgp listen limit" commands. */
10281   install_element (BGP_NODE, &bgp_listen_limit_cmd);
10282   install_element (BGP_NODE, &no_bgp_listen_limit_cmd);
10283
10284   /* "bgp listen range" commands. */
10285   install_element (BGP_NODE, &bgp_listen_range_cmd);
10286   install_element (BGP_NODE, &no_bgp_listen_range_cmd);
10287
10288   /* "neighbor remote-as" commands. */
10289   install_element (BGP_NODE, &neighbor_remote_as_cmd);
10290   install_element (BGP_NODE, &neighbor_interface_config_cmd);
10291   install_element (BGP_NODE, &neighbor_interface_config_v6only_cmd);
10292   install_element (BGP_NODE, &neighbor_interface_config_remote_as_cmd);
10293   install_element (BGP_NODE, &neighbor_interface_v6only_config_remote_as_cmd);
10294   install_element (BGP_NODE, &no_neighbor_cmd);
10295   install_element (BGP_NODE, &no_neighbor_interface_config_cmd);
10296
10297   /* "neighbor peer-group" commands. */
10298   install_element (BGP_NODE, &neighbor_peer_group_cmd);
10299   install_element (BGP_NODE, &no_neighbor_peer_group_cmd);
10300   install_element (BGP_NODE, &no_neighbor_interface_peer_group_remote_as_cmd);
10301
10302   /* "neighbor local-as" commands. */
10303   install_element (BGP_NODE, &neighbor_local_as_cmd);
10304   install_element (BGP_NODE, &neighbor_local_as_no_prepend_cmd);
10305   install_element (BGP_NODE, &neighbor_local_as_no_prepend_replace_as_cmd);
10306   install_element (BGP_NODE, &no_neighbor_local_as_cmd);
10307
10308   /* "neighbor solo" commands. */
10309   install_element (BGP_NODE, &neighbor_solo_cmd);
10310   install_element (BGP_NODE, &no_neighbor_solo_cmd);
10311
10312   /* "neighbor password" commands. */
10313   install_element (BGP_NODE, &neighbor_password_cmd);
10314   install_element (BGP_NODE, &no_neighbor_password_cmd);
10315
10316   /* "neighbor activate" commands. */
10317   install_element (BGP_NODE, &neighbor_activate_cmd);
10318   install_element (BGP_IPV4_NODE, &neighbor_activate_cmd);
10319   install_element (BGP_IPV4M_NODE, &neighbor_activate_cmd);
10320   install_element (BGP_IPV6_NODE, &neighbor_activate_cmd);
10321   install_element (BGP_IPV6M_NODE, &neighbor_activate_cmd);
10322   install_element (BGP_VPNV4_NODE, &neighbor_activate_cmd);
10323   install_element (BGP_VPNV6_NODE, &neighbor_activate_cmd);
10324   install_element (BGP_ENCAP_NODE, &neighbor_activate_cmd);
10325   install_element (BGP_ENCAPV6_NODE, &neighbor_activate_cmd);
10326   install_element (BGP_EVPN_NODE, &neighbor_activate_cmd);
10327
10328   /* "no neighbor activate" commands. */
10329   install_element (BGP_NODE, &no_neighbor_activate_cmd);
10330   install_element (BGP_IPV4_NODE, &no_neighbor_activate_cmd);
10331   install_element (BGP_IPV4M_NODE, &no_neighbor_activate_cmd);
10332   install_element (BGP_IPV6_NODE, &no_neighbor_activate_cmd);
10333   install_element (BGP_IPV6M_NODE, &no_neighbor_activate_cmd);
10334   install_element (BGP_VPNV4_NODE, &no_neighbor_activate_cmd);
10335   install_element (BGP_VPNV6_NODE, &no_neighbor_activate_cmd);
10336   install_element (BGP_ENCAP_NODE, &no_neighbor_activate_cmd);
10337   install_element (BGP_ENCAPV6_NODE, &no_neighbor_activate_cmd);
10338   install_element (BGP_EVPN_NODE, &no_neighbor_activate_cmd);
10339
10340   /* "neighbor peer-group" set commands.
10341    * Long term we should only accept this command under BGP_NODE and not all of
10342    * the afi/safi sub-contexts. For now though we need to accept it for backwards
10343    * compatibility. This changed when we stopped requiring that peers be assigned
10344    * to their peer-group under each address-family sub-context.
10345    */
10346   install_element (BGP_NODE, &neighbor_set_peer_group_cmd);
10347   install_element (BGP_IPV4_NODE, &neighbor_set_peer_group_cmd);
10348   install_element (BGP_IPV4M_NODE, &neighbor_set_peer_group_cmd);
10349   install_element (BGP_IPV6_NODE, &neighbor_set_peer_group_cmd);
10350   install_element (BGP_IPV6M_NODE, &neighbor_set_peer_group_cmd);
10351   install_element (BGP_VPNV4_NODE, &neighbor_set_peer_group_cmd);
10352   install_element (BGP_VPNV6_NODE, &neighbor_set_peer_group_cmd);
10353   install_element (BGP_ENCAP_NODE, &neighbor_set_peer_group_cmd);
10354   install_element (BGP_ENCAPV6_NODE, &neighbor_set_peer_group_cmd);
10355
10356   /* "no neighbor peer-group unset" commands. */
10357   install_element (BGP_NODE, &no_neighbor_set_peer_group_cmd);
10358   install_element (BGP_IPV4_NODE, &no_neighbor_set_peer_group_cmd);
10359   install_element (BGP_IPV4M_NODE, &no_neighbor_set_peer_group_cmd);
10360   install_element (BGP_IPV6_NODE, &no_neighbor_set_peer_group_cmd);
10361   install_element (BGP_IPV6M_NODE, &no_neighbor_set_peer_group_cmd);
10362   install_element (BGP_VPNV4_NODE, &no_neighbor_set_peer_group_cmd);
10363   install_element (BGP_VPNV6_NODE, &no_neighbor_set_peer_group_cmd);
10364   install_element (BGP_ENCAP_NODE, &no_neighbor_set_peer_group_cmd);
10365   install_element (BGP_ENCAPV6_NODE, &no_neighbor_set_peer_group_cmd);
10366
10367   /* "neighbor softreconfiguration inbound" commands.*/
10368   install_element (BGP_NODE, &neighbor_soft_reconfiguration_cmd);
10369   install_element (BGP_NODE, &no_neighbor_soft_reconfiguration_cmd);
10370   install_element (BGP_IPV4_NODE, &neighbor_soft_reconfiguration_cmd);
10371   install_element (BGP_IPV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
10372   install_element (BGP_IPV4M_NODE, &neighbor_soft_reconfiguration_cmd);
10373   install_element (BGP_IPV4M_NODE, &no_neighbor_soft_reconfiguration_cmd);
10374   install_element (BGP_IPV6_NODE, &neighbor_soft_reconfiguration_cmd);
10375   install_element (BGP_IPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
10376   install_element (BGP_IPV6M_NODE, &neighbor_soft_reconfiguration_cmd);
10377   install_element (BGP_IPV6M_NODE, &no_neighbor_soft_reconfiguration_cmd);
10378   install_element (BGP_VPNV4_NODE, &neighbor_soft_reconfiguration_cmd);
10379   install_element (BGP_VPNV4_NODE, &no_neighbor_soft_reconfiguration_cmd);
10380   install_element (BGP_VPNV6_NODE, &neighbor_soft_reconfiguration_cmd);
10381   install_element (BGP_VPNV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
10382   install_element (BGP_ENCAP_NODE, &neighbor_soft_reconfiguration_cmd);
10383   install_element (BGP_ENCAP_NODE, &no_neighbor_soft_reconfiguration_cmd);
10384   install_element (BGP_ENCAPV6_NODE, &neighbor_soft_reconfiguration_cmd);
10385   install_element (BGP_ENCAPV6_NODE, &no_neighbor_soft_reconfiguration_cmd);
10386
10387   /* "neighbor attribute-unchanged" commands.  */
10388   install_element (BGP_NODE, &neighbor_attr_unchanged_cmd);
10389   install_element (BGP_NODE, &no_neighbor_attr_unchanged_cmd);
10390   install_element (BGP_IPV4_NODE, &neighbor_attr_unchanged_cmd);
10391   install_element (BGP_IPV4_NODE, &no_neighbor_attr_unchanged_cmd);
10392   install_element (BGP_IPV4M_NODE, &neighbor_attr_unchanged_cmd);
10393   install_element (BGP_IPV4M_NODE, &no_neighbor_attr_unchanged_cmd);
10394   install_element (BGP_IPV6_NODE, &neighbor_attr_unchanged_cmd);
10395   install_element (BGP_IPV6_NODE, &no_neighbor_attr_unchanged_cmd);
10396   install_element (BGP_IPV6M_NODE, &neighbor_attr_unchanged_cmd);
10397   install_element (BGP_IPV6M_NODE, &no_neighbor_attr_unchanged_cmd);
10398   install_element (BGP_VPNV4_NODE, &neighbor_attr_unchanged_cmd);
10399   install_element (BGP_VPNV4_NODE, &no_neighbor_attr_unchanged_cmd);
10400   install_element (BGP_VPNV6_NODE, &neighbor_attr_unchanged_cmd);
10401   install_element (BGP_VPNV6_NODE, &no_neighbor_attr_unchanged_cmd);
10402
10403   install_element (BGP_ENCAP_NODE, &neighbor_attr_unchanged_cmd);
10404   install_element (BGP_ENCAP_NODE, &no_neighbor_attr_unchanged_cmd);
10405
10406   install_element (BGP_ENCAPV6_NODE, &neighbor_attr_unchanged_cmd);
10407   install_element (BGP_ENCAPV6_NODE, &no_neighbor_attr_unchanged_cmd);
10408
10409   install_element (BGP_EVPN_NODE, &neighbor_attr_unchanged_cmd);
10410   install_element (BGP_EVPN_NODE, &no_neighbor_attr_unchanged_cmd);
10411
10412   /* "nexthop-local unchanged" commands */
10413   install_element (BGP_IPV6_NODE, &neighbor_nexthop_local_unchanged_cmd);
10414   install_element (BGP_IPV6_NODE, &no_neighbor_nexthop_local_unchanged_cmd);
10415
10416   /* "neighbor next-hop-self" commands. */
10417   install_element (BGP_NODE, &neighbor_nexthop_self_cmd);
10418   install_element (BGP_NODE, &no_neighbor_nexthop_self_cmd);
10419   install_element (BGP_IPV4_NODE, &neighbor_nexthop_self_cmd);
10420   install_element (BGP_IPV4_NODE, &no_neighbor_nexthop_self_cmd);
10421   install_element (BGP_IPV4M_NODE, &neighbor_nexthop_self_cmd);
10422   install_element (BGP_IPV4M_NODE, &no_neighbor_nexthop_self_cmd);
10423   install_element (BGP_IPV6_NODE, &neighbor_nexthop_self_cmd);
10424   install_element (BGP_IPV6_NODE, &no_neighbor_nexthop_self_cmd);
10425   install_element (BGP_IPV6M_NODE, &neighbor_nexthop_self_cmd);
10426   install_element (BGP_IPV6M_NODE, &no_neighbor_nexthop_self_cmd);
10427   install_element (BGP_VPNV4_NODE, &neighbor_nexthop_self_cmd);
10428   install_element (BGP_VPNV4_NODE, &no_neighbor_nexthop_self_cmd);
10429   install_element (BGP_VPNV6_NODE, &neighbor_nexthop_self_cmd);
10430   install_element (BGP_VPNV6_NODE, &no_neighbor_nexthop_self_cmd);
10431   install_element (BGP_ENCAP_NODE, &neighbor_nexthop_self_cmd);
10432   install_element (BGP_ENCAP_NODE, &no_neighbor_nexthop_self_cmd);
10433   install_element (BGP_ENCAPV6_NODE, &neighbor_nexthop_self_cmd);
10434   install_element (BGP_ENCAPV6_NODE, &no_neighbor_nexthop_self_cmd);
10435
10436   /* "neighbor next-hop-self force" commands. */
10437   install_element (BGP_NODE, &neighbor_nexthop_self_force_cmd);
10438   install_element (BGP_NODE, &no_neighbor_nexthop_self_force_cmd);
10439   install_element (BGP_IPV4_NODE, &neighbor_nexthop_self_force_cmd);
10440   install_element (BGP_IPV4_NODE, &no_neighbor_nexthop_self_force_cmd);
10441   install_element (BGP_IPV4M_NODE, &neighbor_nexthop_self_force_cmd);
10442   install_element (BGP_IPV4M_NODE, &no_neighbor_nexthop_self_force_cmd);
10443   install_element (BGP_IPV6_NODE, &neighbor_nexthop_self_force_cmd);
10444   install_element (BGP_IPV6_NODE, &no_neighbor_nexthop_self_force_cmd);
10445   install_element (BGP_IPV6M_NODE, &neighbor_nexthop_self_force_cmd);
10446   install_element (BGP_IPV6M_NODE, &no_neighbor_nexthop_self_force_cmd);
10447   install_element (BGP_VPNV4_NODE, &neighbor_nexthop_self_force_cmd);
10448   install_element (BGP_VPNV4_NODE, &no_neighbor_nexthop_self_force_cmd);
10449   install_element (BGP_VPNV6_NODE, &neighbor_nexthop_self_force_cmd);
10450   install_element (BGP_VPNV6_NODE, &no_neighbor_nexthop_self_force_cmd);
10451
10452   /* "neighbor as-override" commands. */
10453   install_element (BGP_NODE, &neighbor_as_override_cmd);
10454   install_element (BGP_NODE, &no_neighbor_as_override_cmd);
10455   install_element (BGP_IPV4_NODE, &neighbor_as_override_cmd);
10456   install_element (BGP_IPV4_NODE, &no_neighbor_as_override_cmd);
10457   install_element (BGP_IPV4M_NODE, &neighbor_as_override_cmd);
10458   install_element (BGP_IPV4M_NODE, &no_neighbor_as_override_cmd);
10459   install_element (BGP_IPV6_NODE, &neighbor_as_override_cmd);
10460   install_element (BGP_IPV6_NODE, &no_neighbor_as_override_cmd);
10461   install_element (BGP_IPV6M_NODE, &neighbor_as_override_cmd);
10462   install_element (BGP_IPV6M_NODE, &no_neighbor_as_override_cmd);
10463   install_element (BGP_VPNV4_NODE, &neighbor_as_override_cmd);
10464   install_element (BGP_VPNV4_NODE, &no_neighbor_as_override_cmd);
10465   install_element (BGP_VPNV6_NODE, &neighbor_as_override_cmd);
10466   install_element (BGP_VPNV6_NODE, &no_neighbor_as_override_cmd);
10467
10468   /* "neighbor remove-private-AS" commands. */
10469   install_element (BGP_NODE, &neighbor_remove_private_as_cmd);
10470   install_element (BGP_NODE, &no_neighbor_remove_private_as_cmd);
10471   install_element (BGP_NODE, &neighbor_remove_private_as_all_cmd);
10472   install_element (BGP_NODE, &no_neighbor_remove_private_as_all_cmd);
10473   install_element (BGP_NODE, &neighbor_remove_private_as_replace_as_cmd);
10474   install_element (BGP_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10475   install_element (BGP_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10476   install_element (BGP_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10477   install_element (BGP_IPV4_NODE, &neighbor_remove_private_as_cmd);
10478   install_element (BGP_IPV4_NODE, &no_neighbor_remove_private_as_cmd);
10479   install_element (BGP_IPV4_NODE, &neighbor_remove_private_as_all_cmd);
10480   install_element (BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_cmd);
10481   install_element (BGP_IPV4_NODE, &neighbor_remove_private_as_replace_as_cmd);
10482   install_element (BGP_IPV4_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10483   install_element (BGP_IPV4_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10484   install_element (BGP_IPV4_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10485   install_element (BGP_IPV4M_NODE, &neighbor_remove_private_as_cmd);
10486   install_element (BGP_IPV4M_NODE, &no_neighbor_remove_private_as_cmd);
10487   install_element (BGP_IPV4M_NODE, &neighbor_remove_private_as_all_cmd);
10488   install_element (BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_cmd);
10489   install_element (BGP_IPV4M_NODE, &neighbor_remove_private_as_replace_as_cmd);
10490   install_element (BGP_IPV4M_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10491   install_element (BGP_IPV4M_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10492   install_element (BGP_IPV4M_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10493   install_element (BGP_IPV6_NODE, &neighbor_remove_private_as_cmd);
10494   install_element (BGP_IPV6_NODE, &no_neighbor_remove_private_as_cmd);
10495   install_element (BGP_IPV6_NODE, &neighbor_remove_private_as_all_cmd);
10496   install_element (BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_cmd);
10497   install_element (BGP_IPV6_NODE, &neighbor_remove_private_as_replace_as_cmd);
10498   install_element (BGP_IPV6_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10499   install_element (BGP_IPV6_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10500   install_element (BGP_IPV6_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10501   install_element (BGP_IPV6M_NODE, &neighbor_remove_private_as_cmd);
10502   install_element (BGP_IPV6M_NODE, &no_neighbor_remove_private_as_cmd);
10503   install_element (BGP_IPV6M_NODE, &neighbor_remove_private_as_all_cmd);
10504   install_element (BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_cmd);
10505   install_element (BGP_IPV6M_NODE, &neighbor_remove_private_as_replace_as_cmd);
10506   install_element (BGP_IPV6M_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10507   install_element (BGP_IPV6M_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10508   install_element (BGP_IPV6M_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10509   install_element (BGP_VPNV4_NODE, &neighbor_remove_private_as_cmd);
10510   install_element (BGP_VPNV4_NODE, &no_neighbor_remove_private_as_cmd);
10511   install_element (BGP_VPNV4_NODE, &neighbor_remove_private_as_all_cmd);
10512   install_element (BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_cmd);
10513   install_element (BGP_VPNV4_NODE, &neighbor_remove_private_as_replace_as_cmd);
10514   install_element (BGP_VPNV4_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10515   install_element (BGP_VPNV4_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10516   install_element (BGP_VPNV4_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10517   install_element (BGP_VPNV6_NODE, &neighbor_remove_private_as_cmd);
10518   install_element (BGP_VPNV6_NODE, &no_neighbor_remove_private_as_cmd);
10519   install_element (BGP_VPNV6_NODE, &neighbor_remove_private_as_all_cmd);
10520   install_element (BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_cmd);
10521   install_element (BGP_VPNV6_NODE, &neighbor_remove_private_as_replace_as_cmd);
10522   install_element (BGP_VPNV6_NODE, &no_neighbor_remove_private_as_replace_as_cmd);
10523   install_element (BGP_VPNV6_NODE, &neighbor_remove_private_as_all_replace_as_cmd);
10524   install_element (BGP_VPNV6_NODE, &no_neighbor_remove_private_as_all_replace_as_cmd);
10525   install_element (BGP_ENCAP_NODE, &neighbor_remove_private_as_cmd);
10526   install_element (BGP_ENCAP_NODE, &no_neighbor_remove_private_as_cmd);
10527   install_element (BGP_ENCAPV6_NODE, &neighbor_remove_private_as_cmd);
10528   install_element (BGP_ENCAPV6_NODE, &no_neighbor_remove_private_as_cmd);
10529
10530   /* "neighbor send-community" commands.*/
10531   install_element (BGP_NODE, &neighbor_send_community_cmd);
10532   install_element (BGP_NODE, &neighbor_send_community_type_cmd);
10533   install_element (BGP_NODE, &no_neighbor_send_community_cmd);
10534   install_element (BGP_NODE, &no_neighbor_send_community_type_cmd);
10535   install_element (BGP_IPV4_NODE, &neighbor_send_community_cmd);
10536   install_element (BGP_IPV4_NODE, &neighbor_send_community_type_cmd);
10537   install_element (BGP_IPV4_NODE, &no_neighbor_send_community_cmd);
10538   install_element (BGP_IPV4_NODE, &no_neighbor_send_community_type_cmd);
10539   install_element (BGP_IPV4M_NODE, &neighbor_send_community_cmd);
10540   install_element (BGP_IPV4M_NODE, &neighbor_send_community_type_cmd);
10541   install_element (BGP_IPV4M_NODE, &no_neighbor_send_community_cmd);
10542   install_element (BGP_IPV4M_NODE, &no_neighbor_send_community_type_cmd);
10543   install_element (BGP_IPV6_NODE, &neighbor_send_community_cmd);
10544   install_element (BGP_IPV6_NODE, &neighbor_send_community_type_cmd);
10545   install_element (BGP_IPV6_NODE, &no_neighbor_send_community_cmd);
10546   install_element (BGP_IPV6_NODE, &no_neighbor_send_community_type_cmd);
10547   install_element (BGP_IPV6M_NODE, &neighbor_send_community_cmd);
10548   install_element (BGP_IPV6M_NODE, &neighbor_send_community_type_cmd);
10549   install_element (BGP_IPV6M_NODE, &no_neighbor_send_community_cmd);
10550   install_element (BGP_IPV6M_NODE, &no_neighbor_send_community_type_cmd);
10551   install_element (BGP_VPNV4_NODE, &neighbor_send_community_cmd);
10552   install_element (BGP_VPNV4_NODE, &neighbor_send_community_type_cmd);
10553   install_element (BGP_VPNV4_NODE, &no_neighbor_send_community_cmd);
10554   install_element (BGP_VPNV4_NODE, &no_neighbor_send_community_type_cmd);
10555   install_element (BGP_VPNV6_NODE, &neighbor_send_community_cmd);
10556   install_element (BGP_VPNV6_NODE, &neighbor_send_community_type_cmd);
10557   install_element (BGP_VPNV6_NODE, &no_neighbor_send_community_cmd);
10558   install_element (BGP_VPNV6_NODE, &no_neighbor_send_community_type_cmd);
10559   install_element (BGP_ENCAP_NODE, &neighbor_send_community_cmd);
10560   install_element (BGP_ENCAP_NODE, &neighbor_send_community_type_cmd);
10561   install_element (BGP_ENCAP_NODE, &no_neighbor_send_community_cmd);
10562   install_element (BGP_ENCAP_NODE, &no_neighbor_send_community_type_cmd);
10563   install_element (BGP_ENCAPV6_NODE, &neighbor_send_community_cmd);
10564   install_element (BGP_ENCAPV6_NODE, &neighbor_send_community_type_cmd);
10565   install_element (BGP_ENCAPV6_NODE, &no_neighbor_send_community_cmd);
10566   install_element (BGP_ENCAPV6_NODE, &no_neighbor_send_community_type_cmd);
10567
10568   /* "neighbor route-reflector" commands.*/
10569   install_element (BGP_NODE, &neighbor_route_reflector_client_cmd);
10570   install_element (BGP_NODE, &no_neighbor_route_reflector_client_cmd);
10571   install_element (BGP_IPV4_NODE, &neighbor_route_reflector_client_cmd);
10572   install_element (BGP_IPV4_NODE, &no_neighbor_route_reflector_client_cmd);
10573   install_element (BGP_IPV4M_NODE, &neighbor_route_reflector_client_cmd);
10574   install_element (BGP_IPV4M_NODE, &no_neighbor_route_reflector_client_cmd);
10575   install_element (BGP_IPV6_NODE, &neighbor_route_reflector_client_cmd);
10576   install_element (BGP_IPV6_NODE, &no_neighbor_route_reflector_client_cmd);
10577   install_element (BGP_IPV6M_NODE, &neighbor_route_reflector_client_cmd);
10578   install_element (BGP_IPV6M_NODE, &no_neighbor_route_reflector_client_cmd);
10579   install_element (BGP_VPNV4_NODE, &neighbor_route_reflector_client_cmd);
10580   install_element (BGP_VPNV4_NODE, &no_neighbor_route_reflector_client_cmd);
10581   install_element (BGP_VPNV6_NODE, &neighbor_route_reflector_client_cmd);
10582   install_element (BGP_VPNV6_NODE, &no_neighbor_route_reflector_client_cmd);
10583   install_element (BGP_ENCAP_NODE, &neighbor_route_reflector_client_cmd);
10584   install_element (BGP_ENCAP_NODE, &no_neighbor_route_reflector_client_cmd);
10585   install_element (BGP_ENCAPV6_NODE, &neighbor_route_reflector_client_cmd);
10586   install_element (BGP_ENCAPV6_NODE, &no_neighbor_route_reflector_client_cmd);
10587
10588   /* "neighbor route-server" commands.*/
10589   install_element (BGP_NODE, &neighbor_route_server_client_cmd);
10590   install_element (BGP_NODE, &no_neighbor_route_server_client_cmd);
10591   install_element (BGP_IPV4_NODE, &neighbor_route_server_client_cmd);
10592   install_element (BGP_IPV4_NODE, &no_neighbor_route_server_client_cmd);
10593   install_element (BGP_IPV4M_NODE, &neighbor_route_server_client_cmd);
10594   install_element (BGP_IPV4M_NODE, &no_neighbor_route_server_client_cmd);
10595   install_element (BGP_IPV6_NODE, &neighbor_route_server_client_cmd);
10596   install_element (BGP_IPV6_NODE, &no_neighbor_route_server_client_cmd);
10597   install_element (BGP_IPV6M_NODE, &neighbor_route_server_client_cmd);
10598   install_element (BGP_IPV6M_NODE, &no_neighbor_route_server_client_cmd);
10599   install_element (BGP_VPNV4_NODE, &neighbor_route_server_client_cmd);
10600   install_element (BGP_VPNV4_NODE, &no_neighbor_route_server_client_cmd);
10601   install_element (BGP_VPNV6_NODE, &neighbor_route_server_client_cmd);
10602   install_element (BGP_VPNV6_NODE, &no_neighbor_route_server_client_cmd);
10603   install_element (BGP_ENCAP_NODE, &neighbor_route_server_client_cmd);
10604   install_element (BGP_ENCAP_NODE, &no_neighbor_route_server_client_cmd);
10605   install_element (BGP_ENCAPV6_NODE, &neighbor_route_server_client_cmd);
10606   install_element (BGP_ENCAPV6_NODE, &no_neighbor_route_server_client_cmd);
10607
10608   /* "neighbor addpath-tx-all-paths" commands.*/
10609   install_element (BGP_NODE, &neighbor_addpath_tx_all_paths_cmd);
10610   install_element (BGP_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10611   install_element (BGP_IPV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
10612   install_element (BGP_IPV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10613   install_element (BGP_IPV4M_NODE, &neighbor_addpath_tx_all_paths_cmd);
10614   install_element (BGP_IPV4M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10615   install_element (BGP_IPV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
10616   install_element (BGP_IPV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10617   install_element (BGP_IPV6M_NODE, &neighbor_addpath_tx_all_paths_cmd);
10618   install_element (BGP_IPV6M_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10619   install_element (BGP_VPNV4_NODE, &neighbor_addpath_tx_all_paths_cmd);
10620   install_element (BGP_VPNV4_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10621   install_element (BGP_VPNV6_NODE, &neighbor_addpath_tx_all_paths_cmd);
10622   install_element (BGP_VPNV6_NODE, &no_neighbor_addpath_tx_all_paths_cmd);
10623
10624   /* "neighbor addpath-tx-bestpath-per-AS" commands.*/
10625   install_element (BGP_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10626   install_element (BGP_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10627   install_element (BGP_IPV4_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10628   install_element (BGP_IPV4_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10629   install_element (BGP_IPV4M_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10630   install_element (BGP_IPV4M_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10631   install_element (BGP_IPV6_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10632   install_element (BGP_IPV6_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10633   install_element (BGP_IPV6M_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10634   install_element (BGP_IPV6M_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10635   install_element (BGP_VPNV4_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10636   install_element (BGP_VPNV4_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10637   install_element (BGP_VPNV6_NODE, &neighbor_addpath_tx_bestpath_per_as_cmd);
10638   install_element (BGP_VPNV6_NODE, &no_neighbor_addpath_tx_bestpath_per_as_cmd);
10639
10640   /* "neighbor passive" commands. */
10641   install_element (BGP_NODE, &neighbor_passive_cmd);
10642   install_element (BGP_NODE, &no_neighbor_passive_cmd);
10643
10644
10645   /* "neighbor shutdown" commands. */
10646   install_element (BGP_NODE, &neighbor_shutdown_cmd);
10647   install_element (BGP_NODE, &no_neighbor_shutdown_cmd);
10648   install_element (BGP_NODE, &neighbor_shutdown_msg_cmd);
10649   install_element (BGP_NODE, &no_neighbor_shutdown_msg_cmd);
10650
10651   /* "neighbor capability extended-nexthop" commands.*/
10652   install_element (BGP_NODE, &neighbor_capability_enhe_cmd);
10653   install_element (BGP_NODE, &no_neighbor_capability_enhe_cmd);
10654
10655   /* "neighbor capability orf prefix-list" commands.*/
10656   install_element (BGP_NODE, &neighbor_capability_orf_prefix_cmd);
10657   install_element (BGP_NODE, &no_neighbor_capability_orf_prefix_cmd);
10658   install_element (BGP_IPV4_NODE, &neighbor_capability_orf_prefix_cmd);
10659   install_element (BGP_IPV4_NODE, &no_neighbor_capability_orf_prefix_cmd);
10660   install_element (BGP_IPV4M_NODE, &neighbor_capability_orf_prefix_cmd);
10661   install_element (BGP_IPV4M_NODE, &no_neighbor_capability_orf_prefix_cmd);
10662   install_element (BGP_IPV6_NODE, &neighbor_capability_orf_prefix_cmd);
10663   install_element (BGP_IPV6_NODE, &no_neighbor_capability_orf_prefix_cmd);
10664   install_element (BGP_IPV6M_NODE, &neighbor_capability_orf_prefix_cmd);
10665   install_element (BGP_IPV6M_NODE, &no_neighbor_capability_orf_prefix_cmd);
10666
10667   /* "neighbor capability dynamic" commands.*/
10668   install_element (BGP_NODE, &neighbor_capability_dynamic_cmd);
10669   install_element (BGP_NODE, &no_neighbor_capability_dynamic_cmd);
10670
10671   /* "neighbor dont-capability-negotiate" commands. */
10672   install_element (BGP_NODE, &neighbor_dont_capability_negotiate_cmd);
10673   install_element (BGP_NODE, &no_neighbor_dont_capability_negotiate_cmd);
10674
10675   /* "neighbor ebgp-multihop" commands. */
10676   install_element (BGP_NODE, &neighbor_ebgp_multihop_cmd);
10677   install_element (BGP_NODE, &neighbor_ebgp_multihop_ttl_cmd);
10678   install_element (BGP_NODE, &no_neighbor_ebgp_multihop_cmd);
10679
10680   /* "neighbor disable-connected-check" commands.  */
10681   install_element (BGP_NODE, &neighbor_disable_connected_check_cmd);
10682   install_element (BGP_NODE, &no_neighbor_disable_connected_check_cmd);
10683
10684   /* "neighbor description" commands. */
10685   install_element (BGP_NODE, &neighbor_description_cmd);
10686   install_element (BGP_NODE, &no_neighbor_description_cmd);
10687
10688   /* "neighbor update-source" commands. "*/
10689   install_element (BGP_NODE, &neighbor_update_source_cmd);
10690   install_element (BGP_NODE, &no_neighbor_update_source_cmd);
10691
10692   /* "neighbor default-originate" commands. */
10693   install_element (BGP_NODE, &neighbor_default_originate_cmd);
10694   install_element (BGP_NODE, &neighbor_default_originate_rmap_cmd);
10695   install_element (BGP_NODE, &no_neighbor_default_originate_cmd);
10696   install_element (BGP_IPV4_NODE, &neighbor_default_originate_cmd);
10697   install_element (BGP_IPV4_NODE, &neighbor_default_originate_rmap_cmd);
10698   install_element (BGP_IPV4_NODE, &no_neighbor_default_originate_cmd);
10699   install_element (BGP_IPV4M_NODE, &neighbor_default_originate_cmd);
10700   install_element (BGP_IPV4M_NODE, &neighbor_default_originate_rmap_cmd);
10701   install_element (BGP_IPV4M_NODE, &no_neighbor_default_originate_cmd);
10702   install_element (BGP_IPV6_NODE, &neighbor_default_originate_cmd);
10703   install_element (BGP_IPV6_NODE, &neighbor_default_originate_rmap_cmd);
10704   install_element (BGP_IPV6_NODE, &no_neighbor_default_originate_cmd);
10705   install_element (BGP_IPV6M_NODE, &neighbor_default_originate_cmd);
10706   install_element (BGP_IPV6M_NODE, &neighbor_default_originate_rmap_cmd);
10707   install_element (BGP_IPV6M_NODE, &no_neighbor_default_originate_cmd);
10708
10709   /* "neighbor port" commands. */
10710   install_element (BGP_NODE, &neighbor_port_cmd);
10711   install_element (BGP_NODE, &no_neighbor_port_cmd);
10712
10713   /* "neighbor weight" commands. */
10714   install_element (BGP_NODE, &neighbor_weight_cmd);
10715   install_element (BGP_NODE, &no_neighbor_weight_cmd);
10716
10717   install_element (BGP_IPV4_NODE, &neighbor_weight_cmd);
10718   install_element (BGP_IPV4_NODE, &no_neighbor_weight_cmd);
10719   install_element (BGP_IPV4M_NODE, &neighbor_weight_cmd);
10720   install_element (BGP_IPV4M_NODE, &no_neighbor_weight_cmd);
10721   install_element (BGP_IPV6_NODE, &neighbor_weight_cmd);
10722   install_element (BGP_IPV6_NODE, &no_neighbor_weight_cmd);
10723   install_element (BGP_IPV6M_NODE, &neighbor_weight_cmd);
10724   install_element (BGP_IPV6M_NODE, &no_neighbor_weight_cmd);
10725   install_element (BGP_VPNV4_NODE, &neighbor_weight_cmd);
10726   install_element (BGP_VPNV4_NODE, &no_neighbor_weight_cmd);
10727   install_element (BGP_VPNV6_NODE, &neighbor_weight_cmd);
10728   install_element (BGP_VPNV6_NODE, &no_neighbor_weight_cmd);
10729   install_element (BGP_ENCAP_NODE, &neighbor_weight_cmd);
10730   install_element (BGP_ENCAP_NODE, &no_neighbor_weight_cmd);
10731   install_element (BGP_ENCAPV6_NODE, &neighbor_weight_cmd);
10732   install_element (BGP_ENCAPV6_NODE, &no_neighbor_weight_cmd);
10733
10734   /* "neighbor override-capability" commands. */
10735   install_element (BGP_NODE, &neighbor_override_capability_cmd);
10736   install_element (BGP_NODE, &no_neighbor_override_capability_cmd);
10737
10738   /* "neighbor strict-capability-match" commands. */
10739   install_element (BGP_NODE, &neighbor_strict_capability_cmd);
10740   install_element (BGP_NODE, &no_neighbor_strict_capability_cmd);
10741
10742   /* "neighbor timers" commands. */
10743   install_element (BGP_NODE, &neighbor_timers_cmd);
10744   install_element (BGP_NODE, &no_neighbor_timers_cmd);
10745
10746   /* "neighbor timers connect" commands. */
10747   install_element (BGP_NODE, &neighbor_timers_connect_cmd);
10748   install_element (BGP_NODE, &no_neighbor_timers_connect_cmd);
10749
10750   /* "neighbor advertisement-interval" commands. */
10751   install_element (BGP_NODE, &neighbor_advertise_interval_cmd);
10752   install_element (BGP_NODE, &no_neighbor_advertise_interval_cmd);
10753
10754   /* "neighbor interface" commands. */
10755   install_element (BGP_NODE, &neighbor_interface_cmd);
10756   install_element (BGP_NODE, &no_neighbor_interface_cmd);
10757
10758   /* "neighbor distribute" commands. */
10759   install_element (BGP_NODE, &neighbor_distribute_list_cmd);
10760   install_element (BGP_NODE, &no_neighbor_distribute_list_cmd);
10761   install_element (BGP_IPV4_NODE, &neighbor_distribute_list_cmd);
10762   install_element (BGP_IPV4_NODE, &no_neighbor_distribute_list_cmd);
10763   install_element (BGP_IPV4M_NODE, &neighbor_distribute_list_cmd);
10764   install_element (BGP_IPV4M_NODE, &no_neighbor_distribute_list_cmd);
10765   install_element (BGP_IPV6_NODE, &neighbor_distribute_list_cmd);
10766   install_element (BGP_IPV6_NODE, &no_neighbor_distribute_list_cmd);
10767   install_element (BGP_IPV6M_NODE, &neighbor_distribute_list_cmd);
10768   install_element (BGP_IPV6M_NODE, &no_neighbor_distribute_list_cmd);
10769   install_element (BGP_VPNV4_NODE, &neighbor_distribute_list_cmd);
10770   install_element (BGP_VPNV4_NODE, &no_neighbor_distribute_list_cmd);
10771   install_element (BGP_VPNV6_NODE, &neighbor_distribute_list_cmd);
10772   install_element (BGP_VPNV6_NODE, &no_neighbor_distribute_list_cmd);
10773   install_element (BGP_ENCAP_NODE, &neighbor_distribute_list_cmd);
10774   install_element (BGP_ENCAP_NODE, &no_neighbor_distribute_list_cmd);
10775   install_element (BGP_ENCAPV6_NODE, &neighbor_distribute_list_cmd);
10776   install_element (BGP_ENCAPV6_NODE, &no_neighbor_distribute_list_cmd);
10777
10778   /* "neighbor prefix-list" commands. */
10779   install_element (BGP_NODE, &neighbor_prefix_list_cmd);
10780   install_element (BGP_NODE, &no_neighbor_prefix_list_cmd);
10781   install_element (BGP_IPV4_NODE, &neighbor_prefix_list_cmd);
10782   install_element (BGP_IPV4_NODE, &no_neighbor_prefix_list_cmd);
10783   install_element (BGP_IPV4M_NODE, &neighbor_prefix_list_cmd);
10784   install_element (BGP_IPV4M_NODE, &no_neighbor_prefix_list_cmd);
10785   install_element (BGP_IPV6_NODE, &neighbor_prefix_list_cmd);
10786   install_element (BGP_IPV6_NODE, &no_neighbor_prefix_list_cmd);
10787   install_element (BGP_IPV6M_NODE, &neighbor_prefix_list_cmd);
10788   install_element (BGP_IPV6M_NODE, &no_neighbor_prefix_list_cmd);
10789   install_element (BGP_VPNV4_NODE, &neighbor_prefix_list_cmd);
10790   install_element (BGP_VPNV4_NODE, &no_neighbor_prefix_list_cmd);
10791   install_element (BGP_VPNV6_NODE, &neighbor_prefix_list_cmd);
10792   install_element (BGP_VPNV6_NODE, &no_neighbor_prefix_list_cmd);
10793   install_element (BGP_ENCAP_NODE, &neighbor_prefix_list_cmd);
10794   install_element (BGP_ENCAP_NODE, &no_neighbor_prefix_list_cmd);
10795   install_element (BGP_ENCAPV6_NODE, &neighbor_prefix_list_cmd);
10796   install_element (BGP_ENCAPV6_NODE, &no_neighbor_prefix_list_cmd);
10797
10798   /* "neighbor filter-list" commands. */
10799   install_element (BGP_NODE, &neighbor_filter_list_cmd);
10800   install_element (BGP_NODE, &no_neighbor_filter_list_cmd);
10801   install_element (BGP_IPV4_NODE, &neighbor_filter_list_cmd);
10802   install_element (BGP_IPV4_NODE, &no_neighbor_filter_list_cmd);
10803   install_element (BGP_IPV4M_NODE, &neighbor_filter_list_cmd);
10804   install_element (BGP_IPV4M_NODE, &no_neighbor_filter_list_cmd);
10805   install_element (BGP_IPV6_NODE, &neighbor_filter_list_cmd);
10806   install_element (BGP_IPV6_NODE, &no_neighbor_filter_list_cmd);
10807   install_element (BGP_IPV6M_NODE, &neighbor_filter_list_cmd);
10808   install_element (BGP_IPV6M_NODE, &no_neighbor_filter_list_cmd);
10809   install_element (BGP_VPNV4_NODE, &neighbor_filter_list_cmd);
10810   install_element (BGP_VPNV4_NODE, &no_neighbor_filter_list_cmd);
10811   install_element (BGP_VPNV6_NODE, &neighbor_filter_list_cmd);
10812   install_element (BGP_VPNV6_NODE, &no_neighbor_filter_list_cmd);
10813   install_element (BGP_ENCAP_NODE, &neighbor_filter_list_cmd);
10814   install_element (BGP_ENCAP_NODE, &no_neighbor_filter_list_cmd);
10815   install_element (BGP_ENCAPV6_NODE, &neighbor_filter_list_cmd);
10816   install_element (BGP_ENCAPV6_NODE, &no_neighbor_filter_list_cmd);
10817
10818   /* "neighbor route-map" commands. */
10819   install_element (BGP_NODE, &neighbor_route_map_cmd);
10820   install_element (BGP_NODE, &no_neighbor_route_map_cmd);
10821   install_element (BGP_IPV4_NODE, &neighbor_route_map_cmd);
10822   install_element (BGP_IPV4_NODE, &no_neighbor_route_map_cmd);
10823   install_element (BGP_IPV4M_NODE, &neighbor_route_map_cmd);
10824   install_element (BGP_IPV4M_NODE, &no_neighbor_route_map_cmd);
10825   install_element (BGP_IPV6_NODE, &neighbor_route_map_cmd);
10826   install_element (BGP_IPV6_NODE, &no_neighbor_route_map_cmd);
10827   install_element (BGP_IPV6M_NODE, &neighbor_route_map_cmd);
10828   install_element (BGP_IPV6M_NODE, &no_neighbor_route_map_cmd);
10829   install_element (BGP_VPNV4_NODE, &neighbor_route_map_cmd);
10830   install_element (BGP_VPNV4_NODE, &no_neighbor_route_map_cmd);
10831   install_element (BGP_VPNV6_NODE, &neighbor_route_map_cmd);
10832   install_element (BGP_VPNV6_NODE, &no_neighbor_route_map_cmd);
10833   install_element (BGP_ENCAP_NODE, &neighbor_route_map_cmd);
10834   install_element (BGP_ENCAP_NODE, &no_neighbor_route_map_cmd);
10835   install_element (BGP_ENCAPV6_NODE, &neighbor_route_map_cmd);
10836   install_element (BGP_ENCAPV6_NODE, &no_neighbor_route_map_cmd);
10837
10838   /* "neighbor unsuppress-map" commands. */
10839   install_element (BGP_NODE, &neighbor_unsuppress_map_cmd);
10840   install_element (BGP_NODE, &no_neighbor_unsuppress_map_cmd);
10841   install_element (BGP_IPV4_NODE, &neighbor_unsuppress_map_cmd);
10842   install_element (BGP_IPV4_NODE, &no_neighbor_unsuppress_map_cmd);
10843   install_element (BGP_IPV4M_NODE, &neighbor_unsuppress_map_cmd);
10844   install_element (BGP_IPV4M_NODE, &no_neighbor_unsuppress_map_cmd);
10845   install_element (BGP_IPV6_NODE, &neighbor_unsuppress_map_cmd);
10846   install_element (BGP_IPV6_NODE, &no_neighbor_unsuppress_map_cmd);
10847   install_element (BGP_IPV6M_NODE, &neighbor_unsuppress_map_cmd);
10848   install_element (BGP_IPV6M_NODE, &no_neighbor_unsuppress_map_cmd);
10849   install_element (BGP_VPNV4_NODE, &neighbor_unsuppress_map_cmd);
10850   install_element (BGP_VPNV4_NODE, &no_neighbor_unsuppress_map_cmd);
10851   install_element (BGP_VPNV6_NODE, &neighbor_unsuppress_map_cmd);
10852   install_element (BGP_VPNV6_NODE, &no_neighbor_unsuppress_map_cmd);
10853   install_element (BGP_ENCAP_NODE, &neighbor_unsuppress_map_cmd);
10854   install_element (BGP_ENCAP_NODE, &no_neighbor_unsuppress_map_cmd);
10855   install_element (BGP_ENCAPV6_NODE, &neighbor_unsuppress_map_cmd);
10856   install_element (BGP_ENCAPV6_NODE, &no_neighbor_unsuppress_map_cmd);
10857
10858   /* "neighbor maximum-prefix" commands. */
10859   install_element (BGP_NODE, &neighbor_maximum_prefix_cmd);
10860   install_element (BGP_NODE, &neighbor_maximum_prefix_threshold_cmd);
10861   install_element (BGP_NODE, &neighbor_maximum_prefix_warning_cmd);
10862   install_element (BGP_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10863   install_element (BGP_NODE, &neighbor_maximum_prefix_restart_cmd);
10864   install_element (BGP_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10865   install_element (BGP_NODE, &no_neighbor_maximum_prefix_cmd);
10866   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_cmd);
10867   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
10868   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_warning_cmd);
10869   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10870   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_restart_cmd);
10871   install_element (BGP_IPV4_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10872   install_element (BGP_IPV4_NODE, &no_neighbor_maximum_prefix_cmd);
10873   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_cmd);
10874   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_cmd);
10875   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_warning_cmd);
10876   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10877   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_restart_cmd);
10878   install_element (BGP_IPV4M_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10879   install_element (BGP_IPV4M_NODE, &no_neighbor_maximum_prefix_cmd);
10880   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_cmd);
10881   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
10882   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
10883   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10884   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
10885   install_element (BGP_IPV6_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10886   install_element (BGP_IPV6_NODE, &no_neighbor_maximum_prefix_cmd);
10887   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_cmd);
10888   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_cmd);
10889   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_warning_cmd);
10890   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10891   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_restart_cmd);
10892   install_element (BGP_IPV6M_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10893   install_element (BGP_IPV6M_NODE, &no_neighbor_maximum_prefix_cmd);
10894   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_cmd);
10895   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_cmd);
10896   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_warning_cmd);
10897   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10898   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_restart_cmd);
10899   install_element (BGP_VPNV4_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10900   install_element (BGP_VPNV4_NODE, &no_neighbor_maximum_prefix_cmd);
10901   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_cmd);
10902   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
10903   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_warning_cmd);
10904   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10905   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_restart_cmd);
10906   install_element (BGP_VPNV6_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10907   install_element (BGP_VPNV6_NODE, &no_neighbor_maximum_prefix_cmd);
10908
10909   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_cmd);
10910   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_threshold_cmd);
10911   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_warning_cmd);
10912   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10913   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_restart_cmd);
10914   install_element (BGP_ENCAP_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10915   install_element (BGP_ENCAP_NODE, &no_neighbor_maximum_prefix_cmd);
10916
10917   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_cmd);
10918   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_threshold_cmd);
10919   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_warning_cmd);
10920   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_threshold_warning_cmd);
10921   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_restart_cmd);
10922   install_element (BGP_ENCAPV6_NODE, &neighbor_maximum_prefix_threshold_restart_cmd);
10923   install_element (BGP_ENCAPV6_NODE, &no_neighbor_maximum_prefix_cmd);
10924
10925   /* "neighbor allowas-in" */
10926   install_element (BGP_NODE, &neighbor_allowas_in_cmd);
10927   install_element (BGP_NODE, &no_neighbor_allowas_in_cmd);
10928   install_element (BGP_IPV4_NODE, &neighbor_allowas_in_cmd);
10929   install_element (BGP_IPV4_NODE, &no_neighbor_allowas_in_cmd);
10930   install_element (BGP_IPV4M_NODE, &neighbor_allowas_in_cmd);
10931   install_element (BGP_IPV4M_NODE, &no_neighbor_allowas_in_cmd);
10932   install_element (BGP_IPV6_NODE, &neighbor_allowas_in_cmd);
10933   install_element (BGP_IPV6_NODE, &no_neighbor_allowas_in_cmd);
10934   install_element (BGP_IPV6M_NODE, &neighbor_allowas_in_cmd);
10935   install_element (BGP_IPV6M_NODE, &no_neighbor_allowas_in_cmd);
10936   install_element (BGP_VPNV4_NODE, &neighbor_allowas_in_cmd);
10937   install_element (BGP_VPNV4_NODE, &no_neighbor_allowas_in_cmd);
10938   install_element (BGP_VPNV6_NODE, &neighbor_allowas_in_cmd);
10939   install_element (BGP_VPNV6_NODE, &no_neighbor_allowas_in_cmd);
10940   install_element (BGP_ENCAP_NODE, &neighbor_allowas_in_cmd);
10941   install_element (BGP_ENCAP_NODE, &no_neighbor_allowas_in_cmd);
10942   install_element (BGP_ENCAPV6_NODE, &neighbor_allowas_in_cmd);
10943   install_element (BGP_ENCAPV6_NODE, &no_neighbor_allowas_in_cmd);
10944
10945   /* address-family commands. */
10946   install_element (BGP_NODE, &address_family_ipv4_safi_cmd);
10947   install_element (BGP_NODE, &address_family_ipv6_safi_cmd);
10948 #ifdef KEEP_OLD_VPN_COMMANDS
10949   install_element (BGP_NODE, &address_family_vpnv4_cmd);
10950   install_element (BGP_NODE, &address_family_vpnv6_cmd);
10951 #endif /* KEEP_OLD_VPN_COMMANDS */
10952
10953   install_element (BGP_NODE, &address_family_encap_cmd);
10954   install_element (BGP_NODE, &address_family_encapv6_cmd);
10955
10956   install_element (BGP_NODE, &address_family_evpn_cmd);
10957
10958   /* "exit-address-family" command. */
10959   install_element (BGP_IPV4_NODE, &exit_address_family_cmd);
10960   install_element (BGP_IPV4M_NODE, &exit_address_family_cmd);
10961   install_element (BGP_IPV6_NODE, &exit_address_family_cmd);
10962   install_element (BGP_IPV6M_NODE, &exit_address_family_cmd);
10963   install_element (BGP_VPNV4_NODE, &exit_address_family_cmd);
10964   install_element (BGP_VPNV6_NODE, &exit_address_family_cmd);
10965   install_element (BGP_ENCAP_NODE, &exit_address_family_cmd);
10966   install_element (BGP_ENCAPV6_NODE, &exit_address_family_cmd);
10967   install_element (BGP_EVPN_NODE, &exit_address_family_cmd);
10968
10969   /* "clear ip bgp commands" */
10970   install_element (ENABLE_NODE, &clear_ip_bgp_all_cmd);
10971
10972   /* clear ip bgp prefix  */
10973   install_element (ENABLE_NODE, &clear_ip_bgp_prefix_cmd);
10974   install_element (ENABLE_NODE, &clear_bgp_ipv6_safi_prefix_cmd);
10975   install_element (ENABLE_NODE, &clear_bgp_instance_ipv6_safi_prefix_cmd);
10976
10977   /* "show [ip] bgp summary" commands. */
10978   install_element (VIEW_NODE, &show_bgp_instance_all_ipv6_updgrps_cmd);
10979   install_element (VIEW_NODE, &show_bgp_instance_updgrps_adj_cmd);
10980   install_element (VIEW_NODE, &show_bgp_instance_updgrps_adj_s_cmd);
10981   install_element (VIEW_NODE, &show_bgp_instance_updgrps_stats_cmd);
10982   install_element (VIEW_NODE, &show_bgp_updgrps_adj_cmd);
10983   install_element (VIEW_NODE, &show_bgp_updgrps_adj_s_cmd);
10984   install_element (VIEW_NODE, &show_bgp_updgrps_afi_adj_cmd);
10985   install_element (VIEW_NODE, &show_bgp_updgrps_afi_adj_s_cmd);
10986   install_element (VIEW_NODE, &show_bgp_updgrps_stats_cmd);
10987   install_element (VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_cmd);
10988   install_element (VIEW_NODE, &show_ip_bgp_instance_updgrps_adj_s_cmd);
10989   install_element (VIEW_NODE, &show_ip_bgp_summary_cmd);
10990   install_element (VIEW_NODE, &show_ip_bgp_updgrps_adj_cmd);
10991   install_element (VIEW_NODE, &show_ip_bgp_updgrps_adj_s_cmd);
10992   install_element (VIEW_NODE, &show_ip_bgp_updgrps_cmd);
10993
10994   /* "show [ip] bgp neighbors" commands. */
10995   install_element (VIEW_NODE, &show_ip_bgp_neighbors_cmd);
10996
10997   /* "show [ip] bgp peer-group" commands. */
10998   install_element (VIEW_NODE, &show_ip_bgp_peer_groups_cmd);
10999
11000   /* "show [ip] bgp paths" commands. */
11001   install_element (VIEW_NODE, &show_ip_bgp_paths_cmd);
11002
11003   /* "show [ip] bgp community" commands. */
11004   install_element (VIEW_NODE, &show_ip_bgp_community_info_cmd);
11005
11006   /* "show ip bgp large-community" commands. */
11007   install_element (VIEW_NODE, &show_ip_bgp_lcommunity_info_cmd);
11008   /* "show [ip] bgp attribute-info" commands. */
11009   install_element (VIEW_NODE, &show_ip_bgp_attr_info_cmd);
11010
11011   /* "redistribute" commands.  */
11012   install_element (BGP_NODE, &bgp_redistribute_ipv4_cmd);
11013   install_element (BGP_NODE, &no_bgp_redistribute_ipv4_cmd);
11014   install_element (BGP_NODE, &bgp_redistribute_ipv4_rmap_cmd);
11015   install_element (BGP_NODE, &bgp_redistribute_ipv4_metric_cmd);
11016   install_element (BGP_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
11017   install_element (BGP_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
11018   install_element (BGP_NODE, &bgp_redistribute_ipv4_ospf_cmd);
11019   install_element (BGP_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
11020   install_element (BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
11021   install_element (BGP_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
11022   install_element (BGP_NODE, &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
11023   install_element (BGP_NODE, &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
11024   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_cmd);
11025   install_element (BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_cmd);
11026   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_cmd);
11027   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_cmd);
11028   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_rmap_metric_cmd);
11029   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_metric_rmap_cmd);
11030   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_cmd);
11031   install_element (BGP_IPV4_NODE, &no_bgp_redistribute_ipv4_ospf_cmd);
11032   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_cmd);
11033   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_cmd);
11034   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_rmap_metric_cmd);
11035   install_element (BGP_IPV4_NODE, &bgp_redistribute_ipv4_ospf_metric_rmap_cmd);
11036   install_element (BGP_IPV6_NODE, &bgp_redistribute_ipv6_cmd);
11037   install_element (BGP_IPV6_NODE, &no_bgp_redistribute_ipv6_cmd);
11038   install_element (BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_cmd);
11039   install_element (BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_cmd);
11040   install_element (BGP_IPV6_NODE, &bgp_redistribute_ipv6_rmap_metric_cmd);
11041   install_element (BGP_IPV6_NODE, &bgp_redistribute_ipv6_metric_rmap_cmd);
11042
11043   /* ttl_security commands */
11044   install_element (BGP_NODE, &neighbor_ttl_security_cmd);
11045   install_element (BGP_NODE, &no_neighbor_ttl_security_cmd);
11046
11047   /* "show [ip] bgp memory" commands. */
11048   install_element (VIEW_NODE, &show_bgp_memory_cmd);
11049
11050   /* "show [ip] bgp views" commands. */
11051   install_element (VIEW_NODE, &show_bgp_views_cmd);
11052
11053   /* "show [ip] bgp vrfs" commands. */
11054   install_element (VIEW_NODE, &show_bgp_vrfs_cmd);
11055
11056   /* Community-list. */
11057   community_list_vty ();
11058 }
11059
11060 #include "memory.h"
11061 #include "bgp_regex.h"
11062 #include "bgp_clist.h"
11063 #include "bgp_ecommunity.h"
11064
11065 /* VTY functions.  */
11066
11067 /* Direction value to string conversion.  */
11068 static const char *
11069 community_direct_str (int direct)
11070 {
11071   switch (direct)
11072     {
11073     case COMMUNITY_DENY:
11074       return "deny";
11075     case COMMUNITY_PERMIT:
11076       return "permit";
11077     default:
11078       return "unknown";
11079     }
11080 }
11081
11082 /* Display error string.  */
11083 static void
11084 community_list_perror (struct vty *vty, int ret)
11085 {
11086   switch (ret)
11087     {
11088     case COMMUNITY_LIST_ERR_CANT_FIND_LIST:
11089       vty_out (vty, "%% Can't find community-list%s", VTY_NEWLINE);
11090       break;
11091     case COMMUNITY_LIST_ERR_MALFORMED_VAL:
11092       vty_out (vty, "%% Malformed community-list value%s", VTY_NEWLINE);
11093       break;
11094     case COMMUNITY_LIST_ERR_STANDARD_CONFLICT:
11095       vty_out (vty, "%% Community name conflict, previously defined as standard community%s", VTY_NEWLINE);
11096       break;
11097     case COMMUNITY_LIST_ERR_EXPANDED_CONFLICT:
11098       vty_out (vty, "%% Community name conflict, previously defined as expanded community%s", VTY_NEWLINE);
11099       break;
11100     }
11101 }
11102
11103 /* "community-list" keyword help string.  */
11104 #define COMMUNITY_LIST_STR "Add a community list entry\n"
11105
11106
11107 /* ip community-list standard */
11108 DEFUN (ip_community_list_standard,
11109        ip_community_list_standard_cmd,
11110        "ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
11111        IP_STR
11112        COMMUNITY_LIST_STR
11113        "Community list number (standard)\n"
11114        "Add an standard community-list entry\n"
11115        "Community list name\n"
11116        "Specify community to reject\n"
11117        "Specify community to accept\n"
11118        COMMUNITY_VAL_STR)
11119 {
11120   char *cl_name_or_number = NULL;
11121   int direct = 0;
11122   int style = COMMUNITY_LIST_STANDARD;
11123
11124   int idx = 0;
11125   argv_find (argv, argc, "(1-99)", &idx);
11126   argv_find (argv, argc, "WORD", &idx);
11127   cl_name_or_number = argv[idx]->arg;
11128   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11129   argv_find (argv, argc, "AA:NN", &idx);
11130   char *str = argv_concat (argv, argc, idx);
11131
11132   int ret = community_list_set (bgp_clist, cl_name_or_number, str, direct, style);
11133
11134   XFREE (MTYPE_TMP, str);
11135
11136   if (ret < 0)
11137     {
11138       /* Display error string.  */
11139       community_list_perror (vty, ret);
11140       return CMD_WARNING;
11141     }
11142
11143   return CMD_SUCCESS;
11144 }
11145
11146 DEFUN (no_ip_community_list_standard_all,
11147        no_ip_community_list_standard_all_cmd,
11148        "no ip community-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
11149        NO_STR
11150        IP_STR
11151        COMMUNITY_LIST_STR
11152        "Community list number (standard)\n"
11153        "Add an standard community-list entry\n"
11154        "Community list name\n"
11155        "Specify community to reject\n"
11156        "Specify community to accept\n"
11157        COMMUNITY_VAL_STR)
11158 {
11159   int delete_all = 0;
11160
11161   char *cl_name_or_number = NULL;
11162   int direct = 0;
11163   int style = COMMUNITY_LIST_STANDARD;
11164
11165   int idx = 0;
11166   argv_find (argv, argc, "(1-99)", &idx);
11167   argv_find (argv, argc, "WORD", &idx);
11168   cl_name_or_number = argv[idx]->arg;
11169   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11170   argv_find (argv, argc, "AA:NN", &idx);
11171   char *str = argv_concat (argv, argc, idx);
11172
11173   int ret = community_list_unset (bgp_clist, cl_name_or_number, str, direct, style, delete_all);
11174
11175   XFREE (MTYPE_TMP, str);
11176
11177   if (ret < 0)
11178     {
11179       community_list_perror (vty, ret);
11180       return CMD_WARNING;
11181     }
11182
11183   return CMD_SUCCESS;
11184 }
11185
11186 /* ip community-list expanded */
11187 DEFUN (ip_community_list_expanded_all,
11188        ip_community_list_expanded_all_cmd,
11189        "ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
11190        IP_STR
11191        COMMUNITY_LIST_STR
11192        "Community list number (expanded)\n"
11193        "Add an expanded community-list entry\n"
11194        "Community list name\n"
11195        "Specify community to reject\n"
11196        "Specify community to accept\n"
11197        COMMUNITY_VAL_STR)
11198 {
11199   char *cl_name_or_number = NULL;
11200   int direct = 0;
11201   int style = COMMUNITY_LIST_EXPANDED;
11202
11203   int idx = 0;
11204   argv_find (argv, argc, "(100-500)", &idx);
11205   argv_find (argv, argc, "WORD", &idx);
11206   cl_name_or_number = argv[idx]->arg;
11207   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11208   argv_find (argv, argc, "AA:NN", &idx);
11209   char *str = argv_concat (argv, argc, idx);
11210
11211   int ret = community_list_set (bgp_clist, cl_name_or_number, str, direct, style);
11212
11213   XFREE (MTYPE_TMP, str);
11214
11215   if (ret < 0)
11216     {
11217       /* Display error string.  */
11218       community_list_perror (vty, ret);
11219       return CMD_WARNING;
11220     }
11221
11222   return CMD_SUCCESS;
11223 }
11224
11225 DEFUN (no_ip_community_list_expanded_all,
11226        no_ip_community_list_expanded_all_cmd,
11227        "no ip community-list <(100-500)|expanded WORD> <deny|permit> AA:NN...",
11228        NO_STR
11229        IP_STR
11230        COMMUNITY_LIST_STR
11231        "Community list number (expanded)\n"
11232        "Add an expanded community-list entry\n"
11233        "Community list name\n"
11234        "Specify community to reject\n"
11235        "Specify community to accept\n"
11236        COMMUNITY_VAL_STR)
11237 {
11238   int delete_all = 0;
11239
11240   char *cl_name_or_number = NULL;
11241   int direct = 0;
11242   int style = COMMUNITY_LIST_EXPANDED;
11243
11244   int idx = 0;
11245   argv_find (argv, argc, "(100-500)", &idx);
11246   argv_find (argv, argc, "WORD", &idx);
11247   cl_name_or_number = argv[idx]->arg;
11248   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11249   argv_find (argv, argc, "AA:NN", &idx);
11250   char *str = argv_concat (argv, argc, idx);
11251
11252   int ret = community_list_unset (bgp_clist, cl_name_or_number, str, direct, style, delete_all);
11253
11254   XFREE (MTYPE_TMP, str);
11255
11256   if (ret < 0)
11257     {
11258       community_list_perror (vty, ret);
11259       return CMD_WARNING;
11260     }
11261
11262   return CMD_SUCCESS;
11263 }
11264
11265 static void
11266 community_list_show (struct vty *vty, struct community_list *list)
11267 {
11268   struct community_entry *entry;
11269
11270   for (entry = list->head; entry; entry = entry->next)
11271     {
11272       if (entry == list->head)
11273         {
11274           if (all_digit (list->name))
11275             vty_out (vty, "Community %s list %s%s",
11276                      entry->style == COMMUNITY_LIST_STANDARD ?
11277                      "standard" : "(expanded) access",
11278                      list->name, VTY_NEWLINE);
11279           else
11280             vty_out (vty, "Named Community %s list %s%s",
11281                      entry->style == COMMUNITY_LIST_STANDARD ?
11282                      "standard" : "expanded",
11283                      list->name, VTY_NEWLINE);
11284         }
11285       if (entry->any)
11286         vty_out (vty, "    %s%s",
11287                  community_direct_str (entry->direct), VTY_NEWLINE);
11288       else
11289         vty_out (vty, "    %s %s%s",
11290                  community_direct_str (entry->direct),
11291                  entry->style == COMMUNITY_LIST_STANDARD
11292                  ? community_str (entry->u.com) : entry->config,
11293                  VTY_NEWLINE);
11294     }
11295 }
11296
11297 DEFUN (show_ip_community_list,
11298        show_ip_community_list_cmd,
11299        "show ip community-list",
11300        SHOW_STR
11301        IP_STR
11302        "List community-list\n")
11303 {
11304   struct community_list *list;
11305   struct community_list_master *cm;
11306
11307   cm = community_list_master_lookup (bgp_clist, COMMUNITY_LIST_MASTER);
11308   if (! cm)
11309     return CMD_SUCCESS;
11310
11311   for (list = cm->num.head; list; list = list->next)
11312     community_list_show (vty, list);
11313
11314   for (list = cm->str.head; list; list = list->next)
11315     community_list_show (vty, list);
11316
11317   return CMD_SUCCESS;
11318 }
11319
11320 DEFUN (show_ip_community_list_arg,
11321        show_ip_community_list_arg_cmd,
11322        "show ip community-list <(1-500)|WORD>",
11323        SHOW_STR
11324        IP_STR
11325        "List community-list\n"
11326        "Community-list number\n"
11327        "Community-list name\n")
11328 {
11329   int idx_comm_list = 3;
11330   struct community_list *list;
11331
11332   list = community_list_lookup (bgp_clist, argv[idx_comm_list]->arg, COMMUNITY_LIST_MASTER);
11333   if (! list)
11334     {
11335       vty_out (vty, "%% Can't find community-list%s", VTY_NEWLINE);
11336       return CMD_WARNING;
11337     }
11338
11339   community_list_show (vty, list);
11340
11341   return CMD_SUCCESS;
11342 }
11343
11344 /*
11345  * Large Community code.
11346  */
11347 static int
11348 lcommunity_list_set_vty (struct vty *vty, int argc, struct cmd_token **argv,
11349                          int style, int reject_all_digit_name)
11350 {
11351   int ret;
11352   int direct;
11353   char *str;
11354   int idx = 0;
11355   char *cl_name;
11356
11357   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11358
11359   /* All digit name check.  */
11360   idx = 0;
11361   argv_find (argv, argc, "WORD", &idx);
11362   argv_find (argv, argc, "(1-99)", &idx);
11363   argv_find (argv, argc, "(100-500)", &idx);
11364   cl_name = argv[idx]->arg;
11365   if (reject_all_digit_name && all_digit (cl_name))
11366     {
11367       vty_out (vty, "%% Community name cannot have all digits%s", VTY_NEWLINE);
11368       return CMD_WARNING;
11369     }
11370
11371   argv_find (argv, argc, "AA:BB:CC", &idx);
11372   argv_find (argv, argc, "LINE", &idx);
11373   /* Concat community string argument. */
11374   if (idx)
11375     str = argv_concat (argv, argc, idx);
11376   else
11377     str = NULL;
11378
11379   ret = lcommunity_list_set (bgp_clist, cl_name, str, direct, style);
11380
11381   /* Free temporary community list string allocated by
11382      argv_concat().  */
11383   if (str)
11384     XFREE (MTYPE_TMP, str);
11385
11386   if (ret < 0)
11387     {
11388       community_list_perror (vty, ret);
11389       return CMD_WARNING;
11390     }
11391   return CMD_SUCCESS;
11392 }
11393
11394 static int
11395 lcommunity_list_unset_vty (struct vty *vty, int argc, struct cmd_token **argv,
11396                            int style)
11397 {
11398   int ret;
11399   int direct = 0;
11400   char *str = NULL;
11401   int idx = 0;
11402
11403   argv_find (argv, argc, "permit", &idx);
11404   argv_find (argv, argc, "deny", &idx);
11405
11406   if (idx)
11407     {
11408       /* Check the list direct. */
11409       if (strncmp (argv[idx]->arg, "p", 1) == 0)
11410         direct = COMMUNITY_PERMIT;
11411       else
11412         direct = COMMUNITY_DENY;
11413
11414       idx = 0;
11415       argv_find (argv, argc, "LINE", &idx);
11416       argv_find (argv, argc, "AA:AA:NN", &idx);
11417       /* Concat community string argument.  */
11418       str = argv_concat (argv, argc, idx);
11419     }
11420
11421   idx = 0;
11422   argv_find (argv, argc, "(1-99)", &idx);
11423   argv_find (argv, argc, "(100-500)", &idx);
11424   argv_find (argv, argc, "WORD", &idx);
11425
11426   /* Unset community list.  */
11427   ret = lcommunity_list_unset (bgp_clist, argv[idx]->arg, str, direct, style);
11428
11429   /* Free temporary community list string allocated by
11430      argv_concat().  */
11431   if (str)
11432     XFREE (MTYPE_TMP, str);
11433
11434   if (ret < 0)
11435     {
11436       community_list_perror (vty, ret);
11437       return CMD_WARNING;
11438     }
11439
11440   return CMD_SUCCESS;
11441 }
11442
11443 /* "large-community-list" keyword help string.  */
11444 #define LCOMMUNITY_LIST_STR "Add a large community list entry\n"
11445 #define LCOMMUNITY_VAL_STR  "large community in 'aa:bb:cc' format\n"
11446
11447 DEFUN (ip_lcommunity_list_standard,
11448        ip_lcommunity_list_standard_cmd,
11449        "ip large-community-list (1-99) <deny|permit>",
11450        IP_STR
11451        LCOMMUNITY_LIST_STR
11452        "Large Community list number (standard)\n"
11453        "Specify large community to reject\n"
11454        "Specify large community to accept\n"
11455        LCOMMUNITY_VAL_STR)
11456 {
11457   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD, 0);
11458 }
11459
11460 DEFUN (ip_lcommunity_list_standard1,
11461        ip_lcommunity_list_standard1_cmd,
11462        "ip large-community-list (1-99) <deny|permit> AA:BB:CC...",
11463        IP_STR
11464        LCOMMUNITY_LIST_STR
11465        "Large Community list number (standard)\n"
11466        "Specify large community to reject\n"
11467        "Specify large community to accept\n"
11468        LCOMMUNITY_VAL_STR)
11469 {
11470   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD, 0);
11471 }
11472
11473 DEFUN (ip_lcommunity_list_expanded,
11474        ip_lcommunity_list_expanded_cmd,
11475        "ip large-community-list (100-500) <deny|permit> LINE...",
11476        IP_STR
11477        LCOMMUNITY_LIST_STR
11478        "Large Community list number (expanded)\n"
11479        "Specify large community to reject\n"
11480        "Specify large community to accept\n"
11481        "An ordered list as a regular-expression\n")
11482 {
11483   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_EXPANDED, 0);
11484 }
11485
11486 DEFUN (ip_lcommunity_list_name_standard,
11487        ip_lcommunity_list_name_standard_cmd,
11488        "ip large-community-list standard WORD <deny|permit>",
11489        IP_STR
11490        LCOMMUNITY_LIST_STR
11491        "Specify standard large-community-list\n"
11492        "Large Community list name\n"
11493        "Specify large community to reject\n"
11494        "Specify large community to accept\n")
11495 {
11496   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD, 1);
11497 }
11498
11499 DEFUN (ip_lcommunity_list_name_standard1,
11500        ip_lcommunity_list_name_standard1_cmd,
11501        "ip large-community-list standard WORD <deny|permit> AA:BB:CC...",
11502        IP_STR
11503        LCOMMUNITY_LIST_STR
11504        "Specify standard large-community-list\n"
11505        "Large Community list name\n"
11506        "Specify large community to reject\n"
11507        "Specify large community to accept\n"
11508        LCOMMUNITY_VAL_STR)
11509 {
11510   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD, 1);
11511 }
11512
11513 DEFUN (ip_lcommunity_list_name_expanded,
11514        ip_lcommunity_list_name_expanded_cmd,
11515        "ip large-community-list expanded WORD <deny|permit> LINE...",
11516        IP_STR
11517        LCOMMUNITY_LIST_STR
11518        "Specify expanded large-community-list\n"
11519        "Large Community list name\n"
11520        "Specify large community to reject\n"
11521        "Specify large community to accept\n"
11522        "An ordered list as a regular-expression\n")
11523 {
11524   return lcommunity_list_set_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_EXPANDED, 1);
11525 }
11526
11527 DEFUN (no_ip_lcommunity_list_standard_all,
11528        no_ip_lcommunity_list_standard_all_cmd,
11529        "no ip large-community-list <(1-99)|(100-500)|WORD>",
11530        NO_STR
11531        IP_STR
11532        LCOMMUNITY_LIST_STR
11533        "Large Community list number (standard)\n"
11534        "Large Community list number (expanded)\n"
11535        "Large Community list name\n")
11536 {
11537   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD);
11538 }
11539
11540 DEFUN (no_ip_lcommunity_list_name_expanded_all,
11541        no_ip_lcommunity_list_name_expanded_all_cmd,
11542        "no ip large-community-list expanded WORD",
11543        NO_STR
11544        IP_STR
11545        LCOMMUNITY_LIST_STR
11546        "Specify expanded large-community-list\n"
11547        "Large Community list name\n")
11548 {
11549   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_EXPANDED);
11550 }
11551
11552 DEFUN (no_ip_lcommunity_list_standard,
11553        no_ip_lcommunity_list_standard_cmd,
11554        "no ip large-community-list (1-99) <deny|permit> AA:AA:NN...",
11555        NO_STR
11556        IP_STR
11557        LCOMMUNITY_LIST_STR
11558        "Large Community list number (standard)\n"
11559        "Specify large community to reject\n"
11560        "Specify large community to accept\n"
11561        LCOMMUNITY_VAL_STR)
11562 {
11563   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD);
11564 }
11565
11566 DEFUN (no_ip_lcommunity_list_expanded,
11567        no_ip_lcommunity_list_expanded_cmd,
11568        "no ip large-community-list (100-500) <deny|permit> LINE...",
11569        NO_STR
11570        IP_STR
11571        LCOMMUNITY_LIST_STR
11572        "Large Community list number (expanded)\n"
11573        "Specify large community to reject\n"
11574        "Specify large community to accept\n"
11575        "An ordered list as a regular-expression\n")
11576 {
11577   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_EXPANDED);
11578 }
11579
11580 DEFUN (no_ip_lcommunity_list_name_standard,
11581        no_ip_lcommunity_list_name_standard_cmd,
11582        "no ip large-community-list standard WORD <deny|permit> AA:AA:NN...",
11583        NO_STR
11584        IP_STR
11585        LCOMMUNITY_LIST_STR
11586        "Specify standard large-community-list\n"
11587        "Large Community list name\n"
11588        "Specify large community to reject\n"
11589        "Specify large community to accept\n"
11590        LCOMMUNITY_VAL_STR)
11591 {
11592   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_STANDARD);
11593 }
11594
11595 DEFUN (no_ip_lcommunity_list_name_expanded,
11596        no_ip_lcommunity_list_name_expanded_cmd,
11597        "no ip large-community-list expanded WORD <deny|permit> LINE...",
11598        NO_STR
11599        IP_STR
11600        LCOMMUNITY_LIST_STR
11601        "Specify expanded large-community-list\n"
11602        "Large community list name\n"
11603        "Specify large community to reject\n"
11604        "Specify large community to accept\n"
11605        "An ordered list as a regular-expression\n")
11606 {
11607   return lcommunity_list_unset_vty (vty, argc, argv, LARGE_COMMUNITY_LIST_EXPANDED);
11608 }
11609
11610 static void
11611 lcommunity_list_show (struct vty *vty, struct community_list *list)
11612 {
11613   struct community_entry *entry;
11614
11615   for (entry = list->head; entry; entry = entry->next)
11616     {
11617       if (entry == list->head)
11618         {
11619           if (all_digit (list->name))
11620             vty_out (vty, "Large community %s list %s%s",
11621                      entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11622                      "standard" : "(expanded) access",
11623                      list->name, VTY_NEWLINE);
11624           else
11625             vty_out (vty, "Named large community %s list %s%s",
11626                      entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11627                      "standard" : "expanded",
11628                      list->name, VTY_NEWLINE);
11629         }
11630       if (entry->any)
11631         vty_out (vty, "    %s%s",
11632                  community_direct_str (entry->direct), VTY_NEWLINE);
11633       else
11634         vty_out (vty, "    %s %s%s",
11635                  community_direct_str (entry->direct),
11636                  entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11637                  entry->u.ecom->str : entry->config,
11638                  VTY_NEWLINE);
11639     }
11640 }
11641
11642 DEFUN (show_ip_lcommunity_list,
11643        show_ip_lcommunity_list_cmd,
11644        "show ip large-community-list",
11645        SHOW_STR
11646        IP_STR
11647        "List large-community list\n")
11648 {
11649   struct community_list *list;
11650   struct community_list_master *cm;
11651
11652   cm = community_list_master_lookup (bgp_clist, LARGE_COMMUNITY_LIST_MASTER);
11653   if (! cm)
11654     return CMD_SUCCESS;
11655
11656   for (list = cm->num.head; list; list = list->next)
11657     lcommunity_list_show (vty, list);
11658
11659   for (list = cm->str.head; list; list = list->next)
11660     lcommunity_list_show (vty, list);
11661
11662   return CMD_SUCCESS;
11663 }
11664
11665 DEFUN (show_ip_lcommunity_list_arg,
11666        show_ip_lcommunity_list_arg_cmd,
11667        "show ip large-community-list <(1-500)|WORD>",
11668        SHOW_STR
11669        IP_STR
11670        "List large-community list\n"
11671        "large-community-list number\n"
11672        "large-community-list name\n")
11673 {
11674   struct community_list *list;
11675
11676   list = community_list_lookup (bgp_clist, argv[3]->arg, LARGE_COMMUNITY_LIST_MASTER);
11677   if (! list)
11678     {
11679       vty_out (vty, "%% Can't find extcommunity-list%s", VTY_NEWLINE);
11680       return CMD_WARNING;
11681     }
11682
11683   lcommunity_list_show (vty, list);
11684
11685   return CMD_SUCCESS;
11686 }
11687
11688 /* "extcommunity-list" keyword help string.  */
11689 #define EXTCOMMUNITY_LIST_STR "Add a extended community list entry\n"
11690 #define EXTCOMMUNITY_VAL_STR  "Extended community attribute in 'rt aa:nn_or_IPaddr:nn' OR 'soo aa:nn_or_IPaddr:nn' format\n"
11691
11692 DEFUN (ip_extcommunity_list_standard,
11693        ip_extcommunity_list_standard_cmd,
11694        "ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
11695        IP_STR
11696        EXTCOMMUNITY_LIST_STR
11697        "Extended Community list number (standard)\n"
11698        "Specify standard extcommunity-list\n"
11699        "Community list name\n"
11700        "Specify community to reject\n"
11701        "Specify community to accept\n"
11702        EXTCOMMUNITY_VAL_STR)
11703 {
11704   int style = EXTCOMMUNITY_LIST_STANDARD;
11705   int direct = 0;
11706   char *cl_number_or_name = NULL;
11707
11708   int idx = 0;
11709   argv_find (argv, argc, "(1-99)", &idx);
11710   argv_find (argv, argc, "WORD", &idx);
11711   cl_number_or_name = argv[idx]->arg;
11712   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11713   argv_find (argv, argc, "AA:NN", &idx);
11714   char *str = argv_concat (argv, argc, idx);
11715
11716   int ret = extcommunity_list_set (bgp_clist, cl_number_or_name, str, direct, style);
11717
11718   XFREE (MTYPE_TMP, str);
11719
11720   if (ret < 0)
11721     {
11722       community_list_perror (vty, ret);
11723       return CMD_WARNING;
11724     }
11725
11726   return CMD_SUCCESS;
11727 }
11728
11729 DEFUN (ip_extcommunity_list_name_expanded,
11730        ip_extcommunity_list_name_expanded_cmd,
11731        "ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
11732        IP_STR
11733        EXTCOMMUNITY_LIST_STR
11734        "Extended Community list number (expanded)\n"
11735        "Specify expanded extcommunity-list\n"
11736        "Extended Community list name\n"
11737        "Specify community to reject\n"
11738        "Specify community to accept\n"
11739        "An ordered list as a regular-expression\n")
11740 {
11741   int style = EXTCOMMUNITY_LIST_EXPANDED;
11742   int direct = 0;
11743   char *cl_number_or_name = NULL;
11744
11745   int idx = 0;
11746   argv_find (argv, argc, "(100-500)", &idx);
11747   argv_find (argv, argc, "WORD", &idx);
11748   cl_number_or_name = argv[idx]->arg;
11749   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11750   argv_find (argv, argc, "LINE", &idx);
11751   char *str = argv_concat (argv, argc, idx);
11752
11753   int ret = extcommunity_list_set (bgp_clist, cl_number_or_name, str, direct, style);
11754
11755   XFREE (MTYPE_TMP, str);
11756
11757   if (ret < 0)
11758     {
11759       community_list_perror (vty, ret);
11760       return CMD_WARNING;
11761     }
11762
11763   return CMD_SUCCESS;
11764 }
11765
11766 DEFUN (no_ip_extcommunity_list_standard_all,
11767        no_ip_extcommunity_list_standard_all_cmd,
11768        "no ip extcommunity-list <(1-99)|standard WORD> <deny|permit> AA:NN...",
11769        NO_STR
11770        IP_STR
11771        EXTCOMMUNITY_LIST_STR
11772        "Extended Community list number (standard)\n"
11773        "Specify standard extcommunity-list\n"
11774        "Community list name\n"
11775        "Specify community to reject\n"
11776        "Specify community to accept\n"
11777        EXTCOMMUNITY_VAL_STR)
11778 {
11779   int deleteall = 0;
11780
11781   int style = EXTCOMMUNITY_LIST_STANDARD;
11782   int direct = 0;
11783   char *cl_number_or_name = NULL;
11784
11785   int idx = 0;
11786   argv_find (argv, argc, "(1-99)", &idx);
11787   argv_find (argv, argc, "WORD", &idx);
11788   cl_number_or_name = argv[idx]->arg;
11789   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11790   argv_find (argv, argc, "AA:NN", &idx);
11791   char *str = argv_concat (argv, argc, idx);
11792
11793   int ret = extcommunity_list_unset (bgp_clist, cl_number_or_name, str, direct, style, deleteall);
11794
11795   XFREE (MTYPE_TMP, str);
11796
11797   if (ret < 0)
11798     {
11799       community_list_perror (vty, ret);
11800       return CMD_WARNING;
11801     }
11802
11803   return CMD_SUCCESS;
11804 }
11805
11806 DEFUN (no_ip_extcommunity_list_expanded_all,
11807        no_ip_extcommunity_list_expanded_all_cmd,
11808        "no ip extcommunity-list <(100-500)|expanded WORD> <deny|permit> LINE...",
11809        NO_STR
11810        IP_STR
11811        EXTCOMMUNITY_LIST_STR
11812        "Extended Community list number (expanded)\n"
11813        "Specify expanded extcommunity-list\n"
11814        "Extended Community list name\n"
11815        "Specify community to reject\n"
11816        "Specify community to accept\n"
11817        "An ordered list as a regular-expression\n")
11818 {
11819   int deleteall = 0;
11820
11821   int style = EXTCOMMUNITY_LIST_EXPANDED;
11822   int direct = 0;
11823   char *cl_number_or_name = NULL;
11824
11825   int idx = 0;
11826   argv_find (argv, argc, "(100-500)", &idx);
11827   argv_find (argv, argc, "WORD", &idx);
11828   cl_number_or_name = argv[idx]->arg;
11829   direct = argv_find (argv, argc, "permit", &idx) ? COMMUNITY_PERMIT : COMMUNITY_DENY;
11830   argv_find (argv, argc, "LINE", &idx);
11831   char *str = argv_concat (argv, argc, idx);
11832
11833   int ret = extcommunity_list_unset (bgp_clist, cl_number_or_name, str, direct, style, deleteall);
11834
11835   XFREE (MTYPE_TMP, str);
11836
11837   if (ret < 0)
11838     {
11839       community_list_perror (vty, ret);
11840       return CMD_WARNING;
11841     }
11842
11843   return CMD_SUCCESS;
11844 }
11845
11846 static void
11847 extcommunity_list_show (struct vty *vty, struct community_list *list)
11848 {
11849   struct community_entry *entry;
11850
11851   for (entry = list->head; entry; entry = entry->next)
11852     {
11853       if (entry == list->head)
11854         {
11855           if (all_digit (list->name))
11856             vty_out (vty, "Extended community %s list %s%s",
11857                      entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11858                      "standard" : "(expanded) access",
11859                      list->name, VTY_NEWLINE);
11860           else
11861             vty_out (vty, "Named extended community %s list %s%s",
11862                      entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11863                      "standard" : "expanded",
11864                      list->name, VTY_NEWLINE);
11865         }
11866       if (entry->any)
11867         vty_out (vty, "    %s%s",
11868                  community_direct_str (entry->direct), VTY_NEWLINE);
11869       else
11870         vty_out (vty, "    %s %s%s",
11871                  community_direct_str (entry->direct),
11872                  entry->style == EXTCOMMUNITY_LIST_STANDARD ?
11873                  entry->u.ecom->str : entry->config,
11874                  VTY_NEWLINE);
11875     }
11876 }
11877
11878 DEFUN (show_ip_extcommunity_list,
11879        show_ip_extcommunity_list_cmd,
11880        "show ip extcommunity-list",
11881        SHOW_STR
11882        IP_STR
11883        "List extended-community list\n")
11884 {
11885   struct community_list *list;
11886   struct community_list_master *cm;
11887
11888   cm = community_list_master_lookup (bgp_clist, EXTCOMMUNITY_LIST_MASTER);
11889   if (! cm)
11890     return CMD_SUCCESS;
11891
11892   for (list = cm->num.head; list; list = list->next)
11893     extcommunity_list_show (vty, list);
11894
11895   for (list = cm->str.head; list; list = list->next)
11896     extcommunity_list_show (vty, list);
11897
11898   return CMD_SUCCESS;
11899 }
11900
11901 DEFUN (show_ip_extcommunity_list_arg,
11902        show_ip_extcommunity_list_arg_cmd,
11903        "show ip extcommunity-list <(1-500)|WORD>",
11904        SHOW_STR
11905        IP_STR
11906        "List extended-community list\n"
11907        "Extcommunity-list number\n"
11908        "Extcommunity-list name\n")
11909 {
11910   int idx_comm_list = 3;
11911   struct community_list *list;
11912
11913   list = community_list_lookup (bgp_clist, argv[idx_comm_list]->arg, EXTCOMMUNITY_LIST_MASTER);
11914   if (! list)
11915     {
11916       vty_out (vty, "%% Can't find extcommunity-list%s", VTY_NEWLINE);
11917       return CMD_WARNING;
11918     }
11919
11920   extcommunity_list_show (vty, list);
11921
11922   return CMD_SUCCESS;
11923 }
11924
11925 /* Return configuration string of community-list entry.  */
11926 static const char *
11927 community_list_config_str (struct community_entry *entry)
11928 {
11929   const char *str;
11930
11931   if (entry->any)
11932     str = "";
11933   else
11934     {
11935       if (entry->style == COMMUNITY_LIST_STANDARD)
11936         str = community_str (entry->u.com);
11937       else
11938         str = entry->config;
11939     }
11940   return str;
11941 }
11942
11943 /* Display community-list and extcommunity-list configuration.  */
11944 static int
11945 community_list_config_write (struct vty *vty)
11946 {
11947   struct community_list *list;
11948   struct community_entry *entry;
11949   struct community_list_master *cm;
11950   int write = 0;
11951
11952   /* Community-list.  */
11953   cm = community_list_master_lookup (bgp_clist, COMMUNITY_LIST_MASTER);
11954
11955   for (list = cm->num.head; list; list = list->next)
11956     for (entry = list->head; entry; entry = entry->next)
11957       {
11958         vty_out (vty, "ip community-list %s %s %s%s",
11959                  list->name, community_direct_str (entry->direct),
11960                  community_list_config_str (entry),
11961                  VTY_NEWLINE);
11962         write++;
11963       }
11964   for (list = cm->str.head; list; list = list->next)
11965     for (entry = list->head; entry; entry = entry->next)
11966       {
11967         vty_out (vty, "ip community-list %s %s %s %s%s",
11968                  entry->style == COMMUNITY_LIST_STANDARD
11969                  ? "standard" : "expanded",
11970                  list->name, community_direct_str (entry->direct),
11971                  community_list_config_str (entry),
11972                  VTY_NEWLINE);
11973         write++;
11974       }
11975
11976   /* Extcommunity-list.  */
11977   cm = community_list_master_lookup (bgp_clist, EXTCOMMUNITY_LIST_MASTER);
11978
11979   for (list = cm->num.head; list; list = list->next)
11980     for (entry = list->head; entry; entry = entry->next)
11981       {
11982         vty_out (vty, "ip extcommunity-list %s %s %s%s",
11983                  list->name, community_direct_str (entry->direct),
11984                  community_list_config_str (entry), VTY_NEWLINE);
11985         write++;
11986       }
11987   for (list = cm->str.head; list; list = list->next)
11988     for (entry = list->head; entry; entry = entry->next)
11989       {
11990         vty_out (vty, "ip extcommunity-list %s %s %s %s%s",
11991                  entry->style == EXTCOMMUNITY_LIST_STANDARD
11992                  ? "standard" : "expanded",
11993                  list->name, community_direct_str (entry->direct),
11994                  community_list_config_str (entry), VTY_NEWLINE);
11995         write++;
11996       }
11997
11998
11999     /* lcommunity-list.  */
12000   cm = community_list_master_lookup (bgp_clist, LARGE_COMMUNITY_LIST_MASTER);
12001
12002   for (list = cm->num.head; list; list = list->next)
12003     for (entry = list->head; entry; entry = entry->next)
12004       {
12005         vty_out (vty, "ip large-community-list %s %s %s%s",
12006                  list->name, community_direct_str (entry->direct),
12007                  community_list_config_str (entry), VTY_NEWLINE);
12008         write++;
12009       }
12010   for (list = cm->str.head; list; list = list->next)
12011     for (entry = list->head; entry; entry = entry->next)
12012       {
12013         vty_out (vty, "ip large-community-list %s %s %s %s%s",
12014                  entry->style == LARGE_COMMUNITY_LIST_STANDARD
12015                  ? "standard" : "expanded",
12016                  list->name, community_direct_str (entry->direct),
12017                  community_list_config_str (entry), VTY_NEWLINE);
12018         write++;
12019       }
12020
12021   return write;
12022 }
12023
12024 static struct cmd_node community_list_node =
12025 {
12026   COMMUNITY_LIST_NODE,
12027   "",
12028   1                             /* Export to vtysh.  */
12029 };
12030
12031 static void
12032 community_list_vty (void)
12033 {
12034   install_node (&community_list_node, community_list_config_write);
12035
12036   /* Community-list.  */
12037   install_element (CONFIG_NODE, &ip_community_list_standard_cmd);
12038   install_element (CONFIG_NODE, &ip_community_list_expanded_all_cmd);
12039   install_element (CONFIG_NODE, &no_ip_community_list_standard_all_cmd);
12040   install_element (CONFIG_NODE, &no_ip_community_list_expanded_all_cmd);
12041   install_element (VIEW_NODE, &show_ip_community_list_cmd);
12042   install_element (VIEW_NODE, &show_ip_community_list_arg_cmd);
12043
12044   /* Extcommunity-list.  */
12045   install_element (CONFIG_NODE, &ip_extcommunity_list_standard_cmd);
12046   install_element (CONFIG_NODE, &ip_extcommunity_list_name_expanded_cmd);
12047   install_element (CONFIG_NODE, &no_ip_extcommunity_list_standard_all_cmd);
12048   install_element (CONFIG_NODE, &no_ip_extcommunity_list_expanded_all_cmd);
12049   install_element (VIEW_NODE, &show_ip_extcommunity_list_cmd);
12050   install_element (VIEW_NODE, &show_ip_extcommunity_list_arg_cmd);
12051
12052   /* Large Community List */
12053   install_element (CONFIG_NODE, &ip_lcommunity_list_standard_cmd);
12054   install_element (CONFIG_NODE, &ip_lcommunity_list_standard1_cmd);
12055   install_element (CONFIG_NODE, &ip_lcommunity_list_expanded_cmd);
12056   install_element (CONFIG_NODE, &ip_lcommunity_list_name_standard_cmd);
12057   install_element (CONFIG_NODE, &ip_lcommunity_list_name_standard1_cmd);
12058   install_element (CONFIG_NODE, &ip_lcommunity_list_name_expanded_cmd);
12059   install_element (CONFIG_NODE, &no_ip_lcommunity_list_standard_all_cmd);
12060   install_element (CONFIG_NODE, &no_ip_lcommunity_list_name_expanded_all_cmd);
12061   install_element (CONFIG_NODE, &no_ip_lcommunity_list_standard_cmd);
12062   install_element (CONFIG_NODE, &no_ip_lcommunity_list_expanded_cmd);
12063   install_element (CONFIG_NODE, &no_ip_lcommunity_list_name_standard_cmd);
12064   install_element (CONFIG_NODE, &no_ip_lcommunity_list_name_expanded_cmd);
12065   install_element (VIEW_NODE, &show_ip_lcommunity_list_cmd);
12066   install_element (VIEW_NODE, &show_ip_lcommunity_list_arg_cmd);
12067 }