thodg/libgit2/src/attrcache.c

• Show log

  Commit

• Hash : f8346905
  Author :
  Date : 2019-07-12T09:03:33
  

  attr_file: ignore macros defined in subdirectories Right now, we are unconditionally applying all macros found in a gitatttributes file. But quoting gitattributes(5): Custom macro attributes can be defined only in top-level gitattributes files ($GIT_DIR/info/attributes, the .gitattributes file at the top level of the working tree, or the global or system-wide gitattributes files), not in .gitattributes files in working tree subdirectories. The built-in macro attribute "binary" is equivalent to: So gitattribute files in subdirectories of the working tree may explicitly _not_ contain macro definitions, but we do not currently enforce this limitation. This patch introduces a new parameter to the gitattributes parser that tells whether macros are allowed in the current file or not. If set to `false`, we will still parse macros, but silently ignore them instead of adding them to the list of defined macros. Update all callers to correctly determine whether the to-be-parsed file may contain macros or not. Most importantly, when walking up the directory hierarchy, we will only set it to `true` once it reaches the root directory of the repo itself. Add a test that verifies that we are indeed not applying macros from subdirectories. Previous to these changes, the test would've failed.

Download

• src/attrcache.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  
  #include "attrcache.h"
  
  #include "repository.h"
  #include "attr_file.h"
  #include "config.h"
  #include "sysdir.h"
  #include "ignore.h"
  
  GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
  {
  	GIT_UNUSED(cache); /* avoid warning if threading is off */
  
  	if (git_mutex_lock(&cache->lock) < 0) {
  		git_error_set(GIT_ERROR_OS, "unable to get attr cache lock");
  		return -1;
  	}
  	return 0;
  }
  
  GIT_INLINE(void) attr_cache_unlock(git_attr_cache *cache)
  {
  	GIT_UNUSED(cache); /* avoid warning if threading is off */
  	git_mutex_unlock(&cache->lock);
  }
  
  GIT_INLINE(git_attr_file_entry *) attr_cache_lookup_entry(
  	git_attr_cache *cache, const char *path)
  {
  	return git_strmap_get(cache->files, path);
  }
  
  int git_attr_cache__alloc_file_entry(
  	git_attr_file_entry **out,
  	const char *base,
  	const char *path,
  	git_pool *pool)
  {
  	size_t baselen = 0, pathlen = strlen(path);
  	size_t cachesize = sizeof(git_attr_file_entry) + pathlen + 1;
  	git_attr_file_entry *ce;
  
  	if (base != NULL && git_path_root(path) < 0) {
  		baselen = strlen(base);
  		cachesize += baselen;
  
  		if (baselen && base[baselen - 1] != '/')
  			cachesize++;
  	}
  
  	ce = git_pool_mallocz(pool, cachesize);
  	GIT_ERROR_CHECK_ALLOC(ce);
  
  	if (baselen) {
  		memcpy(ce->fullpath, base, baselen);
  
  		if (base[baselen - 1] != '/')
  			ce->fullpath[baselen++] = '/';
  	}
  	memcpy(&ce->fullpath[baselen], path, pathlen);
  
  	ce->path = &ce->fullpath[baselen];
  	*out = ce;
  
  	return 0;
  }
  
  /* call with attrcache locked */
  static int attr_cache_make_entry(
  	git_attr_file_entry **out, git_repository *repo, const char *path)
  {
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_attr_file_entry *entry = NULL;
  	int error;
  
  	if ((error = git_attr_cache__alloc_file_entry(&entry, git_repository_workdir(repo),
  						      path, &cache->pool)) < 0)
  		return error;
  
  	if ((error = git_strmap_set(cache->files, entry->path, entry)) < 0)
  		return error;
  
  	*out = entry;
  	return error;
  }
  
  /* insert entry or replace existing if we raced with another thread */
  static int attr_cache_upsert(git_attr_cache *cache, git_attr_file *file)
  {
  	git_attr_file_entry *entry;
  	git_attr_file *old;
  
  	if (attr_cache_lock(cache) < 0)
  		return -1;
  
  	entry = attr_cache_lookup_entry(cache, file->entry->path);
  
  	GIT_REFCOUNT_OWN(file, entry);
  	GIT_REFCOUNT_INC(file);
  
  	/*
  	 * Replace the existing value if another thread has
  	 * created it in the meantime.
  	 */
  	old = git__swap(entry->file[file->source], file);
  
  	if (old) {
  		GIT_REFCOUNT_OWN(old, NULL);
  		git_attr_file__free(old);
  	}
  
  	attr_cache_unlock(cache);
  	return 0;
  }
  
  static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
  {
  	int error = 0;
  	git_attr_file_entry *entry;
  	git_attr_file *old = NULL;
  
  	if (!file)
  		return 0;
  
  	if ((error = attr_cache_lock(cache)) < 0)
  		return error;
  
  	if ((entry = attr_cache_lookup_entry(cache, file->entry->path)) != NULL)
  		old = git__compare_and_swap(&entry->file[file->source], file, NULL);
  
  	attr_cache_unlock(cache);
  
  	if (old) {
  		GIT_REFCOUNT_OWN(old, NULL);
  		git_attr_file__free(old);
  	}
  
  	return error;
  }
  
  /* Look up cache entry and file.
   * - If entry is not present, create it while the cache is locked.
   * - If file is present, increment refcount before returning it, so the
   *   cache can be unlocked and it won't go away.
   */
  static int attr_cache_lookup(
  	git_attr_file **out_file,
  	git_attr_file_entry **out_entry,
  	git_repository *repo,
  	git_attr_session *attr_session,
  	git_attr_file_source source,
  	const char *base,
  	const char *filename)
  {
  	int error = 0;
  	git_buf path = GIT_BUF_INIT;
  	const char *wd = git_repository_workdir(repo), *relfile;
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_attr_file_entry *entry = NULL;
  	git_attr_file *file = NULL;
  
  	/* join base and path as needed */
  	if (base != NULL && git_path_root(filename) < 0) {
  		git_buf *p = attr_session ? &attr_session->tmp : &path;
  
  		if (git_buf_joinpath(p, base, filename) < 0)
  			return -1;
  
  		filename = p->ptr;
  	}
  
  	relfile = filename;
  	if (wd && !git__prefixcmp(relfile, wd))
  		relfile += strlen(wd);
  
  	/* check cache for existing entry */
  	if ((error = attr_cache_lock(cache)) < 0)
  		goto cleanup;
  
  	entry = attr_cache_lookup_entry(cache, relfile);
  	if (!entry)
  		error = attr_cache_make_entry(&entry, repo, relfile);
  	else if (entry->file[source] != NULL) {
  		file = entry->file[source];
  		GIT_REFCOUNT_INC(file);
  	}
  
  	attr_cache_unlock(cache);
  
  cleanup:
  	*out_file  = file;
  	*out_entry = entry;
  
  	git_buf_dispose(&path);
  	return error;
  }
  
  int git_attr_cache__get(
  	git_attr_file **out,
  	git_repository *repo,
  	git_attr_session *attr_session,
  	git_attr_file_source source,
  	const char *base,
  	const char *filename,
  	git_attr_file_parser parser,
  	bool allow_macros)
  {
  	int error = 0;
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_attr_file_entry *entry = NULL;
  	git_attr_file *file = NULL, *updated = NULL;
  
  	if ((error = attr_cache_lookup(
  			&file, &entry, repo, attr_session, source, base, filename)) < 0)
  		return error;
  
  	/* load file if we don't have one or if existing one is out of date */
  	if (!file || (error = git_attr_file__out_of_date(repo, attr_session, file)) > 0)
  		error = git_attr_file__load(&updated, repo, attr_session, entry, source, parser, allow_macros);
  
  	/* if we loaded the file, insert into and/or update cache */
  	if (updated) {
  		if ((error = attr_cache_upsert(cache, updated)) < 0)
  			git_attr_file__free(updated);
  		else {
  			git_attr_file__free(file); /* offset incref from lookup */
  			file = updated;
  		}
  	}
  
  	/* if file could not be loaded */
  	if (error < 0) {
  		/* remove existing entry */
  		if (file) {
  			attr_cache_remove(cache, file);
  			git_attr_file__free(file); /* offset incref from lookup */
  			file = NULL;
  		}
  		/* no error if file simply doesn't exist */
  		if (error == GIT_ENOTFOUND) {
  			git_error_clear();
  			error = 0;
  		}
  	}
  
  	*out = file;
  	return error;
  }
  
  bool git_attr_cache__is_cached(
  	git_repository *repo,
  	git_attr_file_source source,
  	const char *filename)
  {
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_attr_file_entry *entry;
  	git_strmap *files;
  
  	if (!cache || !(files = cache->files))
  		return false;
  
  	if ((entry = git_strmap_get(files, filename)) == NULL)
  		return false;
  
  	return entry && (entry->file[source] != NULL);
  }
  
  
  static int attr_cache__lookup_path(
  	char **out, git_config *cfg, const char *key, const char *fallback)
  {
  	git_buf buf = GIT_BUF_INIT;
  	int error;
  	git_config_entry *entry = NULL;
  
  	*out = NULL;
  
  	if ((error = git_config__lookup_entry(&entry, cfg, key, false)) < 0)
  		return error;
  
  	if (entry) {
  		const char *cfgval = entry->value;
  
  		/* expand leading ~/ as needed */
  		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/') {
  			if (! (error = git_sysdir_expand_global_file(&buf, &cfgval[2])))
  				*out = git_buf_detach(&buf);
  		} else if (cfgval) {
  			*out = git__strdup(cfgval);
  		}
  	}
  	else if (!git_sysdir_find_xdg_file(&buf, fallback)) {
  		*out = git_buf_detach(&buf);
  	}
  
  	git_config_entry_free(entry);
  	git_buf_dispose(&buf);
  
  	return error;
  }
  
  static void attr_cache__free(git_attr_cache *cache)
  {
  	bool unlock;
  
  	if (!cache)
  		return;
  
  	unlock = (attr_cache_lock(cache) == 0);
  
  	if (cache->files != NULL) {
  		git_attr_file_entry *entry;
  		git_attr_file *file;
  		int i;
  
  		git_strmap_foreach_value(cache->files, entry, {
  			for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; ++i) {
  				if ((file = git__swap(entry->file[i], NULL)) != NULL) {
  					GIT_REFCOUNT_OWN(file, NULL);
  					git_attr_file__free(file);
  				}
  			}
  		});
  		git_strmap_free(cache->files);
  	}
  
  	if (cache->macros != NULL) {
  		git_attr_rule *rule;
  
  		git_strmap_foreach_value(cache->macros, rule, {
  			git_attr_rule__free(rule);
  		});
  		git_strmap_free(cache->macros);
  	}
  
  	git_pool_clear(&cache->pool);
  
  	git__free(cache->cfg_attr_file);
  	cache->cfg_attr_file = NULL;
  
  	git__free(cache->cfg_excl_file);
  	cache->cfg_excl_file = NULL;
  
  	if (unlock)
  		attr_cache_unlock(cache);
  	git_mutex_free(&cache->lock);
  
  	git__free(cache);
  }
  
  int git_attr_cache__init(git_repository *repo)
  {
  	int ret = 0;
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_config *cfg = NULL;
  
  	if (cache)
  		return 0;
  
  	cache = git__calloc(1, sizeof(git_attr_cache));
  	GIT_ERROR_CHECK_ALLOC(cache);
  
  	/* set up lock */
  	if (git_mutex_init(&cache->lock) < 0) {
  		git_error_set(GIT_ERROR_OS, "unable to initialize lock for attr cache");
  		git__free(cache);
  		return -1;
  	}
  
  	if ((ret = git_repository_config_snapshot(&cfg, repo)) < 0)
  		goto cancel;
  
  	/* cache config settings for attributes and ignores */
  	ret = attr_cache__lookup_path(
  		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
  	if (ret < 0)
  		goto cancel;
  
  	ret = attr_cache__lookup_path(
  		&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);
  	if (ret < 0)
  		goto cancel;
  
  	/* allocate hashtable for attribute and ignore file contents,
  	 * hashtable for attribute macros, and string pool
  	 */
  	if ((ret = git_strmap_new(&cache->files)) < 0 ||
  	    (ret = git_strmap_new(&cache->macros)) < 0)
  		goto cancel;
  
  	git_pool_init(&cache->pool, 1);
  
  	cache = git__compare_and_swap(&repo->attrcache, NULL, cache);
  	if (cache)
  		goto cancel; /* raced with another thread, free this but no error */
  
  	git_config_free(cfg);
  
  	/* insert default macros */
  	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
  
  cancel:
  	attr_cache__free(cache);
  	git_config_free(cfg);
  	return ret;
  }
  
  void git_attr_cache_flush(git_repository *repo)
  {
  	git_attr_cache *cache;
  
  	/* this could be done less expensively, but for now, we'll just free
  	 * the entire attrcache and let the next use reinitialize it...
  	 */
  	if (repo && (cache = git__swap(repo->attrcache, NULL)) != NULL)
  		attr_cache__free(cache);
  }
  
  int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
  {
  	git_attr_cache *cache = git_repository_attr_cache(repo);
  	git_attr_rule *preexisting;
  	bool locked = false;
  	int error = 0;
  
  	/*
  	 * Callers assume that if we return success, that the
  	 * macro will have been adopted by the attributes cache.
  	 * Thus, we have to free the macro here if it's not being
  	 * added to the cache.
  	 *
  	 * TODO: generate warning log if (macro->assigns.length == 0)
  	 */
  	if (macro->assigns.length == 0) {
  		git_attr_rule__free(macro);
  		goto out;
  	}
  
  	if ((error = attr_cache_lock(cache)) < 0)
  		goto out;
  	locked = true;
  
  	if ((preexisting = git_strmap_get(cache->macros, macro->match.pattern)) != NULL)
  	    git_attr_rule__free(preexisting);
  
  	if ((error = git_strmap_set(cache->macros, macro->match.pattern, macro)) < 0)
  	    goto out;
  
  out:
  	if (locked)
  		attr_cache_unlock(cache);
  	return error;
  }
  
  git_attr_rule *git_attr_cache__lookup_macro(
  	git_repository *repo, const char *name)
  {
  	git_strmap *macros = git_repository_attr_cache(repo)->macros;
  
  	return git_strmap_get(macros, name);
  }
  

Download