Changeset 481 for trunk/src/sh_files.c


Ignore:
Timestamp:
Jul 18, 2015, 5:06:52 PM (6 years ago)
Author:
katerina
Message:

Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/sh_files.c

    r465 r481  
    8888#include "sh_inotify.h"
    8989#include "zAVLTree.h"
     90#include "sh_dbIO.h"
    9091
    9192#undef  FIL__
     
    211212}
    212213
     214char * sh_files_parse_input(const char * str_s, size_t * len)
     215{
     216  char  * p;
     217
     218  if (!str_s || *str_s == '\0')
     219    return NULL;
     220
     221  *len = sl_strlen(str_s);
     222
     223  if ( (str_s[0] == '"'  && str_s[*len-1] == '"' ) ||
     224       (str_s[0] == '\'' && str_s[*len-1] == '\'') )
     225    {
     226      if (*len < 3)
     227        return NULL;
     228      --(*len);
     229      p = sh_util_strdup_l(&str_s[1], *len);
     230      p[*len-1] = '\0';
     231      --(*len);
     232    }
     233  else
     234    {
     235      p = sh_util_strdup_l(str_s, *len);
     236    }
     237
     238  p = sh_files_C_dequote(p, len);
     239
     240  return p;
     241}
     242
     243
    213244extern int flag_err_debug;
    214245extern int flag_err_info;
     
    251282  char                  * name;
    252283  int                     class;
    253   unsigned long           check_mask;
     284  unsigned long           check_flags;
    254285  int                     rdepth;
    255286  short                   checked;
     
    322353    SL_RETURN((-1), _("sh_files_setrecursion"));
    323354
    324   if (sh.flag.opts == 1
     355  if (sh.flag.opts == S_TRUE
    325356    reject = 1;
    326357
     
    380411                           tmp);
    381412        }
    382 #ifndef REPLACE_OLD
    383       /* this will tell that we have seen the file, and thus prevent
    384        * deletion from the database, resulting in an incomplete
    385        * message when the file reappears
    386        */
    387       if (sh.flag.checkSum != SH_CHECK_INIT)
    388         sh_hash_set_visited_true(ptr->name);
    389 #else
     413
    390414      if (sh.flag.checkSum != SH_CHECK_INIT)
    391415        sh_hash_set_missing(ptr->name);
    392 #endif
     416
    393417      if (sh.flag.reportonce == S_TRUE)
    394418        SET_SH_FFLAG_REPORTED(ptr->is_reported);
     
    431455                  }
    432456                }
    433 #ifndef REPLACE_OLD
    434               if (sh.flag.checkSum != SH_CHECK_INIT)
    435                 sh_hash_set_visited_true(ptr->name);
    436 #else
     457
    437458              /* delete from database
    438459               */
    439460              if (sh.flag.checkSum != SH_CHECK_INIT)
    440461                sh_hash_set_missing(ptr->name);
    441 #endif
    442462            }
    443463          else
     
    494514
    495515         
    496           if (flag_err_info == SL_TRUE)
     516          if (flag_err_info == S_TRUE)
    497517            {
    498518              char pstr[32];
     
    508528            {
    509529              sh_inotify_add_watch_later(ptr->name, &sh_file_watches, NULL,
    510                                          ptr->class, ptr->check_mask,
     530                                         ptr->class, ptr->check_flags,
    511531                                         SH_INOTIFY_FILE, 0);
    512532            }
     
    514534          BREAKEXIT(sh_files_filecheck);
    515535          tmp_reported = ptr->is_reported; /* fix aliasing warning */
    516           status = sh_files_filecheck (ptr->class, ptr->check_mask, dir, file,
     536          status = sh_files_filecheck (ptr->class, ptr->check_flags, dir, file,
    517537                                       &tmp_reported, 0);
    518538          ptr->is_reported = tmp_reported;
     
    590610}
    591611
    592 static void * sh_dummy_candidate;
     612void * sh_dummy_621_candidate;
    593613
    594614static char * intern_find_morespecific_dir(zAVLTree * tree,
     
    605625    return NULL;
    606626
    607   sh_dummy_candidate = (void *) &candidate;
     627  sh_dummy_621_candidate = (void *) &candidate;
    608628
    609629  SH_MUTEX_LOCK(mutex_zfiles);
     
    10691089
    10701090int sh_files_push_file_int (int class, const char * str_s, size_t len,
    1071                             unsigned long check_mask)
     1091                            unsigned long check_flags)
    10721092{
    10731093  dirstack_t * new_item_ptr;
     
    10851105  new_item_ptr->name           = fileName;
    10861106  new_item_ptr->class          = class;
    1087   new_item_ptr->check_mask     = check_mask;
     1107  new_item_ptr->check_flags     = check_flags;
    10881108  new_item_ptr->rdepth         = 0;
    10891109  new_item_ptr->checked        = S_FALSE;
     
    11221142    {
    11231143      int           reported;
    1124       unsigned long check_mask = sh_files_maskof(class);
     1144      unsigned long check_flags = sh_files_maskof(class);
    11251145
    11261146      if ((sh.flag.inotify & SH_INOTIFY_INSCAN) != 0)
    11271147        {
    1128           sh_files_filecheck (class, check_mask, str_s, NULL,
     1148          sh_files_filecheck (class, check_flags, str_s, NULL,
    11291149                              &reported, 0);
    11301150          if (SH_FFLAG_REPORTED_SET(reported))
    11311151            sh_files_set_file_reported(str_s);
    11321152          sh_inotify_add_watch_later(str_s, &sh_file_watches, NULL,
    1133                                      class, check_mask,
     1153                                     class, check_flags,
    11341154                                     SH_INOTIFY_FILE, 0);
    11351155        }
    11361156
    1137       if (MODI_AUDIT_ENABLED(check_mask))
     1157      if (MODI_AUDIT_ENABLED(check_flags))
    11381158        {
    11391159          sh_audit_mark(str_s);
     
    11441164}
    11451165
    1146 int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_mask);
     1166int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags);
    11471167
    11481168#ifdef HAVE_GLOB_H
     
    11511171  char                  * name;
    11521172  int                     class;
    1153   unsigned long           check_mask;
     1173  unsigned long           check_flags;
    11541174  int                     rdepth;
    11551175  short                   type;
     
    11601180
    11611181static int sh_files_pushglob (int class, int type, const char * p, int rdepth,
    1162                                unsigned long check_mask_in, int flag)
     1182                               unsigned long check_flags_in, int flag)
    11631183{
    11641184  int     globstatus = -1;
     
    11671187
    11681188  volatile int     count = 0;
    1169   volatile unsigned long check_mask = (flag == 0) ? sh_files_maskof(class) : check_mask_in;
     1189  volatile unsigned long check_flags = (flag == 0) ? sh_files_maskof(class) : check_flags_in;
    11701190 
    11711191  SL_ENTER(_("sh_files_pushglob"));
     
    11901210          new_item_ptr->name           = fileName;
    11911211          new_item_ptr->class          = class;
    1192           new_item_ptr->check_mask     = check_mask;
     1212          new_item_ptr->check_flags     = check_flags;
    11931213          new_item_ptr->rdepth         = rdepth;
    11941214          new_item_ptr->type           = type;
     
    12191239            {
    12201240              count += sh_files_push_file_int (class, pglob.gl_pathv[gloop],
    1221                                                sl_strlen(pglob.gl_pathv[gloop]), check_mask);
     1241                                               sl_strlen(pglob.gl_pathv[gloop]), check_flags);
    12221242            }
    12231243          else
     
    12261246
    12271247              count += sh_files_push_dir_int  (class, pglob.gl_pathv[gloop],
    1228                                                sl_strlen(pglob.gl_pathv[gloop]), rdepth, check_mask);
     1248                                               sl_strlen(pglob.gl_pathv[gloop]), rdepth, check_flags);
    12291249            }
    12301250        }
     
    12851305          sh_files_pushglob(testPattern->class, testPattern->type,
    12861306                            testPattern->name, testPattern->rdepth,
    1287                             testPattern->check_mask, 1);
     1307                            testPattern->check_flags, 1);
    12881308        }
    12891309    }
     
    13061326      sh_files_pushglob(testPattern->class, testPattern->type,
    13071327                        testPattern->name, testPattern->rdepth,
    1308                         testPattern->check_mask, 1);
     1328                        testPattern->check_flags, 1);
    13091329    }
    13101330  SH_MUTEX_UNLOCK(mutex_zglob);
     
    13701390   * is the only one -- and will stay the only one
    13711391   */
    1372   if (sh.flag.opts == 1)
     1392  if (sh.flag.opts == S_TRUE)
    13731393    {
    13741394      sh_files_delfilestack ();
     
    13781398    }
    13791399
    1380   if (str_s == NULL || str_s[0] == '\0')
    1381     SL_RETURN((-1),_("sh_files_pushfile"));
    1382 
    1383   len = sl_strlen(str_s);
    1384 
    1385   if ( (str_s[0] == '"'  && str_s[len-1] == '"' ) ||
    1386        (str_s[0] == '\'' && str_s[len-1] == '\'') )
    1387     {
    1388       if (len < 3)
    1389         SL_RETURN((-1),_("sh_files_pushfile"));
    1390       --len;
    1391       p = sh_util_strdup_l(&str_s[1], len);
    1392       p[len-1] = '\0';
    1393       --len;
    1394     }
    1395   else
    1396     {
    1397       p = sh_util_strdup_l(str_s, len);
    1398     }
    1399 
    1400   p = sh_files_C_dequote(p, &len);
     1400  p = sh_files_parse_input(str_s, &len);
    14011401  if (!p || len == 0)
    14021402    SL_RETURN((-1), _("sh_files_pushfile"));
     
    14911491}
    14921492
    1493 static void * sh_dummy_ptr;
     1493void * sh_dummy_1493_ptr;
    14941494
    14951495unsigned long sh_dirs_chk (int which)
     
    15071507  SL_ENTER(_("sh_dirs_chk"));
    15081508
    1509   sh_dummy_ptr = (void *) &ptr;
     1509  sh_dummy_1493_ptr = (void *) &ptr;
    15101510 
    15111511  SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
     
    15361536                  BREAKEXIT(sh_files_filecheck);
    15371537                  tmp_reported = dst_ptr->is_reported;
    1538                   filetype = sh_files_filecheck (dst_ptr->class, dst_ptr->check_mask,
     1538                  filetype = sh_files_filecheck (dst_ptr->class, dst_ptr->check_flags,
    15391539                                                 ptr->name, 
    15401540                                                 NULL,  &tmp_reported, 0);
     
    15551555            {
    15561556              tmp_reported = ptr->is_reported;
    1557               filetype = sh_files_filecheck (ptr->class,  ptr->check_mask,
     1557              filetype = sh_files_filecheck (ptr->class,  ptr->check_flags,
    15581558                                             ptr->name,  NULL,  &tmp_reported, 0);
    15591559              ptr->is_reported = tmp_reported;
     
    15621562
    15631563          BREAKEXIT(sh_files_checkdir);
    1564           status = sh_files_checkdir (ptr->class, ptr->check_mask,
     1564          status = sh_files_checkdir (ptr->class, ptr->check_flags,
    15651565                                      ptr->rdepth, ptr->name,
    15661566                                      ptr->name);
     
    17101710}
    17111711
    1712 int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_mask)
     1712int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags)
    17131713{
    17141714  zAVLTree   * tree;
     
    17261726  new_item_ptr->name           = dirName;
    17271727  new_item_ptr->class          = class;
    1728   new_item_ptr->check_mask     = check_mask;
     1728  new_item_ptr->check_flags     = check_flags;
    17291729  new_item_ptr->rdepth         = rdepth;
    17301730  new_item_ptr->checked        = S_FALSE;
     
    17761776  else
    17771777    {
    1778       if (MODI_AUDIT_ENABLED(check_mask))
     1778      if (MODI_AUDIT_ENABLED(check_flags))
    17791779        {
    17801780          sh_audit_mark(tail);
     
    17941794  SL_ENTER(_("sh_files_pushdir"));
    17951795
    1796   if (sh.flag.opts == 1) {
     1796  if (sh.flag.opts == S_TRUE) {
    17971797    sh_files_delfilestack ();
    17981798    sh_files_deldirstack ();
     
    18001800  }
    18011801
    1802   if (str_s == NULL || str_s[0] == '\0')
     1802  p = sh_files_parse_input(str_s, &len);
     1803  if (!p || len == 0)
    18031804    SL_RETURN((-1),_("sh_files_pushdir"));
    1804 
    1805   len = sl_strlen(str_s);
    1806 
    1807   if ( (str_s[0] == '"'  && str_s[len-1] == '"' ) ||
    1808        (str_s[0] == '\'' && str_s[len-1] == '\'') )
    1809     {
    1810       if (len < 3)
    1811         SL_RETURN((-1),_("sh_files_pushdir"));
    1812       --len;
    1813       p = sh_util_strdup_l(&str_s[1], len);
    1814       p[len-1] = '\0';
    1815       --len;
    1816     }
    1817   else
    1818     {
    1819       p = sh_util_strdup_l(str_s, len);
    1820     }
    1821 
    1822   p = sh_files_C_dequote(p, &len);
    1823   if (!p || len == 0)
    1824     SL_RETURN((-1), _("sh_files_pushdir"));
    18251805
    18261806  if (p[0] != '/')
     
    20482028 *    check the directory inode itself.
    20492029 */
    2050 int sh_files_checkdir (int iclass, unsigned long check_mask,
     2030int sh_files_checkdir (int iclass, unsigned long check_flags,
    20512031                       int idepth, char * iname,
    20522032                       char * relativeName)
     
    20732053  volatile int    class_next;
    20742054  volatile int    file_class_next;
    2075   volatile unsigned long   check_mask_next;
    2076   volatile unsigned long   file_check_mask_next;
     2055  volatile unsigned long   check_flags_next;
     2056  volatile unsigned long   file_check_flags_next;
    20772057
    20782058  volatile int    checked_flag  = S_FALSE;
     
    21142094    }
    21152095
    2116   if (flag_err_info == SL_TRUE)
     2096  if (flag_err_info == S_TRUE)
    21172097    {
    21182098      char pstr[32];
     
    21492129  theFile->attr_string = NULL;
    21502130  theFile->link_path   = NULL;
    2151   theFile->check_mask  = check_mask;
     2131  theFile->check_flags  = check_flags;
    21522132
    21532133  (void) relativeName;
     
    21902170    {
    21912171      sh_inotify_add_watch_later(iname, &sh_file_watches, &status,
    2192                                  iclass, check_mask, SH_INOTIFY_DIR, idepth);
     2172                                 iclass, check_flags, SH_INOTIFY_DIR, idepth);
    21932173    }
    21942174   
     
    23012281    rdepth_next     = rdepth - 1;
    23022282    class_next      = class;
    2303     check_mask_next = check_mask;
     2283    check_flags_next = check_flags;
    23042284    file_class_next = class;
    2305     file_check_mask_next = check_mask;
     2285    file_check_flags_next = check_flags;
    23062286    checked_flag    = -1;
    23072287    cchecked_flag   = -1;
     
    23222302         */
    23232303        file_class_next    = dst_ptr->class;
    2324         file_check_mask_next = dst_ptr->check_mask;
     2304        file_check_flags_next = dst_ptr->check_flags;
    23252305        checked_flag       = dst_ptr->checked;
    23262306        cchecked_flag      = dst_ptr->childs_checked;
     
    23382318             */
    23392319            file_class_next    = dst_ptr->class;
    2340             file_check_mask_next = dst_ptr->check_mask;
     2320            file_check_flags_next = dst_ptr->check_flags;
    23412321            checked_flag       = dst_ptr->checked;
    23422322            cchecked_flag      = dst_ptr->childs_checked;
     
    23552335         */
    23562336        file_class_next    = dst_ptr->class;
    2357         file_check_mask_next = dst_ptr->check_mask;
     2337        file_check_flags_next = dst_ptr->check_flags;
    23582338        checked_flag       = dst_ptr->checked;
    23592339        /* not set, hence always FALSE                   */
     
    24032383         */
    24042384
    2405         checkit = sh_files_filecheck (file_class_next, file_check_mask_next,
     2385        checkit = sh_files_filecheck (file_class_next, file_check_flags_next,
    24062386                                      iname,
    24072387                                      dirlist->sh_d_name,
     
    24532433                rdepth_next   = tmp_ptr->rdepth;
    24542434                class_next    = tmp_ptr->class;
    2455                 check_mask_next = tmp_ptr->check_mask;
     2435                check_flags_next = tmp_ptr->check_flags;
    24562436                /* 28. Aug 2001 reversed
    24572437                 */
     
    24712451                    rdepth_next   = tmp_ptr->rdepth;
    24722452                    class_next    = tmp_ptr->class;
    2473                     check_mask_next = tmp_ptr->check_mask;
     2453                    check_flags_next = tmp_ptr->check_flags;
    24742454                    /* 28. Aug 2001 reversed
    24752455                     */
     
    24912471            if (cchecked_flag == S_FALSE)
    24922472              {
    2493                 sh_files_checkdir (class_next, check_mask_next, rdepth_next,
     2473                sh_files_checkdir (class_next, check_flags_next, rdepth_next,
    24942474                                   tmpcat, dirlist->sh_d_name);
    24952475                /*
     
    24992479              }
    25002480            else if (checked_flag == -1)
    2501               sh_files_checkdir (class_next, check_mask_next, rdepth_next,
     2481              sh_files_checkdir (class_next, check_flags_next, rdepth_next,
    25022482                                 tmpcat, dirlist->sh_d_name);
    25032483           
     
    25322512  } while (dirlist != NULL);
    25332513
    2534   if (flag_err_info == SL_TRUE)
     2514  if (flag_err_info == S_TRUE)
    25352515    {
    25362516      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DSUM,
     
    25762556}
    25772557
     2558void sh_files_fixup_mask (int class, unsigned long * check_flags)
     2559{
     2560  if (class == SH_LEVEL_ALLIGNORE)
     2561    MODI_SET((*check_flags), MODI_ALLIGNORE);
     2562  sh_tiger_get_mask_hashtype(check_flags);
     2563  return;
     2564}
     2565
    25782566int get_the_fd (SL_TICKET ticket);
    25792567
     
    25892577static void * sh_dummy_tmpdir;
    25902578
    2591 ShFileType sh_files_filecheck (int class, unsigned long check_mask,
     2579ShFileType sh_files_filecheck (int class, unsigned long check_flags,
    25922580                               const char * dirName,
    25932581                               const char * infileName,
     
    27012689   */
    27022690  sl_strlcpy (theFile->fullpath, fullpath, PATH_MAX);
    2703   theFile->check_mask    = check_mask /* sh_files_maskof(class) */;
     2691  theFile->check_flags    = check_flags /* sh_files_maskof(class) */;
    27042692  theFile->file_reported = (*reported);
    27052693  theFile->attr_string   = NULL;
     
    27122700                             fileName,
    27132701                             theFile, fileHash, class);
    2714  
     2702
    27152703  if (status != 0)
    27162704    {
     
    27322720  /* report
    27332721   */
    2734   if ((flag_err_debug == SL_TRUE) && (theFile->c_mode[0] == '-'))
     2722  if ((flag_err_debug == S_TRUE) && (theFile->c_mode[0] == '-'))
    27352723    {
    27362724      tmpname = sh_util_safe_name (fullpath); /* fixed in 1.5.4 */
     
    27432731  ++sh.statistics.files_checked;
    27442732     
    2745   if ( sh.flag.checkSum == SH_CHECK_INIT /* && sh.flag.update == S_FALSE */)
    2746     {
    2747       sh_hash_pushdata (theFile, fileHash);
     2733  if ( sh.flag.checkSum == SH_CHECK_INIT)
     2734    {
     2735      if (class == SH_LEVEL_ALLIGNORE)
     2736        MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
     2737      if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
     2738        MODI_SET(theFile->check_flags, MODI_NOCHECK);
     2739      sh_tiger_get_mask_hashtype(&(theFile->check_flags));
     2740      sh_dbIO_data_write (theFile, fileHash);
    27482741    }
    27492742  else if (sh.flag.checkSum == SH_CHECK_CHECK
     
    27522745           )
    27532746    {
     2747      if (sh.flag.update == S_TRUE)
     2748        {
     2749          if (class == SH_LEVEL_ALLIGNORE)
     2750            MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
     2751          if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
     2752            MODI_SET(theFile->check_flags, MODI_NOCHECK);
     2753          sh_tiger_get_mask_hashtype(&(theFile->check_flags));
     2754        }
    27542755      sh_hash_compdata (class, theFile, fileHash, NULL, -1);
    27552756    }
     
    27602761   */
    27612762#if !defined(O_NOATIME)
    2762   if (class == SH_LEVEL_NOIGNORE && (theFile->check_mask & MODI_ATM) != 0)
     2763  if (class == SH_LEVEL_NOIGNORE && (theFile->check_flags & MODI_ATM) != 0)
    27632764    {
    27642765      utime_buf.actime   = (time_t) theFile->atime;
     
    27922793          if (S_TRUE == sh_unix_file_exists (testpath))
    27932794            {
    2794               sh_files_filecheck (class, check_mask, fullpath, rsrc, &dummy, 1);
     2795              sh_files_filecheck (class, check_flags, fullpath, rsrc, &dummy, 1);
    27952796            }
    27962797        }
     
    28602861 */
    28612862int sh_files_search_dir(char * name, int * class,
    2862                         unsigned long *check_mask, int *reported,
     2863                        unsigned long *check_flags, int *reported,
    28632864                        int * rdepth)
    28642865{
     
    28772878  if (item)
    28782879    {
    2879       *check_mask = item->check_mask;
     2880      *check_flags = item->check_flags;
    28802881      *class      = item->class;
    28812882      *reported   = item->is_reported;
     
    28922893  if (item)
    28932894    {
    2894       *check_mask = item->check_mask;
     2895      *check_flags = item->check_flags;
    28952896      *class      = item->class;
    28962897      *reported   = item->is_reported;
     
    29142915          if (0 == fnmatch(testPattern->name, name, FNM_PATHNAME|FNM_PERIOD))
    29152916            {
    2916               *check_mask = testPattern->check_mask;
     2917              *check_flags = testPattern->check_flags;
    29172918              *class      = testPattern->class;
    29182919              *rdepth     = testPattern->rdepth;
     
    29322933
    29332934int sh_files_search_file(char * name, int * class,
    2934                          unsigned long *check_mask, int *reported)
     2935                         unsigned long *check_flags, int *reported)
    29352936{
    29362937  volatile int retval = 0;
     
    29462947  if (item)
    29472948    {
    2948       *check_mask = item->check_mask;
     2949      *check_flags = item->check_flags;
    29492950      *class      = item->class;
    29502951      *reported   = item->is_reported;
     
    29662967                               FNM_PATHNAME|FNM_PERIOD))
    29672968                {
    2968                   *check_mask = testPattern->check_mask;
     2969                  *check_flags = testPattern->check_flags;
    29692970                  *class      = testPattern->class;
    29702971                  retval = 1;
     
    30353036    {
    30363037      if (0 == strcmp(name, pfilL->name) &&
    3037           (pfilL->check_mask & MODI_ATM) == 0 &&
    3038           (pfilL->check_mask & MODI_CTM) == 0 &&
    3039           (pfilL->check_mask & MODI_MTM) == 0)
     3038          (pfilL->check_flags & MODI_ATM) == 0 &&
     3039          (pfilL->check_flags & MODI_CTM) == 0 &&
     3040          (pfilL->check_flags & MODI_MTM) == 0)
    30403041        {
    30413042          retval = 0;
     
    30873088                  (0 == strncmp(pfilL->name, pdirL->name, dlen)))
    30883089                {
    3089                   if ((pdirL->check_mask & MODI_ATM) != 0  ||
    3090                       (pdirL->check_mask & MODI_MTM) != 0  ||
    3091                       (pdirL->check_mask & MODI_CTM) != 0)
     3090                  if ((pdirL->check_flags & MODI_ATM) != 0  ||
     3091                      (pdirL->check_flags & MODI_MTM) != 0  ||
     3092                      (pdirL->check_flags & MODI_CTM) != 0)
    30923093                    {
    30933094                      if (check_file (pdirL->name) != 0)
Note: See TracChangeset for help on using the changeset viewer.