#include "repository.h"

#include "fileops.h"

#include "config.h"

#include "attr.h"

#include "ignore.h"

#include "git2/oid.h"

#include <ctype.h>

GIT__USE_STRMAP;

const char *git_attr__true = "[internal]__TRUE__";

const char *git_attr__false = "[internal]__FALSE__";

const char *git_attr__unset = "[internal]__UNSET__";

git_attr_t git_attr_value(const char *attr)

{

if (attr == NULL || attr == git_attr__unset)

return GIT_ATTR_UNSPECIFIED_T;

if (attr == git_attr__true)

return GIT_ATTR_TRUE_T;

if (attr == git_attr__false)

return GIT_ATTR_FALSE_T;

return GIT_ATTR_VALUE_T;

}

static int collect_attr_files(

git_vector *files);

int git_attr_get(

const char *name)

{

int error;

git_attr_path path;

git_vector files = GIT_VECTOR_INIT;

size_t i, j;

git_attr_file *file;

git_attr_name attr;

git_attr_rule *rule;

*value = NULL;

if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)

return -1;

if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)

goto cleanup;

attr.name = name;

attr.name_hash = git_attr_file__name_hash(name);

git_vector_foreach(&files, i, file) {

git_attr_file__foreach_matching_rule(file, &path, j, rule) {

size_t pos;

if (!git_vector_bsearch(&pos, &rule->assigns, &attr)) {

*value = ((git_attr_assignment *)git_vector_get(

&rule->assigns, pos))->value;

goto cleanup;

}

}

}

cleanup:

git_vector_free(&files);

git_attr_path__free(&path);

return error;

}

typedef struct {

git_attr_name name;

git_attr_assignment *found;

} attr_get_many_info;

int git_attr_get_many(

const char **names)

{

int error;

git_attr_path path;

git_vector files = GIT_VECTOR_INIT;

size_t i, j, k;

git_attr_file *file;

git_attr_rule *rule;

attr_get_many_info *info = NULL;

size_t num_found = 0;

memset((void *)values, 0, sizeof(const char *) * num_attr);

if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)

return -1;

if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)

goto cleanup;

info = git__calloc(num_attr, sizeof(attr_get_many_info));

GITERR_CHECK_ALLOC(info);

git_vector_foreach(&files, i, file) {

git_attr_file__foreach_matching_rule(file, &path, j, rule) {

for (k = 0; k < num_attr; k++) {

size_t pos;

if (info[k].found != NULL) /* already found assignment */

continue;

if (!info[k].name.name) {

info[k].name.name = names[k];

info[k].name.name_hash = git_attr_file__name_hash(names[k]);

}

if (!git_vector_bsearch(&pos, &rule->assigns, &info[k].name)) {

info[k].found = (git_attr_assignment *)

git_vector_get(&rule->assigns, pos);

values[k] = info[k].found->value;

if (++num_found == num_attr)

goto cleanup;

}

}

}

}

cleanup:

git_vector_free(&files);

git_attr_path__free(&path);

git__free(info);

return error;

}

int git_attr_foreach(

void *payload)

{

int error;

git_attr_path path;

git_vector files = GIT_VECTOR_INIT;

size_t i, j, k;

git_attr_file *file;

git_attr_rule *rule;

git_attr_assignment *assign;

git_strmap *seen = NULL;

if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)

return -1;

if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)

goto cleanup;

seen = git_strmap_alloc();

GITERR_CHECK_ALLOC(seen);

git_vector_foreach(&files, i, file) {

git_attr_file__foreach_matching_rule(file, &path, j, rule) {

git_vector_foreach(&rule->assigns, k, assign) {

/* skip if higher priority assignment was already seen */

if (git_strmap_exists(seen, assign->name))

continue;

git_strmap_insert(seen, assign->name, assign, error);

if (error < 0)

goto cleanup;

error = callback(assign->name, assign->value, payload);

if (error) {

giterr_clear();

error = GIT_EUSER;

goto cleanup;

}

}

}

}

cleanup:

git_strmap_free(seen);

git_vector_free(&files);

git_attr_path__free(&path);

return error;

}

int git_attr_add_macro(

git_repository *repo,

const char *name,

const char *values)

{

int error;

git_attr_rule *macro = NULL;

git_pool *pool;

if (git_attr_cache__init(repo) < 0)

return -1;

macro = git__calloc(1, sizeof(git_attr_rule));

GITERR_CHECK_ALLOC(macro);

pool = &git_repository_attr_cache(repo)->pool;

macro->match.pattern = git_pool_strdup(pool, name);

GITERR_CHECK_ALLOC(macro->match.pattern);

macro->match.length = strlen(macro->match.pattern);

macro->match.flags = GIT_ATTR_FNMATCH_MACRO;

error = git_attr_assignment__parse(repo, pool, &macro->assigns, &values);

if (!error)

error = git_attr_cache__insert_macro(repo, macro);

if (error < 0)

git_attr_rule__free(macro);

return error;

}

bool git_attr_cache__is_cached(

git_repository *repo, git_attr_file_source source, const char *path)

{

git_buf cache_key = GIT_BUF_INIT;

git_strmap *files = git_repository_attr_cache(repo)->files;

const char *workdir = git_repository_workdir(repo);

bool rval;

if (workdir && git__prefixcmp(path, workdir) == 0)

path += strlen(workdir);

if (git_buf_printf(&cache_key, "%d#%s", (int)source, path) < 0)

return false;

rval = git_strmap_exists(files, git_buf_cstr(&cache_key));

git_buf_free(&cache_key);

return rval;

}

static int load_attr_file(

const char **data,

git_futils_filestamp *stamp,

const char *filename)

{

int error;

git_buf content = GIT_BUF_INIT;

error = git_futils_filestamp_check(stamp, filename);

if (error < 0)

return error;

/* if error == 0, then file is up to date. By returning GIT_ENOTFOUND,

if (!error)

return GIT_ENOTFOUND;

error = git_futils_readbuffer(&content, filename);

if (error < 0) {

/* convert error into ENOTFOUND so failed permissions / invalid

return GIT_ENOTFOUND;

/* TODO: once warnings are available, issue a warning callback */

}

*data = git_buf_detach(&content);

return 0;

}

static int load_attr_blob_from_index(

const char *relfile)

{

int error;

size_t pos;

git_index *index;

const git_index_entry *entry;

if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||

(error = git_index_find(&pos, index, relfile)) < 0)

return error;

entry = git_index_get_byindex(index, pos);

if (old_oid && git_oid__cmp(old_oid, &entry->oid) == 0)

return GIT_ENOTFOUND;

if ((error = git_blob_lookup(blob, repo, &entry->oid)) < 0)

return error;

*content = git_blob_rawcontent(*blob);

return 0;

}

static int load_attr_from_cache(

const char *relative_path)

{

git_buf cache_key = GIT_BUF_INIT;

khiter_t cache_pos;

*file = NULL;

if (!cache || !cache->files)

return 0;

if (git_buf_printf(&cache_key, "%d#%s", (int)source, relative_path) < 0)

return -1;

cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr);

git_buf_free(&cache_key);

if (git_strmap_valid_index(cache->files, cache_pos))

*file = git_strmap_value_at(cache->files, cache_pos);

return 0;

}

int git_attr_cache__internal_file(

git_repository *repo,

const char *filename,

git_attr_file **file)

{

int error = 0;

git_attr_cache *cache = git_repository_attr_cache(repo);

khiter_t cache_pos = git_strmap_lookup_index(cache->files, filename);

if (git_strmap_valid_index(cache->files, cache_pos)) {

*file = git_strmap_value_at(cache->files, cache_pos);

return 0;

}

if (git_attr_file__new(file, 0, filename, &cache->pool) < 0)

return -1;

git_strmap_insert(cache->files, (*file)->key + 2, *file, error);

if (error > 0)

error = 0;

return error;

}

int git_attr_cache__push_file(

git_vector *stack)

{

int error = 0;

git_buf path = GIT_BUF_INIT;

const char *workdir = git_repository_workdir(repo);

const char *relfile, *content = NULL;

git_attr_cache *cache = git_repository_attr_cache(repo);

git_attr_file *file = NULL;

git_blob *blob = NULL;

git_futils_filestamp stamp;

assert(filename && stack);

/* join base and path as needed */

if (base != NULL && git_path_root(filename) < 0) {

if (git_buf_joinpath(&path, base, filename) < 0)

return -1;

filename = path.ptr;

}

relfile = filename;

if (workdir && git__prefixcmp(relfile, workdir) == 0)

relfile += strlen(workdir);

/* check cache */

if (load_attr_from_cache(&file, cache, source, relfile) < 0)

return -1;

/* if not in cache, load data, parse, and cache */

if (source == GIT_ATTR_FILE_FROM_FILE) {

git_futils_filestamp_set(

&stamp, file ? &file->cache_data.stamp : NULL);

error = load_attr_file(&content, &stamp, filename);

} else {

error = load_attr_blob_from_index(&content, &blob,

repo, file ? &file->cache_data.oid : NULL, relfile);

}

if (error) {

/* not finding a file is not an error for this function */

if (error == GIT_ENOTFOUND) {

giterr_clear();

error = 0;

}

goto finish;

}

/* if we got here, we have to parse and/or reparse the file */

if (file)

git_attr_file__clear_rules(file);

else {

error = git_attr_file__new(&file, source, relfile, &cache->pool);

if (error < 0)

goto finish;

}

if (parse && (error = parse(repo, parsedata, content, file)) < 0)

goto finish;

git_strmap_insert(cache->files, file->key, file, error); //-V595

if (error > 0)

error = 0;

/* remember "cache buster" file signature */

if (blob)

git_oid_cpy(&file->cache_data.oid, git_object_id((git_object *)blob));

else

git_futils_filestamp_set(&file->cache_data.stamp, &stamp);

finish:

/* push file onto vector if we found one*/

if (!error && file != NULL)

error = git_vector_insert(stack, file);

if (error != 0)

git_attr_file__free(file);

if (blob)

git_blob_free(blob);

else

git__free((void *)content);

git_buf_free(&path);

return error;

}

#define push_attr_file(R,S,B,F) \

git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,git_attr_file__parse_buffer,NULL,(S))

typedef struct {

git_repository *repo;

uint32_t flags;

const char *workdir;

git_index *index;

git_vector *files;

} attr_walk_up_info;

int git_attr_cache__decide_sources(

uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs)

{

int count = 0;

switch (flags & 0x03) {

case GIT_ATTR_CHECK_FILE_THEN_INDEX:

if (has_wd)

srcs[count++] = GIT_ATTR_FILE_FROM_FILE;

if (has_index)

srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;

break;

case GIT_ATTR_CHECK_INDEX_THEN_FILE:

if (has_index)

srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;

if (has_wd)

srcs[count++] = GIT_ATTR_FILE_FROM_FILE;

break;

case GIT_ATTR_CHECK_INDEX_ONLY:

if (has_index)

srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;

break;

}

return count;

}

static int push_one_attr(void *ref, git_buf *path)

{

int error = 0, n_src, i;

attr_walk_up_info *info = (attr_walk_up_info *)ref;

git_attr_file_source src[2];

n_src = git_attr_cache__decide_sources(

info->flags, info->workdir != NULL, info->index != NULL, src);

for (i = 0; !error && i < n_src; ++i)

error = git_attr_cache__push_file(

info->repo, path->ptr, GIT_ATTR_FILE, src[i],

git_attr_file__parse_buffer, NULL, info->files);

return error;

}

static int collect_attr_files(

git_vector *files)

{

int error;

git_buf dir = GIT_BUF_INIT;

const char *workdir = git_repository_workdir(repo);

attr_walk_up_info info;

if (git_attr_cache__init(repo) < 0 ||

git_vector_init(files, 4, NULL) < 0)

return -1;

/* Resolve path in a non-bare repo */

if (workdir != NULL)

error = git_path_find_dir(&dir, path, workdir);

else

error = git_path_dirname_r(&dir, path);

if (error < 0)

goto cleanup;

/* in precendence order highest to lowest:

error = push_attr_file(

repo, files, git_repository_path(repo), GIT_ATTR_FILE_INREPO);

if (error < 0)

goto cleanup;

info.repo = repo;

info.flags = flags;

info.workdir = workdir;

if (git_repository_index__weakptr(&info.index, repo) < 0)

giterr_clear(); /* no error even if there is no index */

info.files = files;

error = git_path_walk_up(&dir, workdir, push_one_attr, &info);

if (error < 0)

goto cleanup;

if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {

error = push_attr_file(

repo, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file);

if (error < 0)

goto cleanup;

}

if ((flags & GIT_ATTR_CHECK_NO_SYSTEM) == 0) {

error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);

if (!error)

error = push_attr_file(repo, files, NULL, dir.ptr);

else if (error == GIT_ENOTFOUND) {

giterr_clear();

error = 0;

}

}

cleanup:

if (error < 0)

git_vector_free(files);

git_buf_free(&dir);

return error;

}

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;

const char *cfgval = NULL;

*out = NULL;

if (!(error = git_config_get_string(&cfgval, cfg, key))) {

/* expand leading ~/ as needed */

if (cfgval && cfgval[0] == '~' && cfgval[1] == '/' &&

!git_futils_find_global_file(&buf, &cfgval[2]))

*out = git_buf_detach(&buf);

else if (cfgval)

*out = git__strdup(cfgval);

} else if (error == GIT_ENOTFOUND) {

giterr_clear();

error = 0;

if (!git_futils_find_xdg_file(&buf, fallback))

*out = git_buf_detach(&buf);

}

git_buf_free(&buf);

return error;

}

int git_attr_cache__init(git_repository *repo)

{

int ret;

git_attr_cache *cache = git_repository_attr_cache(repo);

git_config *cfg;

if (cache->initialized)

return 0;

/* cache config settings for attributes and ignores */

if (git_repository_config__weakptr(&cfg, repo) < 0)

return -1;

ret = attr_cache__lookup_path(

&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);

if (ret < 0)

return ret;

ret = attr_cache__lookup_path(

&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);

if (ret < 0)

return ret;

/* allocate hashtable for attribute and ignore file contents */

if (cache->files == NULL) {

cache->files = git_strmap_alloc();

GITERR_CHECK_ALLOC(cache->files);

}

/* allocate hashtable for attribute macros */

if (cache->macros == NULL) {

cache->macros = git_strmap_alloc();

GITERR_CHECK_ALLOC(cache->macros);

}

/* allocate string pool */

if (git_pool_init(&cache->pool, 1, 0) < 0)

return -1;

cache->initialized = 1;

/* insert default macros */

return git_attr_add_macro(repo, "binary", "-diff -crlf -text");

}

void git_attr_cache_flush(

git_repository *repo)

{

git_attr_cache *cache;

if (!repo)

return;

cache = git_repository_attr_cache(repo);

if (cache->files != NULL) {

git_attr_file *file;

git_strmap_foreach_value(cache->files, file, {

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;

cache->initialized = 0;

}

int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)

{

git_strmap *macros = git_repository_attr_cache(repo)->macros;

int error;

/* TODO: generate warning log if (macro->assigns.length == 0) */

if (macro->assigns.length == 0)

return 0;

git_strmap_insert(macros, macro->match.pattern, macro, error);

return (error < 0) ? -1 : 0;

}

git_attr_rule *git_attr_cache__lookup_macro(

git_repository *repo, const char *name)

{

git_strmap *macros = git_repository_attr_cache(repo)->macros;

khiter_t pos;

pos = git_strmap_lookup_index(macros, name);

if (!git_strmap_valid_index(macros, pos))

return NULL;

return (git_attr_rule *)git_strmap_value_at(macros, pos);

}