#include "common.h"

#include "config.h"

#include "filebuf.h"

#include "sysdir.h"

#include "buffer.h"

#include "buf_text.h"

#include "git2/config.h"

#include "git2/sys/config.h"

#include "git2/types.h"

#include "strmap.h"

#include "array.h"

#include <ctype.h>

#include <sys/types.h>

#include <regex.h>

typedef struct cvar_t {

} cvar_t;

typedef struct git_config_file_iter {

} git_config_file_iter;

#define MAX_INCLUDE_DEPTH 10

#define CVAR_LIST_HEAD(list) ((list)->head)

#define CVAR_LIST_TAIL(list) ((list)->tail)

#define CVAR_LIST_NEXT(var) ((var)->next)

#define CVAR_LIST_EMPTY(list) ((list)->head == NULL)

#define CVAR_LIST_APPEND(list, var) do {\

if (CVAR_LIST_EMPTY(list)) {\

CVAR_LIST_HEAD(list) = CVAR_LIST_TAIL(list) = var;\

} else {\

CVAR_LIST_NEXT(CVAR_LIST_TAIL(list)) = var;\

CVAR_LIST_TAIL(list) = var;\

}\

} while(0)

#define CVAR_LIST_REMOVE_HEAD(list) do {\

CVAR_LIST_HEAD(list) = CVAR_LIST_NEXT(CVAR_LIST_HEAD(list));\

} while(0)

#define CVAR_LIST_REMOVE_AFTER(var) do {\

CVAR_LIST_NEXT(var) = CVAR_LIST_NEXT(CVAR_LIST_NEXT(var));\

} while(0)

#define CVAR_LIST_FOREACH(list, iter)\

for ((iter) = CVAR_LIST_HEAD(list);\

(iter) != NULL;\

(iter) = CVAR_LIST_NEXT(iter))

#define CVAR_LIST_FOREACH_SAFE(start, iter, tmp)\

for ((iter) = CVAR_LIST_HEAD(vars);\

(iter) && (((tmp) = CVAR_LIST_NEXT(iter) || 1));\

(iter) = (tmp))

struct reader {

};

typedef struct {

git_atomic refcount;

git_strmap *values;

} refcounted_strmap;

typedef struct {

git_config_backend parent;

/* mutex to coordinate accessing the values */

git_mutex values_mutex;

refcounted_strmap *values;

} diskfile_header;

typedef struct {

diskfile_header header;

git_config_level_t level;

git_array_t(struct reader) readers;

bool locked;

git_filebuf locked_buf;

git_buf locked_content;

char *file_path;

} diskfile_backend;

typedef struct {

diskfile_header header;

diskfile_backend *snapshot_from;

} diskfile_readonly_backend;

static int config_read(git_strmap *values, diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);

static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);

static char *escape_value(const char *ptr);

int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);

static int config_snapshot(git_config_backend **out, git_config_backend *in);

static void set_parse_error(struct reader *reader, int col, const char *error_str)

{

giterr_set(GITERR_CONFIG, "failed to parse config file: %s (in %s:%d, column %d)",

error_str, reader->file_path, reader->line_number, col);

}

static int config_error_readonly(void)

{

giterr_set(GITERR_CONFIG, "this backend is read-only");

return -1;

}

static void cvar_free(cvar_t *var)

{

if (var == NULL)

return;

git__free((char*)var->entry->name);

git__free((char *)var->entry->value);

git__free(var->entry);

git__free(var);

}

int git_config_file_normalize_section(char *start, char *end)

{

char *scan;

if (start == end)

return GIT_EINVALIDSPEC;

/* Validate and downcase range */

for (scan = start; *scan; ++scan) {

if (end && scan >= end)

break;

if (isalnum(*scan))

*scan = (char)git__tolower(*scan);

else if (*scan != '-' || scan == start)

return GIT_EINVALIDSPEC;

}

if (scan == start)

return GIT_EINVALIDSPEC;

return 0;

}

static int append_entry(git_strmap *values, cvar_t *var)

{

git_strmap_iter pos;

cvar_t *existing;

int error = 0;

pos = git_strmap_lookup_index(values, var->entry->name);

if (!git_strmap_valid_index(values, pos)) {

git_strmap_insert(values, var->entry->name, var, &error);

} else {

existing = git_strmap_value_at(values, pos);

while (existing->next != NULL) {

existing = existing->next;

}

existing->next = var;

}

if (error > 0)

error = 0;

return error;

}

static void free_vars(git_strmap *values)

{

cvar_t *var = NULL;

if (values == NULL)

return;

git_strmap_foreach_value(values, var,

while (var != NULL) {

cvar_t *next = CVAR_LIST_NEXT(var);

cvar_free(var);

var = next;

});

git_strmap_free(values);

}

static void refcounted_strmap_free(refcounted_strmap *map)

{

if (!map)

return;

if (git_atomic_dec(&map->refcount) != 0)

return;

free_vars(map->values);

git__free(map);

}

static refcounted_strmap *refcounted_strmap_take(diskfile_header *h)

{

refcounted_strmap *map;

if (git_mutex_lock(&h->values_mutex) < 0) {

giterr_set(GITERR_OS, "failed to lock config backend");

return NULL;

}

map = h->values;

git_atomic_inc(&map->refcount);

git_mutex_unlock(&h->values_mutex);

return map;

}

static int refcounted_strmap_alloc(refcounted_strmap **out)

{

refcounted_strmap *map;

int error;

map = git__calloc(1, sizeof(refcounted_strmap));

GITERR_CHECK_ALLOC(map);

git_atomic_set(&map->refcount, 1);

if ((error = git_strmap_alloc(&map->values)) < 0)

git__free(map);

else

*out = map;

return error;

}

static int config_open(git_config_backend *cfg, git_config_level_t level)

{

int res;

struct reader *reader;

diskfile_backend *b = (diskfile_backend *)cfg;

b->level = level;

if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)

return res;

git_array_init(b->readers);

reader = git_array_alloc(b->readers);

if (!reader) {

refcounted_strmap_free(b->header.values);

return -1;

}

memset(reader, 0, sizeof(struct reader));

reader->file_path = git__strdup(b->file_path);

GITERR_CHECK_ALLOC(reader->file_path);

git_buf_init(&reader->buffer, 0);

res = git_futils_readbuffer_updated(

&reader->buffer, b->file_path, &reader->checksum, NULL);

/* It's fine if the file doesn't exist */

if (res == GIT_ENOTFOUND)

return 0;

if (res < 0 || (res = config_read(b->header.values->values, b, reader, level, 0)) < 0) {

refcounted_strmap_free(b->header.values);

b->header.values = NULL;

}

reader = git_array_get(b->readers, 0);

git_buf_free(&reader->buffer);

return res;

}

static int config__refresh(git_config_backend *cfg)

{

refcounted_strmap *values = NULL, *tmp;

diskfile_backend *b = (diskfile_backend *)cfg;

struct reader *reader = NULL;

int error = 0;

if ((error = refcounted_strmap_alloc(&values)) < 0)

goto out;

reader = git_array_get(b->readers, git_array_size(b->readers) - 1);

GITERR_CHECK_ALLOC(reader);

if ((error = config_read(values->values, b, reader, b->level, 0)) < 0)

goto out;

if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {

giterr_set(GITERR_OS, "failed to lock config backend");

goto out;

}

tmp = b->header.values;

b->header.values = values;

values = tmp;

git_mutex_unlock(&b->header.values_mutex);

out:

refcounted_strmap_free(values);

if (reader)

git_buf_free(&reader->buffer);

return error;

}

static int config_refresh(git_config_backend *cfg)

{

int error = 0, updated = 0, any_updated = 0;

diskfile_backend *b = (diskfile_backend *)cfg;

struct reader *reader = NULL;

uint32_t i;

for (i = 0; i < git_array_size(b->readers); i++) {

reader = git_array_get(b->readers, i);

error = git_futils_readbuffer_updated(

&reader->buffer, reader->file_path,

&reader->checksum, &updated);

if (error < 0 && error != GIT_ENOTFOUND)

return error;

if (updated)

any_updated = 1;

}

if (!any_updated)

return (error == GIT_ENOTFOUND) ? 0 : error;

return config__refresh(cfg);

}

static void backend_free(git_config_backend *_backend)

{

diskfile_backend *backend = (diskfile_backend *)_backend;

uint32_t i;

if (backend == NULL)

return;

for (i = 0; i < git_array_size(backend->readers); i++) {

struct reader *r = git_array_get(backend->readers, i);

git__free(r->file_path);

}

git_array_clear(backend->readers);

git__free(backend->file_path);

refcounted_strmap_free(backend->header.values);

git_mutex_free(&backend->header.values_mutex);

git__free(backend);

}

static void config_iterator_free(

git_config_iterator* iter)

{

iter->backend->free(iter->backend);

git__free(iter);

}

static int config_iterator_next(

git_config_entry **entry,

git_config_iterator *iter)

{

git_config_file_iter *it = (git_config_file_iter *) iter;

diskfile_header *h = (diskfile_header *) it->parent.backend;

git_strmap *values = h->values->values;

int err = 0;

cvar_t * var;

if (it->next_var == NULL) {

err = git_strmap_next((void**) &var, &(it->iter), values);

} else {

var = it->next_var;

}

if (err < 0) {

it->next_var = NULL;

return err;

}

*entry = var->entry;

it->next_var = CVAR_LIST_NEXT(var);

return 0;

}

static int config_iterator_new(

git_config_iterator **iter,

struct git_config_backend* backend)

{

diskfile_header *h;

git_config_file_iter *it;

git_config_backend *snapshot;

diskfile_backend *b = (diskfile_backend *) backend;

int error;

if ((error = config_snapshot(&snapshot, backend)) < 0)

return error;

if ((error = snapshot->open(snapshot, b->level)) < 0)

return error;

it = git__calloc(1, sizeof(git_config_file_iter));

GITERR_CHECK_ALLOC(it);

h = (diskfile_header *)snapshot;

/* strmap_begin() is currently a macro returning 0 */

GIT_UNUSED(h);

it->parent.backend = snapshot;

it->iter = git_strmap_begin(h->values);

it->next_var = NULL;

it->parent.next = config_iterator_next;

it->parent.free = config_iterator_free;

*iter = (git_config_iterator *) it;

return 0;

}

static int config_set(git_config_backend *cfg, const char *name, const char *value)

{

diskfile_backend *b = (diskfile_backend *)cfg;

refcounted_strmap *map;

git_strmap *values;

char *key, *esc_value = NULL;

khiter_t pos;

int rval, ret;

if ((rval = git_config__normalize_name(name, &key)) < 0)

return rval;

if ((map = refcounted_strmap_take(&b->header)) == NULL)

return -1;

values = map->values;

/*

pos = git_strmap_lookup_index(values, key);

if (git_strmap_valid_index(values, pos)) {

cvar_t *existing = git_strmap_value_at(values, pos);

if (existing->next != NULL) {

giterr_set(GITERR_CONFIG, "multivar incompatible with simple set");

ret = -1;

goto out;

}

/* don't update if old and new values already match */

if ((!existing->entry->value && !value) ||

(existing->entry->value && value &&

!strcmp(existing->entry->value, value))) {

ret = 0;

goto out;

}

}

/* No early returns due to sanity checks, let's write it out and refresh */

if (value) {

esc_value = escape_value(value);

GITERR_CHECK_ALLOC(esc_value);

}

if ((ret = config_write(b, key, NULL, esc_value)) < 0)

goto out;

ret = config_refresh(cfg);

out:

refcounted_strmap_free(map);

git__free(esc_value);

git__free(key);

return ret;

}

static void release_map(git_config_entry *entry)

{

refcounted_strmap *map = (refcounted_strmap *) entry->payload;

refcounted_strmap_free(map);

}

static int config_get(git_config_backend *cfg, const char *key, git_config_entry **out)

{

diskfile_header *h = (diskfile_header *)cfg;

refcounted_strmap *map;

git_strmap *values;

khiter_t pos;

cvar_t *var;

int error = 0;

if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))

return error;

if ((map = refcounted_strmap_take(h)) == NULL)

return -1;

values = map->values;

pos = git_strmap_lookup_index(values, key);

/* no error message; the config system will write one */

if (!git_strmap_valid_index(values, pos)) {

refcounted_strmap_free(map);

return GIT_ENOTFOUND;

}

var = git_strmap_value_at(values, pos);

while (var->next)

var = var->next;

*out = var->entry;

(*out)->free = release_map;

(*out)->payload = map;

return error;

}

static int config_set_multivar(

git_config_backend *cfg, const char *name, const char *regexp, const char *value)

{

diskfile_backend *b = (diskfile_backend *)cfg;

char *key;

regex_t preg;

int result;

assert(regexp);

if ((result = git_config__normalize_name(name, &key)) < 0)

return result;

result = p_regcomp(&preg, regexp, REG_EXTENDED);

if (result != 0) {

giterr_set_regex(&preg, result);

result = -1;

goto out;

}

/* If we do have it, set call config_write() and reload */

if ((result = config_write(b, key, &preg, value)) < 0)

goto out;

result = config_refresh(cfg);

out:

git__free(key);

regfree(&preg);

return result;

}

static int config_delete(git_config_backend *cfg, const char *name)

{

cvar_t *var;

diskfile_backend *b = (diskfile_backend *)cfg;

refcounted_strmap *map; git_strmap *values;

char *key;

int result;

khiter_t pos;

if ((result = git_config__normalize_name(name, &key)) < 0)

return result;

if ((map = refcounted_strmap_take(&b->header)) == NULL)

return -1;

values = b->header.values->values;

pos = git_strmap_lookup_index(values, key);

git__free(key);

if (!git_strmap_valid_index(values, pos)) {

refcounted_strmap_free(map);

giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);

return GIT_ENOTFOUND;

}

var = git_strmap_value_at(values, pos);

refcounted_strmap_free(map);

if (var->next != NULL) {

giterr_set(GITERR_CONFIG, "cannot delete multivar with a single delete");

return -1;

}

if ((result = config_write(b, var->entry->name, NULL, NULL)) < 0)

return result;

return config_refresh(cfg);

}

static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)

{

diskfile_backend *b = (diskfile_backend *)cfg;

refcounted_strmap *map;

git_strmap *values;

char *key;

regex_t preg;

int result;

khiter_t pos;

if ((result = git_config__normalize_name(name, &key)) < 0)

return result;

if ((map = refcounted_strmap_take(&b->header)) == NULL)

return -1;

values = b->header.values->values;

pos = git_strmap_lookup_index(values, key);

if (!git_strmap_valid_index(values, pos)) {

refcounted_strmap_free(map);

git__free(key);

giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);

return GIT_ENOTFOUND;

}

refcounted_strmap_free(map);

result = p_regcomp(&preg, regexp, REG_EXTENDED);

if (result != 0) {

giterr_set_regex(&preg, result);

result = -1;

goto out;

}

if ((result = config_write(b, key, &preg, NULL)) < 0)

goto out;

result = config_refresh(cfg);

out:

git__free(key);

regfree(&preg);

return result;

}

static int config_snapshot(git_config_backend **out, git_config_backend *in)

{

diskfile_backend *b = (diskfile_backend *) in;

return git_config_file__snapshot(out, b);

}

static int config_lock(git_config_backend *_cfg)

{

diskfile_backend *cfg = (diskfile_backend *) _cfg;

int error;

if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file_path, 0, GIT_CONFIG_FILE_MODE)) < 0)

return error;

error = git_futils_readbuffer(&cfg->locked_content, cfg->file_path);

if (error < 0 && error != GIT_ENOTFOUND) {

git_filebuf_cleanup(&cfg->locked_buf);

return error;

}

cfg->locked = true;

return 0;

}

static int config_unlock(git_config_backend *_cfg, int success)

{

diskfile_backend *cfg = (diskfile_backend *) _cfg;

int error = 0;

if (success) {

git_filebuf_write(&cfg->locked_buf, cfg->locked_content.ptr, cfg->locked_content.size);

error = git_filebuf_commit(&cfg->locked_buf);

}

git_filebuf_cleanup(&cfg->locked_buf);

git_buf_free(&cfg->locked_content);

cfg->locked = false;

return error;

}

int git_config_file__ondisk(git_config_backend **out, const char *path)

{

diskfile_backend *backend;

backend = git__calloc(1, sizeof(diskfile_backend));

GITERR_CHECK_ALLOC(backend);

backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;

git_mutex_init(&backend->header.values_mutex);

backend->file_path = git__strdup(path);

GITERR_CHECK_ALLOC(backend->file_path);

backend->header.parent.open = config_open;

backend->header.parent.get = config_get;

backend->header.parent.set = config_set;

backend->header.parent.set_multivar = config_set_multivar;

backend->header.parent.del = config_delete;

backend->header.parent.del_multivar = config_delete_multivar;

backend->header.parent.iterator = config_iterator_new;

backend->header.parent.snapshot = config_snapshot;

backend->header.parent.lock = config_lock;

backend->header.parent.unlock = config_unlock;

backend->header.parent.free = backend_free;

*out = (git_config_backend *)backend;

return 0;

}

static int config_set_readonly(git_config_backend *cfg, const char *name, const char *value)

{

GIT_UNUSED(cfg);

GIT_UNUSED(name);

GIT_UNUSED(value);

return config_error_readonly();

}

static int config_set_multivar_readonly(

git_config_backend *cfg, const char *name, const char *regexp, const char *value)

{

GIT_UNUSED(cfg);

GIT_UNUSED(name);

GIT_UNUSED(regexp);

GIT_UNUSED(value);

return config_error_readonly();

}

static int config_delete_multivar_readonly(git_config_backend *cfg, const char *name, const char *regexp)

{

GIT_UNUSED(cfg);

GIT_UNUSED(name);

GIT_UNUSED(regexp);

return config_error_readonly();

}

static int config_delete_readonly(git_config_backend *cfg, const char *name)

{

GIT_UNUSED(cfg);

GIT_UNUSED(name);

return config_error_readonly();

}

static int config_lock_readonly(git_config_backend *_cfg)

{

GIT_UNUSED(_cfg);

return config_error_readonly();

}

static int config_unlock_readonly(git_config_backend *_cfg, int success)

{

GIT_UNUSED(_cfg);

GIT_UNUSED(success);

return config_error_readonly();

}

static void backend_readonly_free(git_config_backend *_backend)

{

diskfile_backend *backend = (diskfile_backend *)_backend;

if (backend == NULL)

return;

refcounted_strmap_free(backend->header.values);

git_mutex_free(&backend->header.values_mutex);

git__free(backend);

}

static int config_readonly_open(git_config_backend *cfg, git_config_level_t level)

{

diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;

diskfile_backend *src = b->snapshot_from;

diskfile_header *src_header = &src->header;

refcounted_strmap *src_map;

int error;

if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)

return error;

/* We're just copying data, don't care about the level */

GIT_UNUSED(level);

if ((src_map = refcounted_strmap_take(src_header)) == NULL)

return -1;

b->header.values = src_map;

return 0;

}

int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)

{

diskfile_readonly_backend *backend;

backend = git__calloc(1, sizeof(diskfile_readonly_backend));

GITERR_CHECK_ALLOC(backend);

backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;

git_mutex_init(&backend->header.values_mutex);

backend->snapshot_from = in;

backend->header.parent.readonly = 1;

backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;

backend->header.parent.open = config_readonly_open;

backend->header.parent.get = config_get;

backend->header.parent.set = config_set_readonly;

backend->header.parent.set_multivar = config_set_multivar_readonly;

backend->header.parent.del = config_delete_readonly;

backend->header.parent.del_multivar = config_delete_multivar_readonly;

backend->header.parent.iterator = config_iterator_new;

backend->header.parent.lock = config_lock_readonly;

backend->header.parent.unlock = config_unlock_readonly;

backend->header.parent.free = backend_readonly_free;

*out = (git_config_backend *)backend;

return 0;

}

static int reader_getchar_raw(struct reader *reader)

{

int c;

c = *reader->read_ptr++;

/*

if (c == '\r' && *reader->read_ptr == '\n') {

reader->read_ptr++;

c = '\n';

}

if (c == '\n')

reader->line_number++;

if (c == 0) {

reader->eof = 1;

c = '\0';

}

return c;

}

#define SKIP_WHITESPACE (1 << 1)

#define SKIP_COMMENTS (1 << 2)

static int reader_getchar(struct reader *reader, int flags)

{

const int skip_whitespace = (flags & SKIP_WHITESPACE);

const int skip_comments = (flags & SKIP_COMMENTS);

int c;

assert(reader->read_ptr);

do {

c = reader_getchar_raw(reader);

} while (c != '\n' && c != '\0' && skip_whitespace && git__isspace(c));

if (skip_comments && (c == '#' || c == ';')) {

do {

c = reader_getchar_raw(reader);

} while (c != '\n' && c != '\0');

}

return c;

}

static int reader_peek(struct reader *reader, int flags)

{

void *old_read_ptr;

int old_lineno, old_eof;

int ret;

assert(reader->read_ptr);

old_read_ptr = reader->read_ptr;

old_lineno = reader->line_number;

old_eof = reader->eof;

ret = reader_getchar(reader, flags);

reader->read_ptr = old_read_ptr;

reader->line_number = old_lineno;

reader->eof = old_eof;

return ret;

}

static char *reader_readline(struct reader *reader, bool skip_whitespace)

{

char *line = NULL;

char *line_src, *line_end;

size_t line_len, alloc_len;

line_src = reader->read_ptr;

if (skip_whitespace) {

/* Skip empty empty lines */

while (git__isspace(*line_src))

++line_src;

}

line_end = strchr(line_src, '\n');

/* no newline at EOF */

if (line_end == NULL)

line_end = strchr(line_src, 0);

line_len = line_end - line_src;

if (GIT_ADD_SIZET_OVERFLOW(&alloc_len, line_len, 1) ||

(line = git__malloc(alloc_len)) == NULL) {

return NULL;

}

memcpy(line, line_src, line_len);

do line[line_len] = '\0';

while (line_len-- > 0 && git__isspace(line[line_len]));

if (*line_end == '\n')

line_end++;

if (*line_end == '\0')

reader->eof = 1;

reader->line_number++;

reader->read_ptr = line_end;

return line;

}

static void reader_consume_line(struct reader *reader)

{

char *line_start, *line_end;

line_start = reader->read_ptr;

line_end = strchr(line_start, '\n');

/* No newline at EOF */

if(line_end == NULL){

line_end = strchr(line_start, '\0');

}

if (*line_end == '\n')

line_end++;