Line data    Source code

       1             : /* AS regular expression routine
       2             :    Copyright (C) 1999 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 "log.h"
      24             : #include "command.h"
      25             : #include "memory.h"
      26             : 
      27             : #include "bgpd.h"
      28             : #include "bgp_aspath.h"
      29             : #include "bgp_regex.h"
      30             : 
      31             : /* Character `_' has special mean.  It represents [,{}() ] and the
      32             :    beginning of the line(^) and the end of the line ($).  
      33             : 
      34             :    (^|[,{}() ]|$) */
      35             : 
      36             : regex_t *
      37           0 : bgp_regcomp (const char *regstr)
      38             : {
      39             :   /* Convert _ character to generic regular expression. */
      40             :   int i, j;
      41             :   int len;
      42           0 :   int magic = 0;
      43             :   char *magic_str;
      44           0 :   char magic_regexp[] = "(^|[,{}() ]|$)";
      45             :   int ret;
      46             :   regex_t *regex;
      47             : 
      48           0 :   len = strlen (regstr);
      49           0 :   for (i = 0; i < len; i++)
      50           0 :     if (regstr[i] == '_')
      51           0 :       magic++;
      52             : 
      53           0 :   magic_str = XMALLOC (MTYPE_TMP, len + (14 * magic) + 1);
      54             :   
      55           0 :   for (i = 0, j = 0; i < len; i++)
      56             :     {
      57           0 :       if (regstr[i] == '_')
      58             :         {
      59           0 :           memcpy (magic_str + j, magic_regexp, strlen (magic_regexp));
      60           0 :           j += strlen (magic_regexp);
      61             :         }
      62             :       else
      63           0 :         magic_str[j++] = regstr[i];
      64             :     }
      65           0 :   magic_str[j] = '\0';
      66             : 
      67           0 :   regex = XMALLOC (MTYPE_BGP_REGEXP, sizeof (regex_t));
      68             : 
      69           0 :   ret = regcomp (regex, magic_str, REG_EXTENDED|REG_NOSUB);
      70             : 
      71           0 :   XFREE (MTYPE_TMP, magic_str);
      72             : 
      73           0 :   if (ret != 0)
      74             :     {
      75           0 :       XFREE (MTYPE_BGP_REGEXP, regex);
      76           0 :       return NULL;
      77             :     }
      78             : 
      79           0 :   return regex;
      80             : }
      81             : 
      82             : int
      83           0 : bgp_regexec (regex_t *regex, struct aspath *aspath)
      84             : {
      85           0 :   return regexec (regex, aspath->str, 0, NULL, 0);
      86             : }
      87             : 
      88             : void
      89           0 : bgp_regex_free (regex_t *regex)
      90             : {
      91           0 :   regfree (regex);
      92           0 :   XFREE (MTYPE_BGP_REGEXP, regex);
      93           0 : }