contrib/cvs-1.12/src/ignore.c

   1 /* This program is free software; you can redistribute it and/or modify
   2    it under the terms of the GNU General Public License as published by
   3    the Free Software Foundation; either version 2, or (at your option)
   4    any later version.
   5
   6    This program is distributed in the hope that it will be useful,
   7    but WITHOUT ANY WARRANTY; without even the implied warranty of
   8    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9    GNU General Public License for more details.  */
  10
  11 /*
  12  * .cvsignore file support contributed by David G. Grubbs <dgg@odi.com>
  13  */
  14
  15 #include "cvs.h"
  16 #include "getline.h"
  17 #include "lstat.h"
  18
  19 /*
  20  * Ignore file section.
  21  *
  22  *      "!" may be included any time to reset the list (i.e. ignore nothing);
  23  *      "*" may be specified to ignore everything.  It stays as the first
  24  *          element forever, unless a "!" clears it out.
  25  */
  26
  27 static char **ign_list;                 /* List of files to ignore in update
  28                                          * and import */
  29 static char **s_ign_list = NULL;
  30 static int ign_count;                   /* Number of active entries */
  31 static int s_ign_count = 0;
  32 static int ign_size;                    /* This many slots available (plus
  33                                          * one for a NULL) */
  34 static int ign_hold = -1;               /* Index where first "temporary" item
  35                                          * is held */
  36
  37 const char *ign_default = ". .. core RCSLOG tags TAGS RCS SCCS .make.state\
  38  .nse_depinfo #* .#* cvslog.* ,* CVS CVS.adm .del-* *.a *.olb *.o *.obj\
  39  *.so *.Z *~ *.old *.elc *.ln *.bak *.BAK *.orig *.rej *.exe _$* *$";
  40
  41 #define IGN_GROW 16                     /* grow the list by 16 elements at a
  42                                          * time */
  43
  44 /* Nonzero if we have encountered an -I ! directive, which means one should
  45    no longer ask the server about what is in CVSROOTADM_IGNORE.  */
  46 int ign_inhibit_server;
  47
  48
  49
  50 /*
  51  * To the "ignore list", add the hard-coded default ignored wildcards above,
  52  * the wildcards found in $CVSROOT/CVSROOT/cvsignore, the wildcards found in
  53  * ~/.cvsignore and the wildcards found in the CVSIGNORE environment
  54  * variable.
  55  */
  56 void
  57 ign_setup (void)
  58 {
  59     char *home_dir;
  60     char *tmp;
  61
  62     ign_inhibit_server = 0;
  63
  64     /* Start with default list and special case */
  65     tmp = xstrdup (ign_default);
  66     ign_add (tmp, 0);
  67     free (tmp);
  68
  69     /* The client handles another way, by (after it does its own ignore file
  70        processing, and only if !ign_inhibit_server), letting the server
  71        know about the files and letting it decide whether to ignore
  72        them based on CVSROOOTADM_IGNORE.  */
  73     if (!current_parsed_root->isremote)
  74     {
  75         char *file = Xasprintf ("%s/%s/%s", current_parsed_root->directory,
  76                                 CVSROOTADM, CVSROOTADM_IGNORE);
  77         /* Then add entries found in repository, if it exists */
  78         ign_add_file (file, 0);
  79         free (file);
  80     }
  81
  82     /* Then add entries found in home dir, (if user has one) and file exists */
  83     home_dir = get_homedir ();
  84     /* If we can't find a home directory, ignore ~/.cvsignore.  This may
  85        make tracking down problems a bit of a pain, but on the other
  86        hand it might be obnoxious to complain when CVS will function
  87        just fine without .cvsignore (and many users won't even know what
  88        .cvsignore is).  */
  89     if (home_dir)
  90     {
  91         char *file = strcat_filename_onto_homedir (home_dir, CVSDOTIGNORE);
  92         ign_add_file (file, 0);
  93         free (file);
  94     }
  95
  96     /* Then add entries found in CVSIGNORE environment variable. */
  97     ign_add (getenv (IGNORE_ENV), 0);
  98
  99     /* Later, add ignore entries found in -I arguments */
 100 }
 101
 102
 103
 104 /*
 105  * Open a file and read lines, feeding each line to a line parser. Arrange
 106  * for keeping a temporary list of wildcards at the end, if the "hold"
 107  * argument is set.
 108  */
 109 void
 110 ign_add_file (char *file, int hold)
 111 {
 112     FILE *fp;
 113     char *line = NULL;
 114     size_t line_allocated = 0;
 115
 116     /* restore the saved list (if any) */
 117     if (s_ign_list != NULL)
 118     {
 119         int i;
 120
 121         for (i = 0; i < s_ign_count; i++)
 122             ign_list[i] = s_ign_list[i];
 123         ign_count = s_ign_count;
 124         ign_list[ign_count] = NULL;
 125
 126         s_ign_count = 0;
 127         free (s_ign_list);
 128         s_ign_list = NULL;
 129     }
 130
 131     /* is this a temporary ignore file? */
 132     if (hold)
 133     {
 134         /* re-set if we had already done a temporary file */
 135         if (ign_hold >= 0)
 136         {
 137             int i;
 138
 139             for (i = ign_hold; i < ign_count; i++)
 140                 free (ign_list[i]);
 141             ign_count = ign_hold;
 142             ign_list[ign_count] = NULL;
 143         }
 144         else
 145         {
 146             ign_hold = ign_count;
 147         }
 148     }
 149
 150     /* load the file */
 151     fp = CVS_FOPEN (file, "r");
 152     if (fp == NULL)
 153     {
 154         if (! existence_error (errno))
 155             error (0, errno, "cannot open %s", file);
 156         return;
 157     }
 158     while (getline (&line, &line_allocated, fp) >= 0)
 159         ign_add (line, hold);
 160     if (ferror (fp))
 161         error (0, errno, "cannot read %s", file);
 162     if (fclose (fp) < 0)
 163         error (0, errno, "cannot close %s", file);
 164     free (line);
 165 }
 166
 167
 168
 169 /* Parse a line of space-separated wildcards and add them to the list. */
 170 void
 171 ign_add (char *ign, int hold)
 172 {
 173     if (!ign || !*ign)
 174         return;
 175
 176     for (; *ign; ign++)
 177     {
 178         char *mark;
 179         char save;
 180
 181         /* ignore whitespace before the token */
 182         if (isspace ((unsigned char) *ign))
 183             continue;
 184
 185         /* If we have used up all the space, add some more.  Do this before
 186            processing `!', since an "empty" list still contains the `CVS'
 187            entry.  */
 188         if (ign_count >= ign_size)
 189         {
 190             ign_size += IGN_GROW;
 191             ign_list = xnrealloc (ign_list, ign_size + 1, sizeof (char *));
 192         }
 193
 194         /*
 195          * if we find a single character !, we must re-set the ignore list
 196          * (saving it if necessary).  We also catch * as a special case in a
 197          * global ignore file as an optimization
 198          */
 199         if ((!*(ign+1) || isspace ((unsigned char) *(ign+1)))
 200             && (*ign == '!' || *ign == '*'))
 201         {
 202             if (!hold)
 203             {
 204                 /* permanently reset the ignore list */
 205                 int i;
 206
 207                 for (i = 0; i < ign_count; i++)
 208                     free (ign_list[i]);
 209                 ign_count = 1;
 210                 /* Always ignore the "CVS" directory.  */
 211                 ign_list[0] = xstrdup ("CVS");
 212                 ign_list[1] = NULL;
 213
 214                 /* if we are doing a '!', continue; otherwise add the '*' */
 215                 if (*ign == '!')
 216                 {
 217                     ign_inhibit_server = 1;
 218                     continue;
 219                 }
 220             }
 221             else if (*ign == '!')
 222             {
 223                 /* temporarily reset the ignore list */
 224                 int i;
 225
 226                 if (ign_hold >= 0)
 227                 {
 228                     for (i = ign_hold; i < ign_count; i++)
 229                         free (ign_list[i]);
 230                     ign_hold = -1;
 231                 }
 232                 if (s_ign_list)
 233                 {
 234                     /* Don't save the ignore list twice - if there are two
 235                      * bangs in a local .cvsignore file then we don't want to
 236                      * save the new list the first bang created.
 237                      *
 238                      * We still need to free the "new" ignore list.
 239                      */
 240                     for (i = 0; i < ign_count; i++)
 241                         free (ign_list[i]);
 242                 }
 243                 else
 244                 {
 245                     /* Save the ignore list for later.  */
 246                     s_ign_list = xnmalloc (ign_count, sizeof (char *));
 247                     for (i = 0; i < ign_count; i++)
 248                         s_ign_list[i] = ign_list[i];
 249                     s_ign_count = ign_count;
 250                 }
 251                 ign_count = 1;
 252                     /* Always ignore the "CVS" directory.  */
 253                 ign_list[0] = xstrdup ("CVS");
 254                 ign_list[1] = NULL;
 255                 continue;
 256             }
 257         }
 258
 259         /* find the end of this token */
 260         for (mark = ign; *mark && !isspace ((unsigned char) *mark); mark++)
 261              /* do nothing */ ;
 262
 263         save = *mark;
 264         *mark = '\0';
 265
 266         ign_list[ign_count++] = xstrdup (ign);
 267         ign_list[ign_count] = NULL;
 268
 269         *mark = save;
 270         if (save)
 271             ign = mark;
 272         else
 273             ign = mark - 1;
 274     }
 275 }
 276
 277
 278
 279 /* Return true if the given filename should be ignored by update or import,
 280  * else return false.
 281  */
 282 int
 283 ign_name (char *name)
 284 {
 285     char **cpp = ign_list;
 286
 287     if (cpp == NULL)
 288         return 0;
 289
 290     while (*cpp)
 291         if (CVS_FNMATCH (*cpp++, name, 0) == 0)
 292             return 1;
 293
 294     return 0;
 295 }
 296
 297
 298
 299 /* FIXME: This list of dirs to ignore stuff seems not to be used.
 300    Really?  send_dirent_proc and update_dirent_proc both call
 301    ignore_directory and do_module calls ign_dir_add.  No doubt could
 302    use some documentation/testsuite work.  */
 303
 304 static char **dir_ign_list = NULL;
 305 static int dir_ign_max = 0;
 306 static int dir_ign_current = 0;
 307
 308 /* Add a directory to list of dirs to ignore.  */
 309 void
 310 ign_dir_add (char *name)
 311 {
 312     /* Make sure we've got the space for the entry.  */
 313     if (dir_ign_current <= dir_ign_max)
 314     {
 315         dir_ign_max += IGN_GROW;
 316         dir_ign_list = xnrealloc (dir_ign_list,
 317                                   dir_ign_max + 1, sizeof (char *));
 318     }
 319
 320     dir_ign_list[dir_ign_current++] = xstrdup (name);
 321 }
 322
 323
 324 /* Return nonzero if NAME is part of the list of directories to ignore.  */
 325
 326 int
 327 ignore_directory (const char *name)
 328 {
 329     int i;
 330
 331     if (!dir_ign_list)
 332         return 0;
 333
 334     i = dir_ign_current;
 335     while (i--)
 336     {
 337         if (strncmp (name, dir_ign_list[i], strlen (dir_ign_list[i])+1) == 0)
 338             return 1;
 339     }
 340
 341     return 0;
 342 }
 343
 344
 345
 346 /*
 347  * Process the current directory, looking for files not in ILIST and
 348  * not on the global ignore list for this directory.  If we find one,
 349  * call PROC passing it the name of the file and the update dir.
 350  * ENTRIES is the entries list, which is used to identify known
 351  * directories.  ENTRIES may be NULL, in which case we assume that any
 352  * directory with a CVS administration directory is known.
 353  */
 354 void
 355 ignore_files (List *ilist, List *entries, const char *update_dir,
 356               Ignore_proc proc)
 357 {
 358     int subdirs;
 359     DIR *dirp;
 360     struct dirent *dp;
 361     struct stat sb;
 362     char *file;
 363     const char *xdir;
 364     List *files;
 365     Node *p;
 366
 367     /* Set SUBDIRS if we have subdirectory information in ENTRIES.  */
 368     if (entries == NULL)
 369         subdirs = 0;
 370     else
 371     {
 372         struct stickydirtag *sdtp = entries->list->data;
 373
 374         subdirs = sdtp == NULL || sdtp->subdirs;
 375     }
 376
 377     /* we get called with update_dir set to "." sometimes... strip it */
 378     if (strcmp (update_dir, ".") == 0)
 379         xdir = "";
 380     else
 381         xdir = update_dir;
 382
 383     dirp = CVS_OPENDIR (".");
 384     if (dirp == NULL)
 385     {
 386         error (0, errno, "cannot open current directory");
 387         return;
 388     }
 389
 390     ign_add_file (CVSDOTIGNORE, 1);
 391     wrap_add_file (CVSDOTWRAPPER, 1);
 392
 393     /* Make a list for the files.  */
 394     files = getlist ();
 395
 396     while (errno = 0, (dp = CVS_READDIR (dirp)) != NULL)
 397     {
 398         file = dp->d_name;
 399         if (strcmp (file, ".") == 0 || strcmp (file, "..") == 0)
 400             continue;
 401         if (findnode_fn (ilist, file) != NULL)
 402             continue;
 403         if (subdirs)
 404         {
 405             Node *node;
 406
 407             node = findnode_fn (entries, file);
 408             if (node != NULL
 409                 && ((Entnode *) node->data)->type == ENT_SUBDIR)
 410             {
 411                 char *p;
 412                 int dir;
 413
 414                 /* For consistency with past behaviour, we only ignore
 415                    this directory if there is a CVS subdirectory.
 416                    This will normally be the case, but the user may
 417                    have messed up the working directory somehow.  */
 418                 p = Xasprintf ("%s/%s", file, CVSADM);
 419                 dir = isdir (p);
 420                 free (p);
 421                 if (dir)
 422                     continue;
 423             }
 424         }
 425
 426         /* We could be ignoring FIFOs and other files which are neither
 427            regular files nor directories here.  */
 428         if (ign_name (file))
 429             continue;
 430
 431         if (
 432 #ifdef DT_DIR
 433             dp->d_type != DT_UNKNOWN ||
 434 #endif
 435             lstat (file, &sb) != -1)
 436         {
 437
 438             if (
 439 #ifdef DT_DIR
 440                 dp->d_type == DT_DIR
 441                 || (dp->d_type == DT_UNKNOWN && S_ISDIR (sb.st_mode))
 442 #else
 443                 S_ISDIR (sb.st_mode)
 444 #endif
 445                 )
 446             {
 447                 if (!subdirs)
 448                 {
 449                     char *temp = Xasprintf ("%s/%s", file, CVSADM);
 450                     if (isdir (temp))
 451                     {
 452                         free (temp);
 453                         continue;
 454                     }
 455                     free (temp);
 456                 }
 457             }
 458 #ifdef S_ISLNK
 459             else if (
 460 #ifdef DT_DIR
 461                      dp->d_type == DT_LNK
 462                      || (dp->d_type == DT_UNKNOWN && S_ISLNK (sb.st_mode))
 463 #else
 464                      S_ISLNK (sb.st_mode)
 465 #endif
 466                      )
 467             {
 468                 continue;
 469             }
 470 #endif
 471         }
 472
 473         p = getnode ();
 474         p->type = FILES;
 475         p->key = xstrdup (file);
 476         (void) addnode (files, p);
 477     }
 478     if (errno != 0)
 479         error (0, errno, "error reading current directory");
 480     (void) CVS_CLOSEDIR (dirp);
 481
 482     sortlist (files, fsortcmp);
 483     for (p = files->list->next; p != files->list; p = p->next)
 484         (*proc) (p->key, xdir);
 485     dellist (&files);
 486 }