git.sur5r.net Git - bacula/bacula/blob - bacula/src/findlib/match.c

   1 /*
   2  *  Routines used to keep and match include and exclude
   3  *   filename/pathname patterns.
   4  *
   5  *   Kern E. Sibbald, December MMI
   6  *
   7  */
   8 /*
   9    Copyright (C) 2001-2003 Kern Sibbald and John Walker
  10
  11    This program is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation; either version 2 of
  14    the License, or (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19    General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public
  22    License along with this program; if not, write to the Free
  23    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  24    MA 02111-1307, USA.
  25
  26  */
  27
  28 #include "bacula.h"
  29 #include "find.h"
  30
  31 #include <pwd.h>
  32 #include <grp.h>
  33 #include <sys/types.h>
  34
  35 #ifndef FNM_LEADING_DIR
  36 #define FNM_LEADING_DIR 0
  37 #endif
  38
  39 #undef bmalloc
  40 #define bmalloc(x) sm_malloc(__FILE__, __LINE__, x)
  41
  42 #ifdef HAVE_CYGWIN
  43 static int win32_client = 1;
  44 #else
  45 static int win32_client = 0;
  46 #endif
  47
  48
  49 /*
  50  * Initialize structures for filename matching
  51  */
  52 void init_include_exclude_files(FF_PKT *ff)
  53 {
  54 }
  55
  56 /*
  57  * Done doing filename matching, release all
  58  *  resources used.
  59  */
  60 void term_include_exclude_files(FF_PKT *ff)
  61 {
  62    struct s_included_file *inc, *next_inc;
  63    struct s_excluded_file *exc, *next_exc;
  64
  65    for (inc=ff->included_files_list; inc; ) {
  66       next_inc = inc->next;
  67       free(inc);
  68       inc = next_inc;
  69    }
  70
  71    for (exc=ff->excluded_files_list; exc; ) {
  72       next_exc = exc->next;
  73       free(exc);
  74       exc = next_exc;
  75    }
  76
  77    for (exc=ff->excluded_paths_list; exc; ) {
  78       next_exc = exc->next;
  79       free(exc);
  80       exc = next_exc;
  81    }
  82
  83 }
  84
  85 /*
  86  * Add a filename to list of included files
  87  */
  88 void add_fname_to_include_list(FF_PKT *ff, int prefixed, char *fname)
  89 {
  90    int len, j;
  91    struct s_included_file *inc;
  92    char *p;
  93
  94    len = strlen(fname);
  95
  96    inc =(struct s_included_file *)bmalloc(sizeof(struct s_included_file) + len + 1);
  97    inc->options = 0;
  98    inc->VerifyOpts[0] = 'V';
  99    inc->VerifyOpts[1] = ':';
 100    inc->VerifyOpts[2] = 0;
 101
 102    /* prefixed = preceded with options */
 103    if (prefixed) {
 104       for (p=fname; *p && *p != ' '; p++) {
 105          switch (*p) {
 106          case 'a':                 /* alway replace */
 107          case '0':                 /* no option */
 108             break;
 109          case 'f':
 110             inc->options |= FO_MULTIFS;
 111             break;
 112          case 'h':                 /* no recursion */
 113             inc->options |= FO_NO_RECURSION;
 114             break;
 115          case 'M':                 /* MD5 */
 116             inc->options |= FO_MD5;
 117             break;
 118          case 'n':
 119             inc->options |= FO_NOREPLACE;
 120             break;
 121          case 'p':                 /* use portable data format */
 122             inc->options |= FO_PORTABLE;
 123             break;
 124          case 'r':                 /* read fifo */
 125             inc->options |= FO_READFIFO;
 126             break;
 127          case 'S':
 128             inc->options |= FO_SHA1;
 129             break;
 130          case 's':
 131             inc->options |= FO_SPARSE;
 132             break;
 133          case 'V':                  /* verify options */
 134             /* Copy Verify Options */
 135             for (j=0; *p && *p != ':'; p++) {
 136                inc->VerifyOpts[j] = *p;
 137                if (j < (int)sizeof(inc->VerifyOpts) - 1) {
 138                   j++;
 139                }
 140             }
 141             inc->VerifyOpts[j] = 0;
 142             break;
 143          case 'w':
 144             inc->options |= FO_IF_NEWER;
 145             break;
 146          case 'Z':                 /* gzip compression */
 147             inc->options |= FO_GZIP;
 148             inc->level = *++p - '0';
 149             Dmsg1(200, "Compression level=%d\n", inc->level);
 150             break;
 151          default:
 152             Emsg1(M_ERROR, 0, "Unknown include/exclude option: %c\n", *p);
 153             break;
 154          }
 155       }
 156       /* Skip past space(s) */
 157       for ( ; *p == ' '; p++)
 158          {}
 159    } else {
 160       p = fname;
 161    }
 162
 163    strcpy(inc->fname, p);
 164    p = inc->fname;
 165    len = strlen(p);
 166    /* Zap trailing slashes.  */
 167    p += len - 1;
 168    while (p > inc->fname && *p == '/') {
 169       *p-- = 0;
 170       len--;
 171    }
 172    inc->len = len;
 173    /* Check for wild cards */
 174    inc->pattern = 0;
 175    for (p=inc->fname; *p; p++) {
 176       if (*p == '*' || *p == '[' || *p == '?') {
 177          inc->pattern = 1;
 178          break;
 179       }
 180    }
 181 #ifdef HAVE_CYGWIN
 182    /* Convert any \'s into /'s */
 183    for (p=inc->fname; *p; p++) {
 184       if (*p == '\\') {
 185          *p = '/';
 186       }
 187    }
 188 #endif
 189    inc->next = NULL;
 190    /* Chain this one on the end of the list */
 191    if (!ff->included_files_list) {
 192       /* First one, so set head */
 193       ff->included_files_list = inc;
 194    } else {
 195       struct s_included_file *next;
 196       /* Walk to end of list */
 197       for (next=ff->included_files_list; next->next; next=next->next)
 198          { }
 199       next->next = inc;
 200    }
 201    Dmsg1(50, "add_fname_to_include fname=%s\n", inc->fname);
 202 }
 203
 204 /*
 205  * We add an exclude name to either the exclude path
 206  *  list or the exclude filename list.
 207  */
 208 void add_fname_to_exclude_list(FF_PKT *ff, char *fname)
 209 {
 210    int len;
 211    struct s_excluded_file *exc, **list;
 212
 213 #ifdef HAVE_CYGWIN
 214    /* Convert any \'s into /'s */
 215    for (char *p=fname; *p; p++) {
 216       if (*p == '\\') {
 217          *p = '/';
 218       }
 219    }
 220 #endif
 221    Dmsg1(20, "Add name to exclude: %s\n", fname);
 222
 223    if (strchr(fname, '/')) {
 224       list = &ff->excluded_paths_list;
 225    } else {
 226       list = &ff->excluded_files_list;
 227    }
 228
 229    len = strlen(fname);
 230
 231    exc = (struct s_excluded_file *)bmalloc(sizeof(struct s_excluded_file) + len + 1);
 232    exc->next = *list;
 233    exc->len = len;
 234    strcpy(exc->fname, fname);
 235    *list = exc;
 236 }
 237
 238
 239 /*
 240  * Get next included file
 241  */
 242 struct s_included_file *get_next_included_file(FF_PKT *ff, struct s_included_file *ainc)
 243 {
 244    struct s_included_file *inc;
 245
 246    if (ainc == NULL) {
 247       inc = ff->included_files_list;
 248    } else {
 249       inc = ainc->next;
 250    }
 251    /*
 252     * copy inc_options for this file into the ff packet
 253     */
 254    if (inc) {
 255       ff->flags = inc->options;
 256       ff->GZIP_level = inc->level;
 257    }
 258    return inc;
 259 }
 260
 261 /*
 262  * Walk through the included list to see if this
 263  *  file is included possibly with wild-cards.
 264  */
 265
 266 int file_is_included(FF_PKT *ff, char *file)
 267 {
 268    struct s_included_file *inc = ff->included_files_list;
 269    int len;
 270
 271    for ( ; inc; inc=inc->next ) {
 272       if (inc->pattern) {
 273          if (fnmatch(inc->fname, file, FNM_LEADING_DIR) == 0) {
 274             return 1;
 275          }
 276          continue;
 277       }
 278       /*
 279        * No wild cards. We accept a match to the
 280        *  end of any component.
 281        */
 282       Dmsg2(900, "pat=%s file=%s\n", inc->fname, file);
 283       len = strlen(file);
 284       if (inc->len == len && strcmp(inc->fname, file) == 0) {
 285          return 1;
 286       }
 287       if (inc->len < len && file[inc->len] == '/' &&
 288           strncmp(inc->fname, file, inc->len) == 0) {
 289          return 1;
 290       }
 291       if (inc->len == 1 && inc->fname[0] == '/') {
 292          return 1;
 293       }
 294    }
 295    return 0;
 296 }
 297
 298
 299 /*
 300  * This is the workhorse of excluded_file().
 301  * Determine if the file is excluded or not.
 302  */
 303 static int
 304 file_in_excluded_list(struct s_excluded_file *exc, char *file)
 305 {
 306    if (exc == NULL) {
 307       Dmsg0(900, "exc is NULL\n");
 308    }
 309    for ( ; exc; exc=exc->next ) {
 310       if (fnmatch(exc->fname, file, FNM_PATHNAME) == 0) {
 311          Dmsg2(900, "Match exc pat=%s: file=%s:\n", exc->fname, file);
 312          return 1;
 313       }
 314       Dmsg2(900, "No match exc pat=%s: file=%s:\n", exc->fname, file);
 315    }
 316    return 0;
 317 }
 318
 319
 320 /*
 321  * Walk through the excluded lists to see if this
 322  *  file is excluded, or if it matches a component
 323  *  of an excluded directory.
 324  */
 325
 326 int file_is_excluded(FF_PKT *ff, char *file)
 327 {
 328    char *p;
 329
 330    if (win32_client && file[1] == ':') {
 331       file += 2;
 332    }
 333
 334    if (file_in_excluded_list(ff->excluded_paths_list, file)) {
 335       return 1;
 336    }
 337
 338    /* Try each component */
 339    for (p = file; *p; p++) {
 340       /* Match from the beginning of a component only */
 341       if ((p == file || (*p != '/' && *(p-1) == '/'))
 342            && file_in_excluded_list(ff->excluded_files_list, p)) {
 343          return 1;
 344       }
 345    }
 346    return 0;
 347 }