LCOV - code coverage report
Current view: top level - bgpd - bgp_mplsvpn.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 289 0.0 %
Date: 2015-11-19 Functions: 0 21 0.0 %

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

Generated by: LCOV version 1.10