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

   1 /*
   2  * Main routine for finding files on a file system.
   3  *  The heart of the work to find the files on the
   4  *    system is done in find_one.c. Here we have the
   5  *    higher level control as well as the matching
   6  *    routines for the new syntax Options resource.
   7  *
   8  *  Kern E. Sibbald, MM
   9  *
  10  *   Version $Id$
  11  */
  12 /*
  13    Bacula® - The Network Backup Solution
  14
  15    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  16
  17    The main author of Bacula is Kern Sibbald, with contributions from
  18    many others, a complete list can be found in the file AUTHORS.
  19    This program is Free Software; you can redistribute it and/or
  20    modify it under the terms of version two of the GNU General Public
  21    License as published by the Free Software Foundation plus additions
  22    that are listed in the file LICENSE.
  23
  24    This program is distributed in the hope that it will be useful, but
  25    WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  27    General Public License for more details.
  28
  29    You should have received a copy of the GNU General Public License
  30    along with this program; if not, write to the Free Software
  31    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  32    02110-1301, USA.
  33
  34    Bacula® is a registered trademark of John Walker.
  35    The licensor of Bacula is the Free Software Foundation Europe
  36    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  37    Switzerland, email:ftf@fsfeurope.org.
  38 */
  39
  40
  41 #include "bacula.h"
  42 #include "find.h"
  43
  44 int32_t name_max;              /* filename max length */
  45 int32_t path_max;              /* path name max length */
  46
  47 #ifdef DEBUG
  48 #undef bmalloc
  49 #define bmalloc(x) sm_malloc(__FILE__, __LINE__, x)
  50 #endif
  51 static int our_callback(FF_PKT *ff, void *hpkt, bool top_level);
  52 static bool accept_file(FF_PKT *ff);
  53
  54 static const int fnmode = 0;
  55
  56 /*
  57  * Initialize the find files "global" variables
  58  */
  59 FF_PKT *init_find_files()
  60 {
  61   FF_PKT *ff;
  62
  63   ff = (FF_PKT *)bmalloc(sizeof(FF_PKT));
  64   memset(ff, 0, sizeof(FF_PKT));
  65
  66   ff->sys_fname = get_pool_memory(PM_FNAME);
  67
  68    /* Get system path and filename maximum lengths */
  69    path_max = pathconf(".", _PC_PATH_MAX);
  70    if (path_max < 1024) {
  71       path_max = 1024;
  72    }
  73
  74    name_max = pathconf(".", _PC_NAME_MAX);
  75    if (name_max < 1024) {
  76       name_max = 1024;
  77    }
  78    path_max++;                        /* add for EOS */
  79    name_max++;                        /* add for EOS */
  80
  81   Dmsg1(100, "init_find_files ff=%p\n", ff);
  82   return ff;
  83 }
  84
  85 /*
  86  * Set find_files options. For the moment, we only
  87  * provide for full/incremental saves, and setting
  88  * of save_time. For additional options, see above
  89  */
  90 void
  91 set_find_options(FF_PKT *ff, int incremental, time_t save_time)
  92 {
  93   Dmsg0(100, "Enter set_find_options()\n");
  94   ff->incremental = incremental;
  95   ff->save_time = save_time;
  96   Dmsg0(100, "Leave set_find_options()\n");
  97 }
  98
  99 /*
 100  * For VSS we need to know which windows drives
 101  * are used, because we create a snapshot of all used
 102  * drives before operation
 103  *
 104  * the function returns the number of used drives and
 105  * fills "drives" with up to 26 (A..Z) drive names
 106  *
 107  */
 108 int
 109 get_win32_driveletters(FF_PKT *ff, char* szDrives)
 110 {
 111    /* szDrives must be at least 27 bytes long */
 112
 113 #if !defined(HAVE_WIN32)
 114    return 0;
 115 #endif
 116
 117    szDrives[0] = 0; /* make empty */
 118    int nCount = 0;
 119
 120    findFILESET *fileset = ff->fileset;
 121    if (fileset) {
 122       int i;
 123       char *fname;
 124
 125       for (i=0; i<fileset->include_list.size(); i++) {
 126          findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
 127
 128          /* look through all files and check */
 129          foreach_alist(fname, &incexe->name_list) {
 130             /* fname should match x:/ */
 131             if (strlen(fname) >= 2 && B_ISALPHA(fname[0])
 132                && fname[1] == ':') {
 133
 134                /* always add in uppercase */
 135                char ch = toupper(fname[0]);
 136                /* if not found in string, add drive letter */
 137                if (!strchr(szDrives,ch)) {
 138                   szDrives[nCount] = ch;
 139                   szDrives[nCount+1] = 0;
 140                   nCount++;
 141                }
 142             }
 143          }
 144       }
 145    }
 146    return nCount;
 147 }
 148
 149 /*
 150  * Find all specified files (determined by calls to name_add()
 151  * This routine calls the (handle_file) subroutine with all
 152  * sorts of good information for the final disposition of
 153  * the file.
 154  *
 155  * Call this subroutine with a callback subroutine as the first
 156  * argument and a packet as the second argument, this packet
 157  * will be passed back to the callback subroutine as the last
 158  * argument.
 159  *
 160  * The callback subroutine gets called with:
 161  *  arg1 -- the FF_PKT containing filename, link, stat, ftype, flags, etc
 162  *  arg2 -- the user supplied packet
 163  *
 164  */
 165 int
 166 find_files(JCR *jcr, FF_PKT *ff, int callback(FF_PKT *ff_pkt, void *hpkt, bool top_level),
 167            void *his_pkt)
 168 {
 169    ff->callback = callback;
 170
 171    /* This is the new way */
 172    findFILESET *fileset = ff->fileset;
 173    if (fileset) {
 174       int i, j;
 175       ff->flags = 0;
 176       ff->VerifyOpts[0] = 'V';
 177       ff->VerifyOpts[1] = 0;
 178       for (i=0; i<fileset->include_list.size(); i++) {
 179          findINCEXE *incexe = (findINCEXE *)fileset->include_list.get(i);
 180          fileset->incexe = incexe;
 181          /*
 182           * By setting all options, we in effect or the global options
 183           *   which is what we want.
 184           */
 185          for (j=0; j<incexe->opts_list.size(); j++) {
 186             findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 187             ff->flags |= fo->flags;
 188             ff->GZIP_level = fo->GZIP_level;
 189             ff->fstypes = fo->fstype;
 190             ff->drivetypes = fo->drivetype;
 191             bstrncat(ff->VerifyOpts, fo->VerifyOpts, sizeof(ff->VerifyOpts));
 192          }
 193          char *fname;
 194          foreach_alist(fname, &incexe->name_list) {
 195             Dmsg1(100, "F %s\n", fname);
 196             ff->top_fname = fname;
 197             if (find_one_file(jcr, ff, our_callback, his_pkt, ff->top_fname, (dev_t)-1, true) == 0) {
 198                return 0;                  /* error return */
 199             }
 200          }
 201       }
 202    }
 203    return 1;
 204 }
 205
 206 static bool accept_file(FF_PKT *ff)
 207 {
 208    int i, j, k;
 209    int fnm_flags;
 210    findFILESET *fileset = ff->fileset;
 211    findINCEXE *incexe = fileset->incexe;
 212    const char *basename;
 213    int (*match_func)(const char *pattern, const char *string, int flags);
 214
 215    if (ff->flags & FO_ENHANCEDWILD) {
 216       match_func = enh_fnmatch;
 217       if ((basename = last_path_separator(ff->fname)) != NULL)
 218          basename++;
 219       else
 220          basename = ff->fname;
 221    } else {
 222       match_func = fnmatch;
 223       basename = ff->fname;
 224    }
 225
 226    for (j = 0; j < incexe->opts_list.size(); j++) {
 227       findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 228       ff->flags = fo->flags;
 229       ff->GZIP_level = fo->GZIP_level;
 230       ff->reader = fo->reader;
 231       ff->writer = fo->writer;
 232       ff->fstypes = fo->fstype;
 233       ff->drivetypes = fo->drivetype;
 234
 235       fnm_flags = (ff->flags & FO_IGNORECASE) ? FNM_CASEFOLD : 0;
 236       fnm_flags |= (ff->flags & FO_ENHANCEDWILD) ? FNM_PATHNAME : 0;
 237
 238       if (S_ISDIR(ff->statp.st_mode)) {
 239          for (k=0; k<fo->wilddir.size(); k++) {
 240             if (match_func((char *)fo->wilddir.get(k), ff->fname, fnmode|fnm_flags) == 0) {
 241                if (ff->flags & FO_EXCLUDE) {
 242                   Dmsg2(100, "Exclude wilddir: %s file=%s\n", (char *)fo->wilddir.get(k),
 243                      ff->fname);
 244                   return false;       /* reject dir */
 245                }
 246                return true;           /* accept dir */
 247             }
 248          }
 249       } else {
 250          for (k=0; k<fo->wildfile.size(); k++) {
 251             if (match_func((char *)fo->wildfile.get(k), ff->fname, fnmode|fnm_flags) == 0) {
 252                if (ff->flags & FO_EXCLUDE) {
 253                   Dmsg2(100, "Exclude wildfile: %s file=%s\n", (char *)fo->wildfile.get(k),
 254                      ff->fname);
 255                   return false;       /* reject file */
 256                }
 257                return true;           /* accept file */
 258             }
 259          }
 260
 261          for (k=0; k<fo->wildbase.size(); k++) {
 262             if (match_func((char *)fo->wildbase.get(k), basename, fnmode|fnm_flags) == 0) {
 263                if (ff->flags & FO_EXCLUDE) {
 264                   Dmsg2(100, "Exclude wildbase: %s file=%s\n", (char *)fo->wildbase.get(k),
 265                      basename);
 266                   return false;       /* reject file */
 267                }
 268                return true;           /* accept file */
 269             }
 270          }
 271       }
 272       for (k=0; k<fo->wild.size(); k++) {
 273          if (match_func((char *)fo->wild.get(k), ff->fname, fnmode|fnm_flags) == 0) {
 274             if (ff->flags & FO_EXCLUDE) {
 275                Dmsg2(100, "Exclude wild: %s file=%s\n", (char *)fo->wild.get(k),
 276                   ff->fname);
 277                return false;          /* reject file */
 278             }
 279             return true;              /* accept file */
 280          }
 281       }
 282       if (S_ISDIR(ff->statp.st_mode)) {
 283          for (k=0; k<fo->regexdir.size(); k++) {
 284             const int nmatch = 30;
 285             regmatch_t pmatch[nmatch];
 286             if (regexec((regex_t *)fo->regexdir.get(k), ff->fname, nmatch, pmatch,  0) == 0) {
 287                if (ff->flags & FO_EXCLUDE) {
 288                   return false;       /* reject file */
 289                }
 290                return true;           /* accept file */
 291             }
 292          }
 293       } else {
 294          for (k=0; k<fo->regexfile.size(); k++) {
 295             const int nmatch = 30;
 296             regmatch_t pmatch[nmatch];
 297             if (regexec((regex_t *)fo->regexfile.get(k), ff->fname, nmatch, pmatch,  0) == 0) {
 298                if (ff->flags & FO_EXCLUDE) {
 299                   return false;       /* reject file */
 300                }
 301                return true;           /* accept file */
 302             }
 303          }
 304       }
 305       for (k=0; k<fo->regex.size(); k++) {
 306          const int nmatch = 30;
 307          regmatch_t pmatch[nmatch];
 308          if (regexec((regex_t *)fo->regex.get(k), ff->fname, nmatch, pmatch,  0) == 0) {
 309             if (ff->flags & FO_EXCLUDE) {
 310                return false;          /* reject file */
 311             }
 312             return true;              /* accept file */
 313          }
 314       }
 315       /*
 316        * If we have an empty Options clause with exclude, then
 317        *  exclude the file
 318        */
 319       if (ff->flags & FO_EXCLUDE &&
 320           fo->regex.size() == 0     && fo->wild.size() == 0 &&
 321           fo->regexdir.size() == 0  && fo->wilddir.size() == 0 &&
 322           fo->regexfile.size() == 0 && fo->wildfile.size() == 0 &&
 323           fo->wildbase.size() == 0) {
 324          return false;              /* reject file */
 325       }
 326    }
 327
 328    /* Now apply the Exclude { } directive */
 329    for (i=0; i<fileset->exclude_list.size(); i++) {
 330       findINCEXE *incexe = (findINCEXE *)fileset->exclude_list.get(i);
 331       for (j=0; j<incexe->opts_list.size(); j++) {
 332          findFOPTS *fo = (findFOPTS *)incexe->opts_list.get(j);
 333          fnm_flags = (fo->flags & FO_IGNORECASE) ? FNM_CASEFOLD : 0;
 334          for (k=0; k<fo->wild.size(); k++) {
 335             if (fnmatch((char *)fo->wild.get(k), ff->fname, fnmode|fnm_flags) == 0) {
 336                Dmsg1(100, "Reject wild1: %s\n", ff->fname);
 337                return false;          /* reject file */
 338             }
 339          }
 340       }
 341       fnm_flags = (incexe->current_opts != NULL && incexe->current_opts->flags & FO_IGNORECASE)
 342              ? FNM_CASEFOLD : 0;
 343       char *fname;
 344       foreach_alist(fname, &incexe->name_list) {
 345          if (fnmatch(fname, ff->fname, fnmode|fnm_flags) == 0) {
 346             Dmsg1(100, "Reject wild2: %s\n", ff->fname);
 347             return false;          /* reject file */
 348          }
 349       }
 350    }
 351    return true;
 352 }
 353
 354 /*
 355  * The code comes here for each file examined.
 356  * We filter the files, then call the user's callback if
 357  *    the file is included.
 358  */
 359 static int our_callback(FF_PKT *ff, void *hpkt, bool top_level)
 360 {
 361    if (top_level) {
 362       return ff->callback(ff, hpkt, top_level);   /* accept file */
 363    }
 364    switch (ff->type) {
 365    case FT_NOACCESS:
 366    case FT_NOFOLLOW:
 367    case FT_NOSTAT:
 368    case FT_NOCHG:
 369    case FT_ISARCH:
 370    case FT_NORECURSE:
 371    case FT_NOFSCHG:
 372    case FT_INVALIDFS:
 373    case FT_INVALIDDT:
 374    case FT_NOOPEN:
 375 //    return ff->callback(ff, hpkt, top_level);
 376
 377    /* These items can be filtered */
 378    case FT_LNKSAVED:
 379    case FT_REGE:
 380    case FT_REG:
 381    case FT_LNK:
 382    case FT_DIRBEGIN:
 383    case FT_DIREND:
 384    case FT_RAW:
 385    case FT_FIFO:
 386    case FT_SPEC:
 387    case FT_DIRNOCHG:
 388       if (accept_file(ff)) {
 389 //       Dmsg2(000, "Accept file %s; reader=%s\n", ff->fname, NPRT(ff->reader));
 390          return ff->callback(ff, hpkt, top_level);
 391       } else {
 392          Dmsg1(100, "Skip file %s\n", ff->fname);
 393          return -1;                   /* ignore this file */
 394       }
 395
 396    default:
 397       Dmsg1(000, "Unknown FT code %d\n", ff->type);
 398       return 0;
 399    }
 400 }
 401
 402
 403 /*
 404  * Terminate find_files() and release
 405  * all allocated memory
 406  */
 407 int
 408 term_find_files(FF_PKT *ff)
 409 {
 410   int hard_links;
 411
 412   free_pool_memory(ff->sys_fname);
 413   hard_links = term_find_one(ff);
 414   free(ff);
 415   return hard_links;
 416 }