1: /* exclude.c -- exclude file names
    2: 
    3:    Copyright (C) 1992, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003,
    4:    2004, 2005, 2006, 2007 Free Software Foundation, Inc.
    5: 
    6:    This program is free software; you can redistribute it and/or modify
    7:    it under the terms of the GNU General Public License as published by
    8:    the Free Software Foundation; either version 2, or (at your option)
    9:    any later version.
   10: 
   11:    This program is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14:    GNU General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU General Public License
   17:    along with this program; see the file COPYING.
   18:    If not, write to the Free Software Foundation,
   19:    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
   20: 
   21: /* Written by Paul Eggert <eggert@twinsun.com>  */
   22: 
   23: #include <config.h>
   24: 
   25: #include <stdbool.h>
   26: 
   27: #include <ctype.h>
   28: #include <errno.h>
   29: #include <stddef.h>
   30: #include <stdio.h>
   31: #include <stdlib.h>
   32: #include <string.h>
   33: 
   34: #include "exclude.h"
   35: #include "fnmatch.h"
   36: #include "xalloc.h"
   37: #include "verify.h"
   38: 
   39: #if USE_UNLOCKED_IO
   40: # include "unlocked-io.h"
   41: #endif
   42: 
   43: /* Non-GNU systems lack these options, so we don't need to check them.  */
   44: #ifndef FNM_CASEFOLD
   45: # define FNM_CASEFOLD 0
   46: #endif
   47: #ifndef FNM_EXTMATCH
   48: # define FNM_EXTMATCH 0
   49: #endif
   50: #ifndef FNM_LEADING_DIR
   51: # define FNM_LEADING_DIR 0
   52: #endif
   53: 
   54: verify (((EXCLUDE_ANCHORED | EXCLUDE_INCLUDE | EXCLUDE_WILDCARDS)
   55:          & (FNM_PATHNAME | FNM_NOESCAPE | FNM_PERIOD | FNM_LEADING_DIR
   56:             | FNM_CASEFOLD | FNM_EXTMATCH))
   57:         == 0);
   58: 
   59: /* An exclude pattern-options pair.  The options are fnmatch options
   60:    ORed with EXCLUDE_* options.  */
   61: 
   62: struct patopts
   63:   {
   64:     char const *pattern;
   65:     int options;
   66:   };
   67: 
   68: /* An exclude list, of pattern-options pairs.  */
   69: 
   70: struct exclude
   71:   {
   72:     struct patopts *exclude;
   73:     size_t exclude_alloc;
   74:     size_t exclude_count;
   75:   };
   76: 
   77: /* Return a newly allocated and empty exclude list.  */
   78: 
   79: struct exclude *
   80: new_exclude (void)
   81: {
   82:   return xzalloc (sizeof *new_exclude ());
   83: }
   84: 
   85: /* Free the storage associated with an exclude list.  */
   86: 
   87: void
   88: free_exclude (struct exclude *ex)
   89: {
   90:   free (ex->exclude);
   91:   free (ex);
   92: }
   93: 
   94: /* Return zero if PATTERN matches F, obeying OPTIONS, except that
   95:    (unlike fnmatch) wildcards are disabled in PATTERN.  */
   96: 
   97: static int
   98: fnmatch_no_wildcards (char const *pattern, char const *f, int options)
   99: {
  100:   if (! (options & FNM_LEADING_DIR))
  101:     return ((options & FNM_CASEFOLD)
  102:             ? mbscasecmp (pattern, f)
  103:             : strcmp (pattern, f));
  104:   else if (! (options & FNM_CASEFOLD))
  105:     {
  106:       size_t patlen = strlen (pattern);
  107:       int r = strncmp (pattern, f, patlen);
  108:       if (! r)
  109:         {
  110:           r = f[patlen];
  111:           if (r == '/')
  112:             r = 0;
  113:         }
  114:       return r;
  115:     }
  116:   else
  117:     {
  118:       /* Walk through a copy of F, seeing whether P matches any prefix
  119:          of F.
  120: 
  121:          FIXME: This is an O(N**2) algorithm; it should be O(N).
  122:          Also, the copy should not be necessary.  However, fixing this
  123:          will probably involve a change to the mbs* API.  */
  124: 
  125:       char *fcopy = xstrdup (f);
  126:       char *p;
  127:       int r;
  128:       for (p = fcopy; ; *p++ = '/')
  129:         {
  130:           p = strchr (p, '/');
  131:           if (p)
  132:             *p = '\0';
  133:           r = mbscasecmp (pattern, fcopy);
  134:           if (!p || r <= 0)
  135:             break;
  136:         }
  137:       free (fcopy);
  138:       return r;
  139:     }
  140: }
  141: 
  142: bool
  143: exclude_fnmatch (char const *pattern, char const *f, int options)
  144: {
  145:   int (*matcher) (char const *, char const *, int) =
  146:     (options & EXCLUDE_WILDCARDS
  147:      ? fnmatch
  148:      : fnmatch_no_wildcards);
  149:   bool matched = ((*matcher) (pattern, f, options) == 0);
  150:   char const *p;
  151: 
  152:   if (! (options & EXCLUDE_ANCHORED))
  153:     for (p = f; *p && ! matched; p++)
  154:       if (*p == '/' && p[1] != '/')
  155:         matched = ((*matcher) (pattern, p + 1, options) == 0);
  156: 
  157:   return matched;
  158: }
  159: 
  160: /* Return true if EX excludes F.  */
  161: 
  162: bool
  163: excluded_file_name (struct exclude const *ex, char const *f)
  164: {
  165:   size_t exclude_count = ex->exclude_count;
  166: 
  167:   /* If no options are given, the default is to include.  */
  168:   if (exclude_count == 0)
  169:     return false;
  170:   else
  171:     {
  172:       struct patopts const *exclude = ex->exclude;
  173:       size_t i;
  174: 
  175:       /* Otherwise, the default is the opposite of the first option.  */
  176:       bool excluded = !! (exclude[0].options & EXCLUDE_INCLUDE);
  177: 
  178:       /* Scan through the options, seeing whether they change F from
  179:          excluded to included or vice versa.  */
  180:       for (i = 0;  i < exclude_count;  i++)
  181:         {
  182:           char const *pattern = exclude[i].pattern;
  183:           int options = exclude[i].options;
  184:           if (excluded == !! (options & EXCLUDE_INCLUDE))
  185:             excluded ^= exclude_fnmatch (pattern, f, options);
  186:         }
  187: 
  188:       return excluded;
  189:     }
  190: }
  191: 
  192: /* Append to EX the exclusion PATTERN with OPTIONS.  */
  193: 
  194: void
  195: add_exclude (struct exclude *ex, char const *pattern, int options)
  196: {
  197:   struct patopts *patopts;
  198: 
  199:   if (ex->exclude_count == ex->exclude_alloc)
  200:     ex->exclude = x2nrealloc (ex->exclude, &ex->exclude_alloc,
  201:                               sizeof *ex->exclude);
  202: 
  203:   patopts = &ex->exclude[ex->exclude_count++];
  204:   patopts->pattern = pattern;
  205:   patopts->options = options;
  206: }
  207: 
  208: /* Use ADD_FUNC to append to EX the patterns in FILE_NAME, each with
  209:    OPTIONS.  LINE_END terminates each pattern in the file.  If
  210:    LINE_END is a space character, ignore trailing spaces and empty
  211:    lines in FILE.  Return -1 on failure, 0 on success.  */
  212: 
  213: int
  214: add_exclude_file (void (*add_func) (struct exclude *, char const *, int),
  215:                   struct exclude *ex, char const *file_name, int options,
  216:                   char line_end)
  217: {
  218:   bool use_stdin = file_name[0] == '-' && !file_name[1];
  219:   FILE *in;
  220:   char *buf = NULL;
  221:   char *p;
  222:   char const *pattern;
  223:   char const *lim;
  224:   size_t buf_alloc = 0;
  225:   size_t buf_count = 0;
  226:   int c;
  227:   int e = 0;
  228: 
  229:   if (use_stdin)
  230:     in = stdin;
  231:   else if (! (in = fopen (file_name, "r")))
  232:     return -1;
  233: 
  234:   while ((c = getc (in)) != EOF)
  235:     {
  236:       if (buf_count == buf_alloc)
  237:         buf = x2realloc (buf, &buf_alloc);
  238:       buf[buf_count++] = c;
  239:     }
  240: 
  241:   if (ferror (in))
  242:     e = errno;
  243: 
  244:   if (!use_stdin && fclose (in) != 0)
  245:     e = errno;
  246: 
  247:   buf = xrealloc (buf, buf_count + 1);
  248:   buf[buf_count] = line_end;
  249:   lim = buf + buf_count + ! (buf_count == 0 || buf[buf_count - 1] == line_end);
  250:   pattern = buf;
  251: 
  252:   for (p = buf; p < lim; p++)
  253:     if (*p == line_end)
  254:       {
  255:         char *pattern_end = p;
  256: 
  257:         if (isspace ((unsigned char) line_end))
  258:           {
  259:             for (; ; pattern_end--)
  260:               if (pattern_end == pattern)
  261:                 goto next_pattern;
  262:               else if (! isspace ((unsigned char) pattern_end[-1]))
  263:                 break;
  264:           }
  265: 
  266:         *pattern_end = '\0';
  267:         (*add_func) (ex, pattern, options);
  268: 
  269:       next_pattern:
  270:         pattern = p + 1;
  271:       }
  272: 
  273:   errno = e;
  274:   return e ? -1 : 0;
  275: }