[mirror_frr.git] / bgpd / bgp_mplsvpn.c

/* MPLS-VPN
   Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>

This file is part of GNU Zebra.

GNU Zebra is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

GNU Zebra is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Zebra; see the file COPYING.  If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include <zebra.h>

#include "command.h"
#include "prefix.h"
#include "log.h"
#include "memory.h"
#include "stream.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_mplsvpn.h"

static u_int16_t
decode_rd_type (u_char *pnt)
{
  u_int16_t v;
  
  v = ((u_int16_t) *pnt++ << 8);
  v |= (u_int16_t) *pnt;
  return v;
}

u_int32_t
decode_label (u_char *pnt)
{
  u_int32_t l;

  l = ((u_int32_t) *pnt++ << 12);
  l |= (u_int32_t) *pnt++ << 4;
  l |= (u_int32_t) ((*pnt & 0xf0) >> 4);
  return l;
}

static void
decode_rd_as (u_char *pnt, struct rd_as *rd_as)
{
  rd_as->as = (u_int16_t) *pnt++ << 8;
  rd_as->as |= (u_int16_t) *pnt++;
  
  rd_as->val = ((u_int32_t) *pnt++ << 24);
  rd_as->val |= ((u_int32_t) *pnt++ << 16);
  rd_as->val |= ((u_int32_t) *pnt++ << 8);
  rd_as->val |= (u_int32_t) *pnt;
}

static void
decode_rd_ip (u_char *pnt, struct rd_ip *rd_ip)
{
  memcpy (&rd_ip->ip, pnt, 4);
  pnt += 4;
  
  rd_ip->val = ((u_int16_t) *pnt++ << 8);
  rd_ip->val |= (u_int16_t) *pnt;
}

int
bgp_nlri_parse_vpnv4 (struct peer *peer, struct attr *attr, 
		      struct bgp_nlri *packet)
{
  u_char *pnt;
  u_char *lim;
  struct prefix p;
  int psize;
  int prefixlen;
  u_int32_t label;
  u_int16_t type;
  struct rd_as rd_as;
  struct rd_ip rd_ip;
  struct prefix_rd prd;
  u_char *tagpnt;

  /* Check peer status. */
  if (peer->status != Established)
    return 0;
  
  /* Make prefix_rd */
  prd.family = AF_UNSPEC;
  prd.prefixlen = 64;

  pnt = packet->nlri;
  lim = pnt + packet->length;

  for (; pnt < lim; pnt += psize)
    {
      /* Clear prefix structure. */
      memset (&p, 0, sizeof (struct prefix));

      /* Fetch prefix length. */
      prefixlen = *pnt++;
      p.family = AF_INET;
      psize = PSIZE (prefixlen);

      if (prefixlen < 88)
	{
	  zlog_err ("prefix length is less than 88: %d", prefixlen);
	  return -1;
	}

      label = decode_label (pnt);

      /* Copyr label to prefix. */
      tagpnt = pnt;;

      /* Copy routing distinguisher to rd. */
      memcpy (&prd.val, pnt + 3, 8);

      /* Decode RD type. */
      type = decode_rd_type (pnt + 3);

      /* Decode RD value. */
      if (type == RD_TYPE_AS)
	decode_rd_as (pnt + 5, &rd_as);
      else if (type == RD_TYPE_IP)
	decode_rd_ip (pnt + 5, &rd_ip);
      else
	{
	  zlog_err ("Invalid RD type %d", type);
	  return -1;
	}

      p.prefixlen = prefixlen - 88;
      memcpy (&p.u.prefix, pnt + 11, psize - 11);

#if 0
      if (type == RD_TYPE_AS)
	zlog_info ("prefix %ld:%ld:%ld:%s/%d", label, rd_as.as, rd_as.val,
		   inet_ntoa (p.u.prefix4), p.prefixlen);
      else if (type == RD_TYPE_IP)
	zlog_info ("prefix %ld:%s:%ld:%s/%d", label, inet_ntoa (rd_ip.ip),
		   rd_ip.val, inet_ntoa (p.u.prefix4), p.prefixlen);
#endif /* 0 */

      if (pnt + psize > lim)
	return -1;

      if (attr)
	bgp_update (peer, &p, attr, AFI_IP, SAFI_MPLS_VPN,
		    ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, tagpnt, 0);
      else
	bgp_withdraw (peer, &p, attr, AFI_IP, SAFI_MPLS_VPN,
		      ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, tagpnt);
    }

  /* Packet length consistency check. */
  if (pnt != lim)
    return -1;

  return 0;
}

int
str2prefix_rd (const char *str, struct prefix_rd *prd)
{
  int ret;
  char *p;
  char *p2;
  struct stream *s;
  char *half;
  struct in_addr addr;

  s = stream_new (8);

  prd->family = AF_UNSPEC;
  prd->prefixlen = 64;

  p = strchr (str, ':');
  if (! p)
    return 0;

  if (! all_digit (p + 1))
    return 0;

  half = XMALLOC (MTYPE_TMP, (p - str) + 1);
  memcpy (half, str, (p - str));
  half[p - str] = '\0';

  p2 = strchr (str, '.');

  if (! p2)
    {
      if (! all_digit (half))
	{
	  XFREE (MTYPE_TMP, half);
	  return 0;
	}
      stream_putw (s, RD_TYPE_AS);
      stream_putw (s, atoi (half));
      stream_putl (s, atol (p + 1));
    }
  else
    {
      ret = inet_aton (half, &addr);
      if (! ret)
	{
	  XFREE (MTYPE_TMP, half);
	  return 0;
	}
      stream_putw (s, RD_TYPE_IP);
      stream_put_in_addr (s, &addr);
      stream_putw (s, atol (p + 1));
    }
  memcpy (prd->val, s->data, 8);

  return 1;
}

int
str2tag (const char *str, u_char *tag)
{
  unsigned long l;
  char *endptr;
  u_int32_t t;

  l = strtoul (str, &endptr, 10);
  
  if (*endptr == '\0' || l == ULONG_MAX || l > UINT32_MAX)
    return 0;

  t = (u_int32_t) l;
  
  tag[0] = (u_char)(t >> 12);
  tag[1] = (u_char)(t >> 4);
  tag[2] = (u_char)(t << 4);

  return 1;
}

char *
prefix_rd2str (struct prefix_rd *prd, char *buf, size_t size)
{
  u_char *pnt;
  u_int16_t type;
  struct rd_as rd_as;
  struct rd_ip rd_ip;

  if (size < RD_ADDRSTRLEN)
    return NULL;

  pnt = prd->val;

  type = decode_rd_type (pnt);

  if (type == RD_TYPE_AS)
    {
      decode_rd_as (pnt + 2, &rd_as);
      snprintf (buf, size, "%u:%d", rd_as.as, rd_as.val);
      return buf;
    }
  else if (type == RD_TYPE_IP)
    {
      decode_rd_ip (pnt + 2, &rd_ip);
      snprintf (buf, size, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);
      return buf;
    }

  return NULL;
}

/* For testing purpose, static route of MPLS-VPN. */
DEFUN (vpnv4_network,
       vpnv4_network_cmd,
       "network A.B.C.D/M rd ASN:nn_or_IP-address:nn tag WORD",
       "Specify a network to announce via BGP\n"
       "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
       "Specify Route Distinguisher\n"
       "VPN Route Distinguisher\n"
       "BGP tag\n"
       "tag value\n")
{
  return bgp_static_set_vpnv4 (vty, argv[0], argv[1], argv[2]);
}

/* For testing purpose, static route of MPLS-VPN. */
DEFUN (no_vpnv4_network,
       no_vpnv4_network_cmd,
       "no network A.B.C.D/M rd ASN:nn_or_IP-address:nn tag WORD",
       NO_STR
       "Specify a network to announce via BGP\n"
       "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
       "Specify Route Distinguisher\n"
       "VPN Route Distinguisher\n"
       "BGP tag\n"
       "tag value\n")
{
  return bgp_static_unset_vpnv4 (vty, argv[0], argv[1], argv[2]);
}

static int
show_adj_route_vpn (struct vty *vty, struct peer *peer, struct prefix_rd *prd)
{
  struct bgp *bgp;
  struct bgp_table *table;
  struct bgp_node *rn;
  struct bgp_node *rm;
  struct attr *attr;
  int rd_header;
  int header = 1;
  char v4_header[] = "   Network          Next Hop            Metric LocPrf Weight Path%s";

  bgp = bgp_get_default ();
  if (bgp == NULL)
    {
      vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  for (rn = bgp_table_top (bgp->rib[AFI_IP][SAFI_MPLS_VPN]); rn;
       rn = bgp_route_next (rn))
    {
      if (prd && memcmp (rn->p.u.val, prd->val, 8) != 0)
        continue;

      if ((table = rn->info) != NULL)
        {
          rd_header = 1;

          for (rm = bgp_table_top (table); rm; rm = bgp_route_next (rm))
            if ((attr = rm->info) != NULL)
              {
                if (header)
                  {
                    vty_out (vty, "BGP table version is 0, local router ID is %s%s",
                             inet_ntoa (bgp->router_id), VTY_NEWLINE);
                    vty_out (vty, "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal%s",
                             VTY_NEWLINE);
                    vty_out (vty, "Origin codes: i - IGP, e - EGP, ? - incomplete%s%s",
                             VTY_NEWLINE, VTY_NEWLINE);
                    vty_out (vty, v4_header, VTY_NEWLINE);
                    header = 0;
                  }

                if (rd_header)
                  {
                    u_int16_t type;
                    struct rd_as rd_as;
                    struct rd_ip rd_ip;
                    u_char *pnt;

                    pnt = rn->p.u.val;

                    /* Decode RD type. */
                    type = decode_rd_type (pnt);
                    /* Decode RD value. */
                    if (type == RD_TYPE_AS)
                      decode_rd_as (pnt + 2, &rd_as);
                    else if (type == RD_TYPE_IP)
                      decode_rd_ip (pnt + 2, &rd_ip);

                    vty_out (vty, "Route Distinguisher: ");

                    if (type == RD_TYPE_AS)
                      vty_out (vty, "%u:%d", rd_as.as, rd_as.val);
                    else if (type == RD_TYPE_IP)
                      vty_out (vty, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);

                    vty_out (vty, "%s", VTY_NEWLINE);
                    rd_header = 0;
                  }
                route_vty_out_tmp (vty, &rm->p, attr, SAFI_MPLS_VPN);
              }
        }
    }
  return CMD_SUCCESS;
}

enum bgp_show_type
{
  bgp_show_type_normal,
  bgp_show_type_regexp,
  bgp_show_type_prefix_list,
  bgp_show_type_filter_list,
  bgp_show_type_neighbor,
  bgp_show_type_cidr_only,
  bgp_show_type_prefix_longer,
  bgp_show_type_community_all,
  bgp_show_type_community,
  bgp_show_type_community_exact,
  bgp_show_type_community_list,
  bgp_show_type_community_list_exact
};

static int
bgp_show_mpls_vpn (struct vty *vty, struct prefix_rd *prd, enum bgp_show_type type,
		   void *output_arg, int tags)
{
  struct bgp *bgp;
  struct bgp_table *table;
  struct bgp_node *rn;
  struct bgp_node *rm;
  struct bgp_info *ri;
  int rd_header;
  int header = 1;
  char v4_header[] = "   Network          Next Hop            Metric LocPrf Weight Path%s";
  char v4_header_tag[] = "   Network          Next Hop      In tag/Out tag%s";

  bgp = bgp_get_default ();
  if (bgp == NULL)
    {
      vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE);
      return CMD_WARNING;
    }
  
  for (rn = bgp_table_top (bgp->rib[AFI_IP][SAFI_MPLS_VPN]); rn; rn = bgp_route_next (rn))
    {
      if (prd && memcmp (rn->p.u.val, prd->val, 8) != 0)
	continue;

      if ((table = rn->info) != NULL)
	{
	  rd_header = 1;

	  for (rm = bgp_table_top (table); rm; rm = bgp_route_next (rm))
	    for (ri = rm->info; ri; ri = ri->next)
	      {
		if (type == bgp_show_type_neighbor)
		  {
		    union sockunion *su = output_arg;

		    if (ri->peer->su_remote == NULL || ! sockunion_same(ri->peer->su_remote, su))
		      continue;
		  }
		if (header)
		  {
		    if (tags)
		      vty_out (vty, v4_header_tag, VTY_NEWLINE);
		    else
		      {
			vty_out (vty, "BGP table version is 0, local router ID is %s%s",
				 inet_ntoa (bgp->router_id), VTY_NEWLINE);
			vty_out (vty, "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal%s",
				 VTY_NEWLINE);
			vty_out (vty, "Origin codes: i - IGP, e - EGP, ? - incomplete%s%s",
				 VTY_NEWLINE, VTY_NEWLINE);
			vty_out (vty, v4_header, VTY_NEWLINE);
		      }
		    header = 0;
		  }

		if (rd_header)
		  {
		    u_int16_t type;
		    struct rd_as rd_as;
		    struct rd_ip rd_ip;
		    u_char *pnt;

		    pnt = rn->p.u.val;

		    /* Decode RD type. */
		    type = decode_rd_type (pnt);
		    /* Decode RD value. */
		    if (type == RD_TYPE_AS)
		      decode_rd_as (pnt + 2, &rd_as);
		    else if (type == RD_TYPE_IP)
		      decode_rd_ip (pnt + 2, &rd_ip);

		    vty_out (vty, "Route Distinguisher: ");

		    if (type == RD_TYPE_AS)
		      vty_out (vty, "%u:%d", rd_as.as, rd_as.val);
		    else if (type == RD_TYPE_IP)
		      vty_out (vty, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);
		  
		    vty_out (vty, "%s", VTY_NEWLINE);		  
		    rd_header = 0;
		  }
	        if (tags)
		  route_vty_out_tag (vty, &rm->p, ri, 0, SAFI_MPLS_VPN);
	        else
		  route_vty_out (vty, &rm->p, ri, 0, SAFI_MPLS_VPN);
	      }
        }
    }
  return CMD_SUCCESS;
}

DEFUN (show_ip_bgp_vpnv4_all,
       show_ip_bgp_vpnv4_all_cmd,
       "show ip bgp vpnv4 all",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information about all VPNv4 NLRIs\n")
{
  return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_normal, NULL, 0);
}

DEFUN (show_ip_bgp_vpnv4_rd,
       show_ip_bgp_vpnv4_rd_cmd,
       "show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information for a route distinguisher\n"
       "VPN Route Distinguisher\n")
{
  int ret;
  struct prefix_rd prd;

  ret = str2prefix_rd (argv[0], &prd);
  if (! ret)
    {
      vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
      return CMD_WARNING;
    }
  return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_normal, NULL, 0);
}

DEFUN (show_ip_bgp_vpnv4_all_tags,
       show_ip_bgp_vpnv4_all_tags_cmd,
       "show ip bgp vpnv4 all tags",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information about all VPNv4 NLRIs\n"
       "Display BGP tags for prefixes\n")
{
  return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_normal, NULL,  1);
}

DEFUN (show_ip_bgp_vpnv4_rd_tags,
       show_ip_bgp_vpnv4_rd_tags_cmd,
       "show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn tags",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information for a route distinguisher\n"
       "VPN Route Distinguisher\n"
       "Display BGP tags for prefixes\n")
{
  int ret;
  struct prefix_rd prd;

  ret = str2prefix_rd (argv[0], &prd);
  if (! ret)
    {
      vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
      return CMD_WARNING;
    }
  return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_normal, NULL, 1);
}

DEFUN (show_ip_bgp_vpnv4_all_neighbor_routes,
       show_ip_bgp_vpnv4_all_neighbor_routes_cmd,
       "show ip bgp vpnv4 all neighbors A.B.C.D routes",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information about all VPNv4 NLRIs\n"
       "Detailed information on TCP and BGP neighbor connections\n"
       "Neighbor to display information about\n"
       "Display routes learned from neighbor\n")
{
  union sockunion *su;
  struct peer *peer;
  
  su = sockunion_str2su (argv[0]);
  if (su == NULL)
    {
      vty_out (vty, "Malformed address: %s%s", argv[0], VTY_NEWLINE);
               return CMD_WARNING;
    }

  peer = peer_lookup (NULL, su);
  if (! peer || ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
    {
      vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_neighbor, su, 0);
}

DEFUN (show_ip_bgp_vpnv4_rd_neighbor_routes,
       show_ip_bgp_vpnv4_rd_neighbor_routes_cmd,
       "show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn neighbors A.B.C.D routes",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information for a route distinguisher\n"
       "VPN Route Distinguisher\n"
       "Detailed information on TCP and BGP neighbor connections\n"
       "Neighbor to display information about\n"
       "Display routes learned from neighbor\n")
{
  int ret;
  union sockunion *su;
  struct peer *peer;
  struct prefix_rd prd;

  ret = str2prefix_rd (argv[0], &prd);
  if (! ret)
    {
      vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  su = sockunion_str2su (argv[1]);
  if (su == NULL)
    {
      vty_out (vty, "Malformed address: %s%s", argv[0], VTY_NEWLINE);
               return CMD_WARNING;
    }

  peer = peer_lookup (NULL, su);
  if (! peer || ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
    {
      vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_neighbor, su, 0);
}

DEFUN (show_ip_bgp_vpnv4_all_neighbor_advertised_routes,
       show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd,
       "show ip bgp vpnv4 all neighbors A.B.C.D advertised-routes",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information about all VPNv4 NLRIs\n"
       "Detailed information on TCP and BGP neighbor connections\n"
       "Neighbor to display information about\n"
       "Display the routes advertised to a BGP neighbor\n")
{
  int ret;
  struct peer *peer;
  union sockunion su;

  ret = str2sockunion (argv[0], &su);
  if (ret < 0)
    {
      vty_out (vty, "%% Malformed address: %s%s", argv[0], VTY_NEWLINE);
      return CMD_WARNING;
    }
  peer = peer_lookup (NULL, &su);
  if (! peer || ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
    {
      vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  return show_adj_route_vpn (vty, peer, NULL);
}

DEFUN (show_ip_bgp_vpnv4_rd_neighbor_advertised_routes,
       show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd,
       "show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn neighbors A.B.C.D advertised-routes",
       SHOW_STR
       IP_STR
       BGP_STR
       "Display VPNv4 NLRI specific information\n"
       "Display information for a route distinguisher\n"
       "VPN Route Distinguisher\n"
       "Detailed information on TCP and BGP neighbor connections\n"
       "Neighbor to display information about\n"
       "Display the routes advertised to a BGP neighbor\n")
{
  int ret;
  struct peer *peer;
  struct prefix_rd prd;
  union sockunion su;

  ret = str2sockunion (argv[1], &su);
  if (ret < 0)
    {
      vty_out (vty, "%% Malformed address: %s%s", argv[0], VTY_NEWLINE);
      return CMD_WARNING;
    }
  peer = peer_lookup (NULL, &su);
  if (! peer || ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
    {
      vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  ret = str2prefix_rd (argv[0], &prd);
  if (! ret)
    {
      vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
      return CMD_WARNING;
    }

  return show_adj_route_vpn (vty, peer, &prd);
}

void
bgp_mplsvpn_init (void)
{
  install_element (BGP_VPNV4_NODE, &vpnv4_network_cmd);
  install_element (BGP_VPNV4_NODE, &no_vpnv4_network_cmd);


  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_tags_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_tags_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_neighbor_routes_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_neighbor_routes_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd);
  install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd);

  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_tags_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_tags_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_neighbor_routes_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_neighbor_routes_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd);
  install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd);
}
Commit	Line	Data
718e3744	1	/* MPLS-VPN
	2	Copyright (C) 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
	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 "prefix.h"
	25	#include "log.h"
	26	#include "memory.h"
	27	#include "stream.h"
	28
	29	#include "bgpd/bgpd.h"
	30	#include "bgpd/bgp_table.h"
	31	#include "bgpd/bgp_route.h"
	32	#include "bgpd/bgp_attr.h"
	33	#include "bgpd/bgp_mplsvpn.h"
	34
94f2b392	35	static u_int16_t
718e3744	36	decode_rd_type (u_char *pnt)
	37	{
	38	u_int16_t v;
	39
	40	v = ((u_int16_t) *pnt++ << 8);
	41	v \|= (u_int16_t) *pnt;
	42	return v;
	43	}
	44
	45	u_int32_t
	46	decode_label (u_char *pnt)
	47	{
	48	u_int32_t l;
	49
	50	l = ((u_int32_t) *pnt++ << 12);
	51	l \|= (u_int32_t) *pnt++ << 4;
	52	l \|= (u_int32_t) ((*pnt & 0xf0) >> 4);
	53	return l;
	54	}
	55
94f2b392	56	static void
718e3744	57	decode_rd_as (u_char pnt, struct rd_as rd_as)
	58	{
	59	rd_as->as = (u_int16_t) *pnt++ << 8;
	60	rd_as->as \|= (u_int16_t) *pnt++;
	61
	62	rd_as->val = ((u_int32_t) *pnt++ << 24);
	63	rd_as->val \|= ((u_int32_t) *pnt++ << 16);
	64	rd_as->val \|= ((u_int32_t) *pnt++ << 8);
	65	rd_as->val \|= (u_int32_t) *pnt;
	66	}
	67
94f2b392	68	static void
718e3744	69	decode_rd_ip (u_char pnt, struct rd_ip rd_ip)
	70	{
	71	memcpy (&rd_ip->ip, pnt, 4);
	72	pnt += 4;
	73
	74	rd_ip->val = ((u_int16_t) *pnt++ << 8);
	75	rd_ip->val \|= (u_int16_t) *pnt;
	76	}
	77
718e3744	78	int
	79	bgp_nlri_parse_vpnv4 (struct peer peer, struct attr attr,
	80	struct bgp_nlri *packet)
	81	{
	82	u_char *pnt;
	83	u_char *lim;
	84	struct prefix p;
	85	int psize;
	86	int prefixlen;
	87	u_int32_t label;
	88	u_int16_t type;
	89	struct rd_as rd_as;
	90	struct rd_ip rd_ip;
	91	struct prefix_rd prd;
	92	u_char *tagpnt;
	93
	94	/* Check peer status. */
	95	if (peer->status != Established)
	96	return 0;
	97
	98	/* Make prefix_rd */
	99	prd.family = AF_UNSPEC;
	100	prd.prefixlen = 64;
	101
	102	pnt = packet->nlri;
	103	lim = pnt + packet->length;
	104
	105	for (; pnt < lim; pnt += psize)
	106	{
	107	/* Clear prefix structure. */
	108	memset (&p, 0, sizeof (struct prefix));
	109
	110	/* Fetch prefix length. */
	111	prefixlen = *pnt++;
	112	p.family = AF_INET;
	113	psize = PSIZE (prefixlen);
	114
	115	if (prefixlen < 88)
	116	{
	117	zlog_err ("prefix length is less than 88: %d", prefixlen);
	118	return -1;
	119	}
	120
	121	label = decode_label (pnt);
	122
	123	/* Copyr label to prefix. */
	124	tagpnt = pnt;;
	125
	126	/* Copy routing distinguisher to rd. */
	127	memcpy (&prd.val, pnt + 3, 8);
	128
	129	/* Decode RD type. */
	130	type = decode_rd_type (pnt + 3);
	131
	132	/* Decode RD value. */
	133	if (type == RD_TYPE_AS)
	134	decode_rd_as (pnt + 5, &rd_as);
	135	else if (type == RD_TYPE_IP)
	136	decode_rd_ip (pnt + 5, &rd_ip);
	137	else
	138	{
	139	zlog_err ("Invalid RD type %d", type);
	140	return -1;
	141	}
142
143	p.prefixlen = prefixlen - 88;
144	memcpy (&p.u.prefix, pnt + 11, psize - 11);
145
146	#if 0
147	if (type == RD_TYPE_AS)
148	zlog_info ("prefix %ld:%ld:%ld:%s/%d", label, rd_as.as, rd_as.val,
149	inet_ntoa (p.u.prefix4), p.prefixlen);
150	else if (type == RD_TYPE_IP)
151	zlog_info ("prefix %ld:%s:%ld:%s/%d", label, inet_ntoa (rd_ip.ip),
152	rd_ip.val, inet_ntoa (p.u.prefix4), p.prefixlen);
153	#endif /* 0 */
154
155	if (pnt + psize > lim)
156	return -1;
157
158	if (attr)
159	bgp_update (peer, &p, attr, AFI_IP, SAFI_MPLS_VPN,
94f2b392	160	ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, tagpnt, 0);
718e3744	161	else
	162	bgp_withdraw (peer, &p, attr, AFI_IP, SAFI_MPLS_VPN,
	163	ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, &prd, tagpnt);
	164	}
	165
	166	/* Packet length consistency check. */
	167	if (pnt != lim)
	168	return -1;
	169
	170	return 0;
	171	}
	172
	173	int
fd79ac91	174	str2prefix_rd (const char str, struct prefix_rd prd)
718e3744	175	{
718e3744	176	int ret;
5228ad27	177	char *p;
5228ad27	178	char *p2;
718e3744	179	struct stream *s;
5228ad27	180	char *half;
718e3744	181	struct in_addr addr;
	182
	183	s = stream_new (8);
	184
	185	prd->family = AF_UNSPEC;
	186	prd->prefixlen = 64;
	187
	188	p = strchr (str, ':');
	189	if (! p)
	190	return 0;
	191
	192	if (! all_digit (p + 1))
	193	return 0;
	194
	195	half = XMALLOC (MTYPE_TMP, (p - str) + 1);
	196	memcpy (half, str, (p - str));
	197	half[p - str] = '\0';
	198
	199	p2 = strchr (str, '.');
	200
	201	if (! p2)
	202	{
	203	if (! all_digit (half))
	204	{
	205	XFREE (MTYPE_TMP, half);
	206	return 0;
	207	}
	208	stream_putw (s, RD_TYPE_AS);
	209	stream_putw (s, atoi (half));
	210	stream_putl (s, atol (p + 1));
	211	}
	212	else
	213	{
	214	ret = inet_aton (half, &addr);
	215	if (! ret)
	216	{
	217	XFREE (MTYPE_TMP, half);
	218	return 0;
	219	}
	220	stream_putw (s, RD_TYPE_IP);
	221	stream_put_in_addr (s, &addr);
	222	stream_putw (s, atol (p + 1));
	223	}
	224	memcpy (prd->val, s->data, 8);
	225
	226	return 1;
	227	}
	228
	229	int
fd79ac91	230	str2tag (const char str, u_char tag)
718e3744	231	{
fd79ac91	232	unsigned long l;
	233	char *endptr;
	234	u_int32_t t;
718e3744	235
fd79ac91	236	l = strtoul (str, &endptr, 10);
	237
	238	if (*endptr == '\0' \|\| l == ULONG_MAX \|\| l > UINT32_MAX)
	239	return 0;
718e3744	240
fd79ac91	241	t = (u_int32_t) l;
	242
	243	tag[0] = (u_char)(t >> 12);
	244	tag[1] = (u_char)(t >> 4);
	245	tag[2] = (u_char)(t << 4);
718e3744	246
	247	return 1;
	248	}
	249
	250	char *
	251	prefix_rd2str (struct prefix_rd prd, char buf, size_t size)
	252	{
	253	u_char *pnt;
	254	u_int16_t type;
	255	struct rd_as rd_as;
	256	struct rd_ip rd_ip;
	257
	258	if (size < RD_ADDRSTRLEN)
	259	return NULL;
	260
	261	pnt = prd->val;
	262
	263	type = decode_rd_type (pnt);
	264
	265	if (type == RD_TYPE_AS)
	266	{
	267	decode_rd_as (pnt + 2, &rd_as);
aea339f7	268	snprintf (buf, size, "%u:%d", rd_as.as, rd_as.val);
718e3744	269	return buf;
	270	}
	271	else if (type == RD_TYPE_IP)
	272	{
	273	decode_rd_ip (pnt + 2, &rd_ip);
	274	snprintf (buf, size, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);
	275	return buf;
	276	}
	277
	278	return NULL;
	279	}
	280
	281	/* For testing purpose, static route of MPLS-VPN. */
	282	DEFUN (vpnv4_network,
	283	vpnv4_network_cmd,
	284	"network A.B.C.D/M rd ASN:nn_or_IP-address:nn tag WORD",
	285	"Specify a network to announce via BGP\n"
	286	"IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
	287	"Specify Route Distinguisher\n"
	288	"VPN Route Distinguisher\n"
	289	"BGP tag\n"
	290	"tag value\n")
	291	{
	292	return bgp_static_set_vpnv4 (vty, argv[0], argv[1], argv[2]);
	293	}
	294
	295	/* For testing purpose, static route of MPLS-VPN. */
	296	DEFUN (no_vpnv4_network,
	297	no_vpnv4_network_cmd,
	298	"no network A.B.C.D/M rd ASN:nn_or_IP-address:nn tag WORD",
	299	NO_STR
	300	"Specify a network to announce via BGP\n"
	301	"IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
	302	"Specify Route Distinguisher\n"
	303	"VPN Route Distinguisher\n"
	304	"BGP tag\n"
	305	"tag value\n")
	306	{
	307	return bgp_static_unset_vpnv4 (vty, argv[0], argv[1], argv[2]);
	308	}
	309
94f2b392	310	static int
718e3744	311	show_adj_route_vpn (struct vty vty, struct peer peer, struct prefix_rd *prd)
	312	{
	313	struct bgp *bgp;
	314	struct bgp_table *table;
	315	struct bgp_node *rn;
	316	struct bgp_node *rm;
	317	struct attr *attr;
	318	int rd_header;
	319	int header = 1;
	320	char v4_header[] = " Network Next Hop Metric LocPrf Weight Path%s";
	321
	322	bgp = bgp_get_default ();
	323	if (bgp == NULL)
	324	{
	325	vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE);
	326	return CMD_WARNING;
	327	}
	328
	329	for (rn = bgp_table_top (bgp->rib[AFI_IP][SAFI_MPLS_VPN]); rn;
	330	rn = bgp_route_next (rn))
	331	{
	332	if (prd && memcmp (rn->p.u.val, prd->val, 8) != 0)
	333	continue;
	334
	335	if ((table = rn->info) != NULL)
	336	{
	337	rd_header = 1;
	338
	339	for (rm = bgp_table_top (table); rm; rm = bgp_route_next (rm))
	340	if ((attr = rm->info) != NULL)
	341	{
	342	if (header)
	343	{
	344	vty_out (vty, "BGP table version is 0, local router ID is %s%s",
	345	inet_ntoa (bgp->router_id), VTY_NEWLINE);
	346	vty_out (vty, "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal%s",
	347	VTY_NEWLINE);
	348	vty_out (vty, "Origin codes: i - IGP, e - EGP, ? - incomplete%s%s",
	349	VTY_NEWLINE, VTY_NEWLINE);
	350	vty_out (vty, v4_header, VTY_NEWLINE);
	351	header = 0;
	352	}
	353
	354	if (rd_header)
	355	{
	356	u_int16_t type;
	357	struct rd_as rd_as;
	358	struct rd_ip rd_ip;
	359	u_char *pnt;
	360
	361	pnt = rn->p.u.val;
	362
	363	/* Decode RD type. */
	364	type = decode_rd_type (pnt);
	365	/* Decode RD value. */
	366	if (type == RD_TYPE_AS)
	367	decode_rd_as (pnt + 2, &rd_as);
	368	else if (type == RD_TYPE_IP)
	369	decode_rd_ip (pnt + 2, &rd_ip);
	370
	371	vty_out (vty, "Route Distinguisher: ");
	372
	373	if (type == RD_TYPE_AS)
aea339f7	374	vty_out (vty, "%u:%d", rd_as.as, rd_as.val);
718e3744	375	else if (type == RD_TYPE_IP)
	376	vty_out (vty, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);
	377
	378	vty_out (vty, "%s", VTY_NEWLINE);
	379	rd_header = 0;
	380	}
	381	route_vty_out_tmp (vty, &rm->p, attr, SAFI_MPLS_VPN);
	382	}
	383	}
	384	}
	385	return CMD_SUCCESS;
	386	}
	387
	388	enum bgp_show_type
	389	{
	390	bgp_show_type_normal,
	391	bgp_show_type_regexp,
	392	bgp_show_type_prefix_list,
	393	bgp_show_type_filter_list,
	394	bgp_show_type_neighbor,
	395	bgp_show_type_cidr_only,
	396	bgp_show_type_prefix_longer,
	397	bgp_show_type_community_all,
	398	bgp_show_type_community,
	399	bgp_show_type_community_exact,
	400	bgp_show_type_community_list,
	401	bgp_show_type_community_list_exact
	402	};
	403
94f2b392	404	static int
718e3744	405	bgp_show_mpls_vpn (struct vty vty, struct prefix_rd prd, enum bgp_show_type type,
	406	void *output_arg, int tags)
	407	{
	408	struct bgp *bgp;
	409	struct bgp_table *table;
	410	struct bgp_node *rn;
	411	struct bgp_node *rm;
	412	struct bgp_info *ri;
	413	int rd_header;
	414	int header = 1;
	415	char v4_header[] = " Network Next Hop Metric LocPrf Weight Path%s";
	416	char v4_header_tag[] = " Network Next Hop In tag/Out tag%s";
	417
	418	bgp = bgp_get_default ();
	419	if (bgp == NULL)
	420	{
	421	vty_out (vty, "No BGP process is configured%s", VTY_NEWLINE);
	422	return CMD_WARNING;
	423	}
	424
	425	for (rn = bgp_table_top (bgp->rib[AFI_IP][SAFI_MPLS_VPN]); rn; rn = bgp_route_next (rn))
	426	{
	427	if (prd && memcmp (rn->p.u.val, prd->val, 8) != 0)
	428	continue;
	429
	430	if ((table = rn->info) != NULL)
	431	{
	432	rd_header = 1;
	433
	434	for (rm = bgp_table_top (table); rm; rm = bgp_route_next (rm))
	435	for (ri = rm->info; ri; ri = ri->next)
	436	{
	437	if (type == bgp_show_type_neighbor)
	438	{
	439	union sockunion *su = output_arg;
	440
	441	if (ri->peer->su_remote == NULL \|\| ! sockunion_same(ri->peer->su_remote, su))
	442	continue;
	443	}
	444	if (header)
	445	{
	446	if (tags)
	447	vty_out (vty, v4_header_tag, VTY_NEWLINE);
	448	else
	449	{
	450	vty_out (vty, "BGP table version is 0, local router ID is %s%s",
	451	inet_ntoa (bgp->router_id), VTY_NEWLINE);
	452	vty_out (vty, "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal%s",
	453	VTY_NEWLINE);
	454	vty_out (vty, "Origin codes: i - IGP, e - EGP, ? - incomplete%s%s",
	455	VTY_NEWLINE, VTY_NEWLINE);
	456	vty_out (vty, v4_header, VTY_NEWLINE);
	457	}
	458	header = 0;
	459	}
	460
	461	if (rd_header)
	462	{
	463	u_int16_t type;
	464	struct rd_as rd_as;
	465	struct rd_ip rd_ip;
	466	u_char *pnt;
	467
	468	pnt = rn->p.u.val;
469
470	/* Decode RD type. */
471	type = decode_rd_type (pnt);
472	/* Decode RD value. */
473	if (type == RD_TYPE_AS)
474	decode_rd_as (pnt + 2, &rd_as);
475	else if (type == RD_TYPE_IP)
476	decode_rd_ip (pnt + 2, &rd_ip);
477
478	vty_out (vty, "Route Distinguisher: ");
479
480	if (type == RD_TYPE_AS)
aea339f7	481	vty_out (vty, "%u:%d", rd_as.as, rd_as.val);
718e3744	482	else if (type == RD_TYPE_IP)
	483	vty_out (vty, "%s:%d", inet_ntoa (rd_ip.ip), rd_ip.val);
	484
	485	vty_out (vty, "%s", VTY_NEWLINE);
	486	rd_header = 0;
	487	}
	488	if (tags)
	489	route_vty_out_tag (vty, &rm->p, ri, 0, SAFI_MPLS_VPN);
	490	else
	491	route_vty_out (vty, &rm->p, ri, 0, SAFI_MPLS_VPN);
	492	}
	493	}
	494	}
	495	return CMD_SUCCESS;
	496	}
	497
	498	DEFUN (show_ip_bgp_vpnv4_all,
	499	show_ip_bgp_vpnv4_all_cmd,
	500	"show ip bgp vpnv4 all",
	501	SHOW_STR
	502	IP_STR
	503	BGP_STR
	504	"Display VPNv4 NLRI specific information\n"
	505	"Display information about all VPNv4 NLRIs\n")
	506	{
	507	return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_normal, NULL, 0);
	508	}
	509
	510	DEFUN (show_ip_bgp_vpnv4_rd,
	511	show_ip_bgp_vpnv4_rd_cmd,
	512	"show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn",
	513	SHOW_STR
	514	IP_STR
	515	BGP_STR
	516	"Display VPNv4 NLRI specific information\n"
	517	"Display information for a route distinguisher\n"
	518	"VPN Route Distinguisher\n")
	519	{
	520	int ret;
	521	struct prefix_rd prd;
	522
	523	ret = str2prefix_rd (argv[0], &prd);
	524	if (! ret)
	525	{
	526	vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
	527	return CMD_WARNING;
	528	}
	529	return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_normal, NULL, 0);
	530	}
	531
	532	DEFUN (show_ip_bgp_vpnv4_all_tags,
	533	show_ip_bgp_vpnv4_all_tags_cmd,
	534	"show ip bgp vpnv4 all tags",
	535	SHOW_STR
	536	IP_STR
	537	BGP_STR
	538	"Display VPNv4 NLRI specific information\n"
	539	"Display information about all VPNv4 NLRIs\n"
	540	"Display BGP tags for prefixes\n")
	541	{
	542	return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_normal, NULL, 1);
	543	}
	544
	545	DEFUN (show_ip_bgp_vpnv4_rd_tags,
546	show_ip_bgp_vpnv4_rd_tags_cmd,
547	"show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn tags",
548	SHOW_STR
549	IP_STR
550	BGP_STR
551	"Display VPNv4 NLRI specific information\n"
552	"Display information for a route distinguisher\n"
553	"VPN Route Distinguisher\n"
554	"Display BGP tags for prefixes\n")
555	{
556	int ret;
557	struct prefix_rd prd;
558
559	ret = str2prefix_rd (argv[0], &prd);
560	if (! ret)
561	{
562	vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
563	return CMD_WARNING;
564	}
565	return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_normal, NULL, 1);
566	}
567
568	DEFUN (show_ip_bgp_vpnv4_all_neighbor_routes,
569	show_ip_bgp_vpnv4_all_neighbor_routes_cmd,
570	"show ip bgp vpnv4 all neighbors A.B.C.D routes",
571	SHOW_STR
572	IP_STR
573	BGP_STR
574	"Display VPNv4 NLRI specific information\n"
575	"Display information about all VPNv4 NLRIs\n"
576	"Detailed information on TCP and BGP neighbor connections\n"
577	"Neighbor to display information about\n"
578	"Display routes learned from neighbor\n")
579	{
580	union sockunion *su;
581	struct peer *peer;
582
583	su = sockunion_str2su (argv[0]);
584	if (su == NULL)
585	{
586	vty_out (vty, "Malformed address: %s%s", argv[0], VTY_NEWLINE);
587	return CMD_WARNING;
588	}
589
590	peer = peer_lookup (NULL, su);
591	if (! peer \|\| ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
592	{
593	vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
594	return CMD_WARNING;
595	}
596
597	return bgp_show_mpls_vpn (vty, NULL, bgp_show_type_neighbor, su, 0);
598	}
599
600	DEFUN (show_ip_bgp_vpnv4_rd_neighbor_routes,
601	show_ip_bgp_vpnv4_rd_neighbor_routes_cmd,
602	"show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn neighbors A.B.C.D routes",
603	SHOW_STR
604	IP_STR
605	BGP_STR
606	"Display VPNv4 NLRI specific information\n"
607	"Display information for a route distinguisher\n"
608	"VPN Route Distinguisher\n"
609	"Detailed information on TCP and BGP neighbor connections\n"
610	"Neighbor to display information about\n"
611	"Display routes learned from neighbor\n")
612	{
613	int ret;
614	union sockunion *su;
615	struct peer *peer;
616	struct prefix_rd prd;
617
618	ret = str2prefix_rd (argv[0], &prd);
619	if (! ret)
620	{
621	vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
622	return CMD_WARNING;
623	}
624
625	su = sockunion_str2su (argv[1]);
626	if (su == NULL)
627	{
628	vty_out (vty, "Malformed address: %s%s", argv[0], VTY_NEWLINE);
629	return CMD_WARNING;
630	}
631
632	peer = peer_lookup (NULL, su);
633	if (! peer \|\| ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
634	{
635	vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
636	return CMD_WARNING;
637	}
638
639	return bgp_show_mpls_vpn (vty, &prd, bgp_show_type_neighbor, su, 0);
640	}
641
642	DEFUN (show_ip_bgp_vpnv4_all_neighbor_advertised_routes,
643	show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd,
644	"show ip bgp vpnv4 all neighbors A.B.C.D advertised-routes",
645	SHOW_STR
646	IP_STR
647	BGP_STR
648	"Display VPNv4 NLRI specific information\n"
649	"Display information about all VPNv4 NLRIs\n"
650	"Detailed information on TCP and BGP neighbor connections\n"
651	"Neighbor to display information about\n"
652	"Display the routes advertised to a BGP neighbor\n")
653	{
654	int ret;
655	struct peer *peer;
656	union sockunion su;
657
658	ret = str2sockunion (argv[0], &su);
659	if (ret < 0)
660	{
661	vty_out (vty, "%% Malformed address: %s%s", argv[0], VTY_NEWLINE);
662	return CMD_WARNING;
663	}
664	peer = peer_lookup (NULL, &su);
665	if (! peer \|\| ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
666	{
667	vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
668	return CMD_WARNING;
669	}
670
671	return show_adj_route_vpn (vty, peer, NULL);
672	}
673
674	DEFUN (show_ip_bgp_vpnv4_rd_neighbor_advertised_routes,
675	show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd,
676	"show ip bgp vpnv4 rd ASN:nn_or_IP-address:nn neighbors A.B.C.D advertised-routes",
677	SHOW_STR
678	IP_STR
679	BGP_STR
680	"Display VPNv4 NLRI specific information\n"
681	"Display information for a route distinguisher\n"
682	"VPN Route Distinguisher\n"
683	"Detailed information on TCP and BGP neighbor connections\n"
684	"Neighbor to display information about\n"
685	"Display the routes advertised to a BGP neighbor\n")
686	{
687	int ret;
688	struct peer *peer;
689	struct prefix_rd prd;
690	union sockunion su;
691
692	ret = str2sockunion (argv[1], &su);
693	if (ret < 0)
694	{
695	vty_out (vty, "%% Malformed address: %s%s", argv[0], VTY_NEWLINE);
696	return CMD_WARNING;
697	}
698	peer = peer_lookup (NULL, &su);
699	if (! peer \|\| ! peer->afc[AFI_IP][SAFI_MPLS_VPN])
700	{
701	vty_out (vty, "%% No such neighbor or address family%s", VTY_NEWLINE);
702	return CMD_WARNING;
703	}
704
705	ret = str2prefix_rd (argv[0], &prd);
706	if (! ret)
707	{
708	vty_out (vty, "%% Malformed Route Distinguisher%s", VTY_NEWLINE);
709	return CMD_WARNING;
710	}
711
712	return show_adj_route_vpn (vty, peer, &prd);
713	}
714
715	void
94f2b392	716	bgp_mplsvpn_init (void)
718e3744	717	{
	718	install_element (BGP_VPNV4_NODE, &vpnv4_network_cmd);
	719	install_element (BGP_VPNV4_NODE, &no_vpnv4_network_cmd);
	720
	721
	722	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_cmd);
	723	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_cmd);
	724	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_tags_cmd);
	725	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_tags_cmd);
	726	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_neighbor_routes_cmd);
	727	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_neighbor_routes_cmd);
	728	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd);
	729	install_element (VIEW_NODE, &show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd);
	730
	731	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_cmd);
	732	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_cmd);
	733	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_tags_cmd);
	734	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_tags_cmd);
	735	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_neighbor_routes_cmd);
	736	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_neighbor_routes_cmd);
	737	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_all_neighbor_advertised_routes_cmd);
	738	install_element (ENABLE_NODE, &show_ip_bgp_vpnv4_rd_neighbor_advertised_routes_cmd);
	739	}