src/ignore.c

   1 #include "git2/ignore.h"
   2 #include "common.h"
   3 #include "ignore.h"
   4 #include "attrcache.h"
   5 #include "path.h"
   6 #include "config.h"
   7 #include "fnmatch.h"
   8
   9 #define GIT_IGNORE_INTERNAL             "[internal]exclude"
  10
  11 #define GIT_IGNORE_DEFAULT_RULES ".\n..\n.git\n"
  12
  13 /**
  14  * A negative ignore pattern can match a positive one without
  15  * wildcards if its pattern equals the tail of the positive
  16  * pattern. Thus
  17  *
  18  * foo/bar
  19  * !bar
  20  *
  21  * would result in foo/bar being unignored again.
  22  */
  23 static int does_negate_pattern(git_attr_fnmatch *rule, git_attr_fnmatch *neg)
  24 {
  25         char *p;
  26
  27         if ((rule->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0
  28                 && (neg->flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0) {
  29                 /*
  30                  * no chance of matching if rule is shorter than
  31                  * the negated one
  32                  */
  33                 if (rule->length < neg->length)
  34                         return false;
  35
  36                 /*
  37                  * shift pattern so its tail aligns with the
  38                  * negated pattern
  39                  */
  40                 p = rule->pattern + rule->length - neg->length;
  41                 if (strcmp(p, neg->pattern) == 0)
  42                         return true;
  43         }
  44
  45         return false;
  46 }
  47
  48 /**
  49  * A negative ignore can only unignore a file which is given explicitly before, thus
  50  *
  51  *    foo
  52  *    !foo/bar
  53  *
  54  * does not unignore 'foo/bar' as it's not in the list. However
  55  *
  56  *    foo/<star>
  57  *    !foo/bar
  58  *
  59  * does unignore 'foo/bar', as it is contained within the 'foo/<star>' rule.
  60  */
  61 static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match)
  62 {
  63         int error = 0;
  64         size_t i;
  65         git_attr_fnmatch *rule;
  66         char *path;
  67         git_buf buf = GIT_BUF_INIT;
  68
  69         *out = 0;
  70
  71         /* path of the file relative to the workdir, so we match the rules in subdirs */
  72         if (match->containing_dir) {
  73                 git_buf_puts(&buf, match->containing_dir);
  74         }
  75         if (git_buf_puts(&buf, match->pattern) < 0)
  76                 return -1;
  77
  78         path = git_buf_detach(&buf);
  79
  80         git_vector_foreach(rules, i, rule) {
  81                 if (!(rule->flags & GIT_ATTR_FNMATCH_HASWILD)) {
  82                         if (does_negate_pattern(rule, match)) {
  83                                 error = 0;
  84                                 *out = 1;
  85                                 goto out;
  86                         }
  87                         else
  88                                 continue;
  89                 }
  90
  91         /*
  92          * If we're dealing with a directory (which we know via the
  93          * strchr() check) we want to use 'dirname/<star>' as the
  94          * pattern so p_fnmatch() honours FNM_PATHNAME
  95          */
  96                 git_buf_clear(&buf);
  97                 if (rule->containing_dir) {
  98                         git_buf_puts(&buf, rule->containing_dir);
  99                 }
 100                 if (!strchr(rule->pattern, '*'))
 101                         error = git_buf_printf(&buf, "%s/*", rule->pattern);
 102                 else
 103                         error = git_buf_puts(&buf, rule->pattern);
 104
 105                 if (error < 0)
 106                         goto out;
 107
 108                 if ((error = p_fnmatch(git_buf_cstr(&buf), path, FNM_PATHNAME)) < 0) {
 109                         giterr_set(GITERR_INVALID, "error matching pattern");
 110                         goto out;
 111                 }
 112
 113                 /* if we found a match, we want to keep this rule */
 114                 if (error != FNM_NOMATCH) {
 115                         *out = 1;
 116                         error = 0;
 117                         goto out;
 118                 }
 119         }
 120
 121         error = 0;
 122
 123 out:
 124         git__free(path);
 125         git_buf_free(&buf);
 126         return error;
 127 }
 128
 129 static int parse_ignore_file(
 130         git_repository *repo, git_attr_file *attrs, const char *data)
 131 {
 132         int error = 0;
 133         int ignore_case = false;
 134         const char *scan = data, *context = NULL;
 135         git_attr_fnmatch *match = NULL;
 136
 137         if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0)
 138                 giterr_clear();
 139
 140         /* if subdir file path, convert context for file paths */
 141         if (attrs->entry &&
 142                 git_path_root(attrs->entry->path) < 0 &&
 143                 !git__suffixcmp(attrs->entry->path, "/" GIT_IGNORE_FILE))
 144                 context = attrs->entry->path;
 145
 146         if (git_mutex_lock(&attrs->lock) < 0) {
 147                 giterr_set(GITERR_OS, "Failed to lock ignore file");
 148                 return -1;
 149         }
 150
 151         while (!error && *scan) {
 152                 int valid_rule = 1;
 153
 154                 if (!match && !(match = git__calloc(1, sizeof(*match)))) {
 155                         error = -1;
 156                         break;
 157                 }
 158
 159                 match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
 160
 161                 if (!(error = git_attr_fnmatch__parse(
 162                         match, &attrs->pool, context, &scan)))
 163                 {
 164                         match->flags |= GIT_ATTR_FNMATCH_IGNORE;
 165
 166                         if (ignore_case)
 167                                 match->flags |= GIT_ATTR_FNMATCH_ICASE;
 168
 169                         scan = git__next_line(scan);
 170
 171                         /* if a negative match doesn't actually do anything, throw it away */
 172                         if (match->flags & GIT_ATTR_FNMATCH_NEGATIVE)
 173                                 error = does_negate_rule(&valid_rule, &attrs->rules, match);
 174
 175                         if (!error && valid_rule)
 176                                 error = git_vector_insert(&attrs->rules, match);
 177                 }
 178
 179                 if (error != 0 || !valid_rule) {
 180                         match->pattern = NULL;
 181
 182                         if (error == GIT_ENOTFOUND)
 183                                 error = 0;
 184                 } else {
 185                         match = NULL; /* vector now "owns" the match */
 186                 }
 187         }
 188
 189         git_mutex_unlock(&attrs->lock);
 190         git__free(match);
 191
 192         return error;
 193 }
 194
 195 static int push_ignore_file(
 196         git_ignores *ignores,
 197         git_vector *which_list,
 198         const char *base,
 199         const char *filename)
 200 {
 201         int error = 0;
 202         git_attr_file *file = NULL;
 203
 204         error = git_attr_cache__get(
 205                 &file, ignores->repo, NULL, GIT_ATTR_FILE__FROM_FILE,
 206                 base, filename, parse_ignore_file);
 207         if (error < 0)
 208                 return error;
 209
 210         if (file != NULL) {
 211                 if ((error = git_vector_insert(which_list, file)) < 0)
 212                         git_attr_file__free(file);
 213         }
 214
 215         return error;
 216 }
 217
 218 static int push_one_ignore(void *payload, const char *path)
 219 {
 220         git_ignores *ign = payload;
 221         ign->depth++;
 222         return push_ignore_file(ign, &ign->ign_path, path, GIT_IGNORE_FILE);
 223 }
 224
 225 static int get_internal_ignores(git_attr_file **out, git_repository *repo)
 226 {
 227         int error;
 228
 229         if ((error = git_attr_cache__init(repo)) < 0)
 230                 return error;
 231
 232         error = git_attr_cache__get(
 233                 out, repo, NULL, GIT_ATTR_FILE__IN_MEMORY, NULL, GIT_IGNORE_INTERNAL, NULL);
 234
 235         /* if internal rules list is empty, insert default rules */
 236         if (!error && !(*out)->rules.length)
 237                 error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES);
 238
 239         return error;
 240 }
 241
 242 int git_ignore__for_path(
 243         git_repository *repo,
 244         const char *path,
 245         git_ignores *ignores)
 246 {
 247         int error = 0;
 248         const char *workdir = git_repository_workdir(repo);
 249
 250         assert(ignores && path);
 251
 252         memset(ignores, 0, sizeof(*ignores));
 253         ignores->repo = repo;
 254
 255         /* Read the ignore_case flag */
 256         if ((error = git_repository__cvar(
 257                         &ignores->ignore_case, repo, GIT_CVAR_IGNORECASE)) < 0)
 258                 goto cleanup;
 259
 260         if ((error = git_attr_cache__init(repo)) < 0)
 261                 goto cleanup;
 262
 263         /* given a unrooted path in a non-bare repo, resolve it */
 264         if (workdir && git_path_root(path) < 0)
 265                 error = git_path_find_dir(&ignores->dir, path, workdir);
 266         else
 267                 error = git_buf_joinpath(&ignores->dir, path, "");
 268         if (error < 0)
 269                 goto cleanup;
 270
 271         if (workdir && !git__prefixcmp(ignores->dir.ptr, workdir))
 272                 ignores->dir_root = strlen(workdir);
 273
 274         /* set up internals */
 275         if ((error = get_internal_ignores(&ignores->ign_internal, repo)) < 0)
 276                 goto cleanup;
 277
 278         /* load .gitignore up the path */
 279         if (workdir != NULL) {
 280                 error = git_path_walk_up(
 281                         &ignores->dir, workdir, push_one_ignore, ignores);
 282                 if (error < 0)
 283                         goto cleanup;
 284         }
 285
 286         /* load .git/info/exclude */
 287         error = push_ignore_file(
 288                 ignores, &ignores->ign_global,
 289                 git_repository_path(repo), GIT_IGNORE_FILE_INREPO);
 290         if (error < 0)
 291                 goto cleanup;
 292
 293         /* load core.excludesfile */
 294         if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
 295                 error = push_ignore_file(
 296                         ignores, &ignores->ign_global, NULL,
 297                         git_repository_attr_cache(repo)->cfg_excl_file);
 298
 299 cleanup:
 300         if (error < 0)
 301                 git_ignore__free(ignores);
 302
 303         return error;
 304 }
 305
 306 int git_ignore__push_dir(git_ignores *ign, const char *dir)
 307 {
 308         if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
 309                 return -1;
 310
 311         ign->depth++;
 312
 313         return push_ignore_file(
 314                 ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
 315 }
 316
 317 int git_ignore__pop_dir(git_ignores *ign)
 318 {
 319         if (ign->ign_path.length > 0) {
 320                 git_attr_file *file = git_vector_last(&ign->ign_path);
 321                 const char *start = file->entry->path, *end;
 322
 323                 /* - ign->dir looks something like "/home/user/a/b/" (or "a/b/c/d/")
 324                  * - file->path looks something like "a/b/.gitignore
 325                  *
 326                  * We are popping the last directory off ign->dir.  We also want
 327                  * to remove the file from the vector if the popped directory
 328                  * matches the ignore path.  We need to test if the "a/b" part of
 329                  * the file key matches the path we are about to pop.
 330                  */
 331
 332                 if ((end = strrchr(start, '/')) != NULL) {
 333                         size_t dirlen = (end - start) + 1;
 334                         const char *relpath = ign->dir.ptr + ign->dir_root;
 335                         size_t pathlen = ign->dir.size - ign->dir_root;
 336
 337                         if (pathlen == dirlen && !memcmp(relpath, start, dirlen)) {
 338                                 git_vector_pop(&ign->ign_path);
 339                                 git_attr_file__free(file);
 340                         }
 341                 }
 342         }
 343
 344         if (--ign->depth > 0) {
 345                 git_buf_rtruncate_at_char(&ign->dir, '/');
 346                 git_path_to_dir(&ign->dir);
 347         }
 348
 349         return 0;
 350 }
 351
 352 void git_ignore__free(git_ignores *ignores)
 353 {
 354         unsigned int i;
 355         git_attr_file *file;
 356
 357         git_attr_file__free(ignores->ign_internal);
 358
 359         git_vector_foreach(&ignores->ign_path, i, file) {
 360                 git_attr_file__free(file);
 361                 ignores->ign_path.contents[i] = NULL;
 362         }
 363         git_vector_free(&ignores->ign_path);
 364
 365         git_vector_foreach(&ignores->ign_global, i, file) {
 366                 git_attr_file__free(file);
 367                 ignores->ign_global.contents[i] = NULL;
 368         }
 369         git_vector_free(&ignores->ign_global);
 370
 371         git_buf_free(&ignores->dir);
 372 }
 373
 374 static bool ignore_lookup_in_rules(
 375         int *ignored, git_attr_file *file, git_attr_path *path)
 376 {
 377         size_t j;
 378         git_attr_fnmatch *match;
 379
 380         git_vector_rforeach(&file->rules, j, match) {
 381                 if (git_attr_fnmatch__match(match, path)) {
 382                         *ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0) ?
 383                                 GIT_IGNORE_TRUE : GIT_IGNORE_FALSE;
 384                         return true;
 385                 }
 386         }
 387
 388         return false;
 389 }
 390
 391 int git_ignore__lookup(
 392         int *out, git_ignores *ignores, const char *pathname, git_dir_flag dir_flag)
 393 {
 394         unsigned int i;
 395         git_attr_file *file;
 396         git_attr_path path;
 397
 398         *out = GIT_IGNORE_NOTFOUND;
 399
 400         if (git_attr_path__init(
 401                 &path, pathname, git_repository_workdir(ignores->repo), dir_flag) < 0)
 402                 return -1;
 403
 404         /* first process builtins - success means path was found */
 405         if (ignore_lookup_in_rules(out, ignores->ign_internal, &path))
 406                 goto cleanup;
 407
 408         /* next process files in the path */
 409         git_vector_foreach(&ignores->ign_path, i, file) {
 410                 if (ignore_lookup_in_rules(out, file, &path))
 411                         goto cleanup;
 412         }
 413
 414         /* last process global ignores */
 415         git_vector_foreach(&ignores->ign_global, i, file) {
 416                 if (ignore_lookup_in_rules(out, file, &path))
 417                         goto cleanup;
 418         }
 419
 420 cleanup:
 421         git_attr_path__free(&path);
 422         return 0;
 423 }
 424
 425 int git_ignore_add_rule(git_repository *repo, const char *rules)
 426 {
 427         int error;
 428         git_attr_file *ign_internal = NULL;
 429
 430         if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
 431                 return error;
 432
 433         error = parse_ignore_file(repo, ign_internal, rules);
 434         git_attr_file__free(ign_internal);
 435
 436         return error;
 437 }
 438
 439 int git_ignore_clear_internal_rules(git_repository *repo)
 440 {
 441         int error;
 442         git_attr_file *ign_internal;
 443
 444         if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
 445                 return error;
 446
 447         if (!(error = git_attr_file__clear_rules(ign_internal, true)))
 448                 error = parse_ignore_file(
 449                         repo, ign_internal, GIT_IGNORE_DEFAULT_RULES);
 450
 451         git_attr_file__free(ign_internal);
 452         return error;
 453 }
 454
 455 int git_ignore_path_is_ignored(
 456         int *ignored,
 457         git_repository *repo,
 458         const char *pathname)
 459 {
 460         int error;
 461         const char *workdir;
 462         git_attr_path path;
 463         git_ignores ignores;
 464         unsigned int i;
 465         git_attr_file *file;
 466
 467         assert(ignored && pathname);
 468
 469         workdir = repo ? git_repository_workdir(repo) : NULL;
 470
 471         memset(&path, 0, sizeof(path));
 472         memset(&ignores, 0, sizeof(ignores));
 473
 474         if ((error = git_attr_path__init(&path, pathname, workdir, GIT_DIR_FLAG_UNKNOWN)) < 0 ||
 475                 (error = git_ignore__for_path(repo, path.path, &ignores)) < 0)
 476                 goto cleanup;
 477
 478         while (1) {
 479                 /* first process builtins - success means path was found */
 480                 if (ignore_lookup_in_rules(ignored, ignores.ign_internal, &path))
 481                         goto cleanup;
 482
 483                 /* next process files in the path */
 484                 git_vector_foreach(&ignores.ign_path, i, file) {
 485                         if (ignore_lookup_in_rules(ignored, file, &path))
 486                                 goto cleanup;
 487                 }
 488
 489                 /* last process global ignores */
 490                 git_vector_foreach(&ignores.ign_global, i, file) {
 491                         if (ignore_lookup_in_rules(ignored, file, &path))
 492                                 goto cleanup;
 493                 }
 494
 495                 /* move up one directory */
 496                 if (path.basename == path.path)
 497                         break;
 498                 path.basename[-1] = '\0';
 499                 while (path.basename > path.path && *path.basename != '/')
 500                         path.basename--;
 501                 if (path.basename > path.path)
 502                         path.basename++;
 503                 path.is_dir = 1;
 504
 505                 if ((error = git_ignore__pop_dir(&ignores)) < 0)
 506                         break;
 507         }
 508
 509         *ignored = 0;
 510
 511 cleanup:
 512         git_attr_path__free(&path);
 513         git_ignore__free(&ignores);
 514         return error;
 515 }
 516
 517 int git_ignore__check_pathspec_for_exact_ignores(
 518         git_repository *repo,
 519         git_vector *vspec,
 520         bool no_fnmatch)
 521 {
 522         int error = 0;
 523         size_t i;
 524         git_attr_fnmatch *match;
 525         int ignored;
 526         git_buf path = GIT_BUF_INIT;
 527         const char *wd, *filename;
 528         git_index *idx;
 529
 530         if ((error = git_repository__ensure_not_bare(
 531                         repo, "validate pathspec")) < 0 ||
 532                 (error = git_repository_index(&idx, repo)) < 0)
 533                 return error;
 534
 535         wd = git_repository_workdir(repo);
 536
 537         git_vector_foreach(vspec, i, match) {
 538                 /* skip wildcard matches (if they are being used) */
 539                 if ((match->flags & GIT_ATTR_FNMATCH_HASWILD) != 0 &&
 540                         !no_fnmatch)
 541                         continue;
 542
 543                 filename = match->pattern;
 544
 545                 /* if file is already in the index, it's fine */
 546                 if (git_index_get_bypath(idx, filename, 0) != NULL)
 547                         continue;
 548
 549                 if ((error = git_buf_joinpath(&path, wd, filename)) < 0)
 550                         break;
 551
 552                 /* is there a file on disk that matches this exactly? */
 553                 if (!git_path_isfile(path.ptr))
 554                         continue;
 555
 556                 /* is that file ignored? */
 557                 if ((error = git_ignore_path_is_ignored(&ignored, repo, filename)) < 0)
 558                         break;
 559
 560                 if (ignored) {
 561                         giterr_set(GITERR_INVALID, "pathspec contains ignored file '%s'",
 562                                 filename);
 563                         error = GIT_EINVALIDSPEC;
 564                         break;
 565                 }
 566         }
 567
 568         git_index_free(idx);
 569         git_buf_free(&path);
 570
 571         return error;
 572 }
 573