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 along
      17             :  * with this program; see the file COPYING; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include <zebra.h>
      22             : 
      23             : #include "log.h"
      24             : #include "command.h"
      25             : #include "memory.h"
      26             : #include "queue.h"
      27             : #include "filter.h"
      28             : 
      29             : #include "bgpd.h"
      30             : #include "bgp_aspath.h"
      31             : #include "bgp_regex.h"
      32             : 
      33             : /* Character `_' has special mean.  It represents [,{}() ] and the
      34             :    beginning of the line(^) and the end of the line ($).
      35             : 
      36             :    (^|[,{}() ]|$) */
      37             : 
      38           0 : regex_t *bgp_regcomp(const char *regstr)
      39             : {
      40             :         /* Convert _ character to generic regular expression. */
      41           0 :         int i, j;
      42           0 :         int len;
      43           0 :         int magic = 0;
      44           0 :         char *magic_str;
      45           0 :         char magic_regexp[] = "(^|[,{}() ]|$)";
      46           0 :         int ret;
      47           0 :         regex_t *regex;
      48             : 
      49           0 :         len = strlen(regstr);
      50           0 :         for (i = 0; i < len; i++)
      51           0 :                 if (regstr[i] == '_')
      52           0 :                         magic++;
      53             : 
      54           0 :         magic_str = XMALLOC(MTYPE_TMP, len + (14 * magic) + 1);
      55             : 
      56           0 :         for (i = 0, j = 0; i < len; i++) {
      57           0 :                 if (regstr[i] == '_') {
      58           0 :                         memcpy(magic_str + j, magic_regexp,
      59             :                                strlen(magic_regexp));
      60           0 :                         j += strlen(magic_regexp);
      61             :                 } else
      62           0 :                         magic_str[j++] = regstr[i];
      63             :         }
      64           0 :         magic_str[j] = '\0';
      65             : 
      66           0 :         regex = XMALLOC(MTYPE_BGP_REGEXP, sizeof(regex_t));
      67             : 
      68           0 :         ret = regcomp(regex, magic_str, REG_EXTENDED | REG_NOSUB);
      69             : 
      70           0 :         XFREE(MTYPE_TMP, magic_str);
      71             : 
      72           0 :         if (ret != 0) {
      73           0 :                 XFREE(MTYPE_BGP_REGEXP, regex);
      74           0 :                 return NULL;
      75             :         }
      76             : 
      77             :         return regex;
      78             : }
      79             : 
      80           0 : int bgp_regexec(regex_t *regex, struct aspath *aspath)
      81             : {
      82           0 :         return regexec(regex, aspath->str, 0, NULL, 0);
      83             : }
      84             : 
      85           0 : void bgp_regex_free(regex_t *regex)
      86             : {
      87           0 :         regfree(regex);
      88           0 :         XFREE(MTYPE_BGP_REGEXP, regex);
      89           0 : }