dir.c

   1 /*
   2  * This handles recursive filename detection with exclude
   3  * files, index knowledge etc..
   4  *
   5  * Copyright (C) Linus Torvalds, 2005-2006
   6  *               Junio Hamano, 2005-2006
   7  */
   8 #include <dirent.h>
   9 #include <fnmatch.h>
  10
  11 #include "cache.h"
  12 #include "dir.h"
  13
  14 int common_prefix(const char **pathspec)
  15 {
  16         const char *path, *slash, *next;
  17         int prefix;
  18
  19         if (!pathspec)
  20                 return 0;
  21
  22         path = *pathspec;
  23         slash = strrchr(path, '/');
  24         if (!slash)
  25                 return 0;
  26
  27         prefix = slash - path + 1;
  28         while ((next = *++pathspec) != NULL) {
  29                 int len = strlen(next);
  30                 if (len >= prefix && !memcmp(path, next, len))
  31                         continue;
  32                 for (;;) {
  33                         if (!len)
  34                                 return 0;
  35                         if (next[--len] != '/')
  36                                 continue;
  37                         if (memcmp(path, next, len+1))
  38                                 continue;
  39                         prefix = len + 1;
  40                         break;
  41                 }
  42         }
  43         return prefix;
  44 }
  45
  46 static int match_one(const char *match, const char *name, int namelen)
  47 {
  48         int matchlen;
  49
  50         /* If the match was just the prefix, we matched */
  51         matchlen = strlen(match);
  52         if (!matchlen)
  53                 return 1;
  54
  55         /*
  56          * If we don't match the matchstring exactly,
  57          * we need to match by fnmatch
  58          */
  59         if (strncmp(match, name, matchlen))
  60                 return !fnmatch(match, name, 0);
  61
  62         /*
  63          * If we did match the string exactly, we still
  64          * need to make sure that it happened on a path
  65          * component boundary (ie either the last character
  66          * of the match was '/', or the next character of
  67          * the name was '/' or the terminating NUL.
  68          */
  69         return  match[matchlen-1] == '/' ||
  70                 name[matchlen] == '/' ||
  71                 !name[matchlen];
  72 }
  73
  74 int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen)
  75 {
  76         int retval;
  77         const char *match;
  78
  79         name += prefix;
  80         namelen -= prefix;
  81
  82         for (retval = 0; (match = *pathspec++) != NULL; seen++) {
  83                 if (retval & *seen)
  84                         continue;
  85                 match += prefix;
  86                 if (match_one(match, name, namelen)) {
  87                         retval = 1;
  88                         *seen = 1;
  89                 }
  90         }
  91         return retval;
  92 }
  93
  94 void add_exclude(const char *string, const char *base,
  95                  int baselen, struct exclude_list *which)
  96 {
  97         struct exclude *x = xmalloc(sizeof (*x));
  98
  99         x->pattern = string;
 100         x->base = base;
 101         x->baselen = baselen;
 102         if (which->nr == which->alloc) {
 103                 which->alloc = alloc_nr(which->alloc);
 104                 which->excludes = xrealloc(which->excludes,
 105                                            which->alloc * sizeof(x));
 106         }
 107         which->excludes[which->nr++] = x;
 108 }
 109
 110 static int add_excludes_from_file_1(const char *fname,
 111                                     const char *base,
 112                                     int baselen,
 113                                     struct exclude_list *which)
 114 {
 115         struct stat st;
 116         int fd, i;
 117         long size;
 118         char *buf, *entry;
 119
 120         fd = open(fname, O_RDONLY);
 121         if (fd < 0 || fstat(fd, &st) < 0)
 122                 goto err;
 123         size = st.st_size;
 124         if (size == 0) {
 125                 close(fd);
 126                 return 0;
 127         }
 128         buf = xmalloc(size+1);
 129         if (read(fd, buf, size) != size)
 130                 goto err;
 131         close(fd);
 132
 133         buf[size++] = '\n';
 134         entry = buf;
 135         for (i = 0; i < size; i++) {
 136                 if (buf[i] == '\n') {
 137                         if (entry != buf + i && entry[0] != '#') {
 138                                 buf[i - (i && buf[i-1] == '\r')] = 0;
 139                                 add_exclude(entry, base, baselen, which);
 140                         }
 141                         entry = buf + i + 1;
 142                 }
 143         }
 144         return 0;
 145
 146  err:
 147         if (0 <= fd)
 148                 close(fd);
 149         return -1;
 150 }
 151
 152 void add_excludes_from_file(struct dir_struct *dir, const char *fname)
 153 {
 154         if (add_excludes_from_file_1(fname, "", 0,
 155                                      &dir->exclude_list[EXC_FILE]) < 0)
 156                 die("cannot use %s as an exclude file", fname);
 157 }
 158
 159 static int push_exclude_per_directory(struct dir_struct *dir, const char *base, int baselen)
 160 {
 161         char exclude_file[PATH_MAX];
 162         struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
 163         int current_nr = el->nr;
 164
 165         if (dir->exclude_per_dir) {
 166                 memcpy(exclude_file, base, baselen);
 167                 strcpy(exclude_file + baselen, dir->exclude_per_dir);
 168                 add_excludes_from_file_1(exclude_file, base, baselen, el);
 169         }
 170         return current_nr;
 171 }
 172
 173 static void pop_exclude_per_directory(struct dir_struct *dir, int stk)
 174 {
 175         struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
 176
 177         while (stk < el->nr)
 178                 free(el->excludes[--el->nr]);
 179 }
 180
 181 /* Scan the list and let the last match determines the fate.
 182  * Return 1 for exclude, 0 for include and -1 for undecided.
 183  */
 184 static int excluded_1(const char *pathname,
 185                       int pathlen,
 186                       struct exclude_list *el)
 187 {
 188         int i;
 189
 190         if (el->nr) {
 191                 for (i = el->nr - 1; 0 <= i; i--) {
 192                         struct exclude *x = el->excludes[i];
 193                         const char *exclude = x->pattern;
 194                         int to_exclude = 1;
 195
 196                         if (*exclude == '!') {
 197                                 to_exclude = 0;
 198                                 exclude++;
 199                         }
 200
 201                         if (!strchr(exclude, '/')) {
 202                                 /* match basename */
 203                                 const char *basename = strrchr(pathname, '/');
 204                                 basename = (basename) ? basename+1 : pathname;
 205                                 if (fnmatch(exclude, basename, 0) == 0)
 206                                         return to_exclude;
 207                         }
 208                         else {
 209                                 /* match with FNM_PATHNAME:
 210                                  * exclude has base (baselen long) implicitly
 211                                  * in front of it.
 212                                  */
 213                                 int baselen = x->baselen;
 214                                 if (*exclude == '/')
 215                                         exclude++;
 216
 217                                 if (pathlen < baselen ||
 218                                     (baselen && pathname[baselen-1] != '/') ||
 219                                     strncmp(pathname, x->base, baselen))
 220                                     continue;
 221
 222                                 if (fnmatch(exclude, pathname+baselen,
 223                                             FNM_PATHNAME) == 0)
 224                                         return to_exclude;
 225                         }
 226                 }
 227         }
 228         return -1; /* undecided */
 229 }
 230
 231 int excluded(struct dir_struct *dir, const char *pathname)
 232 {
 233         int pathlen = strlen(pathname);
 234         int st;
 235
 236         for (st = EXC_CMDL; st <= EXC_FILE; st++) {
 237                 switch (excluded_1(pathname, pathlen, &dir->exclude_list[st])) {
 238                 case 0:
 239                         return 0;
 240                 case 1:
 241                         return 1;
 242                 }
 243         }
 244         return 0;
 245 }
 246
 247 static void add_name(struct dir_struct *dir, const char *pathname, int len)
 248 {
 249         struct dir_entry *ent;
 250
 251         if (cache_name_pos(pathname, len) >= 0)
 252                 return;
 253
 254         if (dir->nr == dir->alloc) {
 255                 int alloc = alloc_nr(dir->alloc);
 256                 dir->alloc = alloc;
 257                 dir->entries = xrealloc(dir->entries, alloc*sizeof(ent));
 258         }
 259         ent = xmalloc(sizeof(*ent) + len + 1);
 260         ent->len = len;
 261         memcpy(ent->name, pathname, len);
 262         ent->name[len] = 0;
 263         dir->entries[dir->nr++] = ent;
 264 }
 265
 266 static int dir_exists(const char *dirname, int len)
 267 {
 268         int pos = cache_name_pos(dirname, len);
 269         if (pos >= 0)
 270                 return 1;
 271         pos = -pos-1;
 272         if (pos >= active_nr) /* can't */
 273                 return 0;
 274         return !strncmp(active_cache[pos]->name, dirname, len);
 275 }
 276
 277 /*
 278  * Read a directory tree. We currently ignore anything but
 279  * directories, regular files and symlinks. That's because git
 280  * doesn't handle them at all yet. Maybe that will change some
 281  * day.
 282  *
 283  * Also, we ignore the name ".git" (even if it is not a directory).
 284  * That likely will not change.
 285  */
 286 static int read_directory_recursive(struct dir_struct *dir, const char *path, const char *base, int baselen, int check_only)
 287 {
 288         DIR *fdir = opendir(path);
 289         int contents = 0;
 290
 291         if (fdir) {
 292                 int exclude_stk;
 293                 struct dirent *de;
 294                 char fullname[PATH_MAX + 1];
 295                 memcpy(fullname, base, baselen);
 296
 297                 exclude_stk = push_exclude_per_directory(dir, base, baselen);
 298
 299                 while ((de = readdir(fdir)) != NULL) {
 300                         int len;
 301
 302                         if ((de->d_name[0] == '.') &&
 303                             (de->d_name[1] == 0 ||
 304                              !strcmp(de->d_name + 1, ".") ||
 305                              !strcmp(de->d_name + 1, "git")))
 306                                 continue;
 307                         len = strlen(de->d_name);
 308                         memcpy(fullname + baselen, de->d_name, len+1);
 309                         if (excluded(dir, fullname) != dir->show_ignored) {
 310                                 if (!dir->show_ignored || DTYPE(de) != DT_DIR) {
 311                                         continue;
 312                                 }
 313                         }
 314
 315                         switch (DTYPE(de)) {
 316                         struct stat st;
 317                         default:
 318                                 continue;
 319                         case DT_UNKNOWN:
 320                                 if (lstat(fullname, &st))
 321                                         continue;
 322                                 if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
 323                                         break;
 324                                 if (!S_ISDIR(st.st_mode))
 325                                         continue;
 326                                 /* fallthrough */
 327                         case DT_DIR:
 328                                 memcpy(fullname + baselen + len, "/", 2);
 329                                 len++;
 330                                 if (dir->show_other_directories &&
 331                                     !dir_exists(fullname, baselen + len)) {
 332                                         if (dir->hide_empty_directories &&
 333                                             !read_directory_recursive(dir,
 334                                                     fullname, fullname,
 335                                                     baselen + len, 1))
 336                                                 continue;
 337                                         break;
 338                                 }
 339
 340                                 contents += read_directory_recursive(dir,
 341                                         fullname, fullname, baselen + len, 0);
 342                                 continue;
 343                         case DT_REG:
 344                         case DT_LNK:
 345                                 break;
 346                         }
 347                         contents++;
 348                         if (check_only)
 349                                 goto exit_early;
 350                         else
 351                                 add_name(dir, fullname, baselen + len);
 352                 }
 353 exit_early:
 354                 closedir(fdir);
 355
 356                 pop_exclude_per_directory(dir, exclude_stk);
 357         }
 358
 359         return contents;
 360 }
 361
 362 static int cmp_name(const void *p1, const void *p2)
 363 {
 364         const struct dir_entry *e1 = *(const struct dir_entry **)p1;
 365         const struct dir_entry *e2 = *(const struct dir_entry **)p2;
 366
 367         return cache_name_compare(e1->name, e1->len,
 368                                   e2->name, e2->len);
 369 }
 370
 371 int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen)
 372 {
 373         /*
 374          * Make sure to do the per-directory exclude for all the
 375          * directories leading up to our base.
 376          */
 377         if (baselen) {
 378                 if (dir->exclude_per_dir) {
 379                         char *p, *pp = xmalloc(baselen+1);
 380                         memcpy(pp, base, baselen+1);
 381                         p = pp;
 382                         while (1) {
 383                                 char save = *p;
 384                                 *p = 0;
 385                                 push_exclude_per_directory(dir, pp, p-pp);
 386                                 *p++ = save;
 387                                 if (!save)
 388                                         break;
 389                                 p = strchr(p, '/');
 390                                 if (p)
 391                                         p++;
 392                                 else
 393                                         p = pp + baselen;
 394                         }
 395                         free(pp);
 396                 }
 397         }
 398
 399         read_directory_recursive(dir, path, base, baselen, 0);
 400         qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
 401         return dir->nr;
 402 }
 403
 404 int
 405 file_exists(const char *f)
 406 {
 407   struct stat sb;
 408   return stat(f, &sb) == 0;
 409 }