#include "common.h"

#include "config.h"

#include "fileops.h"

#include "filebuf.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>

GIT__USE_STRMAP;

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_config_backend parent;

git_strmap *values;

git_array_t(struct reader) readers;

char *file_path;

git_config_level_t level;

} diskfile_backend;

static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);

static int parse_variable(struct reader *reader, char **var_name, char **var_value);

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

static char *escape_value(const char *ptr);

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 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);

}

static int cvar_length(cvar_t *var)

{

int length = 0;

while (var) {

length++;

var = var->next;

}

return length;

}

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)tolower(*scan);

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

return GIT_EINVALIDSPEC;

}

if (scan == start)

return GIT_EINVALIDSPEC;

return 0;

}

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 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;

b->values = git_strmap_alloc();

GITERR_CHECK_ALLOC(b->values);

git_array_init(b->readers);

reader = git_array_alloc(b->readers);

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->file_mtime, &reader->file_size, NULL);

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

if (res == GIT_ENOTFOUND)

return 0;

if (res < 0 || (res = config_parse(b, reader, level, 0)) < 0) {

free_vars(b->values);

b->values = NULL;

}

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

git_buf_free(&reader->buffer);

return res;

}

static int config_refresh(git_config_backend *cfg)

{

int res = 0, updated = 0, any_updated = 0;

diskfile_backend *b = (diskfile_backend *)cfg;

git_strmap *old_values;

struct reader *reader = NULL;

uint32_t i;

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

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

res = git_futils_readbuffer_updated(

&reader->buffer, reader->file_path, &reader->file_mtime, &reader->file_size, &updated);

if (res < 0)

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

if (updated)

any_updated = 1;

}

if (!any_updated)

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

/* need to reload - store old values and prep for reload */

old_values = b->values;

b->values = git_strmap_alloc();

GITERR_CHECK_ALLOC(b->values);

if ((res = config_parse(b, reader, b->level, 0)) < 0) {

free_vars(b->values);

b->values = old_values;

} else {

free_vars(old_values);

}

git_buf_free(&reader->buffer);

return res;

}

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);

free_vars(backend->values);

git__free(backend);

}

static void config_iterator_free(

git_config_iterator* iter)

{

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_backend *b = (diskfile_backend *) it->parent.backend;

int err = 0;

cvar_t * var;

if (it->next_var == NULL) {

err = git_strmap_next((void**) &var, &(it->iter), b->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_backend *b = (diskfile_backend *)backend;

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

GIT_UNUSED(b);

GITERR_CHECK_ALLOC(it);

it->parent.backend = backend;

it->iter = git_strmap_begin(b->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)

{

cvar_t *var = NULL, *old_var = NULL;

diskfile_backend *b = (diskfile_backend *)cfg;

char *key, *esc_value = NULL;

khiter_t pos;

int rval, ret;

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

return rval;

/*

pos = git_strmap_lookup_index(b->values, key);

if (git_strmap_valid_index(b->values, pos)) {

cvar_t *existing = git_strmap_value_at(b->values, pos);

char *tmp = NULL;

git__free(key);

if (existing->next != NULL) {

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

return -1;

}

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

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

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

return 0;

if (value) {

tmp = git__strdup(value);

GITERR_CHECK_ALLOC(tmp);

esc_value = escape_value(value);

GITERR_CHECK_ALLOC(esc_value);

}

git__free((void *)existing->entry->value);

existing->entry->value = tmp;

ret = config_write(b, existing->entry->name, NULL, esc_value);

git__free(esc_value);

return ret;

}

var = git__malloc(sizeof(cvar_t));

GITERR_CHECK_ALLOC(var);

memset(var, 0x0, sizeof(cvar_t));

var->entry = git__malloc(sizeof(git_config_entry));

GITERR_CHECK_ALLOC(var->entry);

memset(var->entry, 0x0, sizeof(git_config_entry));

var->entry->name = key;

var->entry->value = NULL;

if (value) {

var->entry->value = git__strdup(value);

GITERR_CHECK_ALLOC(var->entry->value);

esc_value = escape_value(value);

GITERR_CHECK_ALLOC(esc_value);

}

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

git__free(esc_value);

cvar_free(var);

return ret;

}

git__free(esc_value);

git_strmap_insert2(b->values, key, var, old_var, rval);

if (rval < 0)

return -1;

if (old_var != NULL)

cvar_free(old_var);

return 0;

}

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

{

diskfile_backend *b = (diskfile_backend *)cfg;

khiter_t pos = git_strmap_lookup_index(b->values, key);

cvar_t *var;

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

if (!git_strmap_valid_index(b->values, pos))

return GIT_ENOTFOUND;

var = git_strmap_value_at(b->values, pos);

while (var->next)

var = var->next;

*out = var->entry;

return 0;

}

static int config_set_multivar(

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

{

int replaced = 0;

cvar_t *var, *newvar;

diskfile_backend *b = (diskfile_backend *)cfg;

char *key;

regex_t preg;

int result;

khiter_t pos;

assert(regexp);

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

return result;

pos = git_strmap_lookup_index(b->values, key);

if (!git_strmap_valid_index(b->values, pos)) {

/* If we don't have it, behave like a normal set */

result = config_set(cfg, name, value);

git__free(key);

return result;

}

var = git_strmap_value_at(b->values, pos);

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

if (result < 0) {

git__free(key);

giterr_set_regex(&preg, result);

regfree(&preg);

return -1;

}

for (;;) {

if (regexec(&preg, var->entry->value, 0, NULL, 0) == 0) {

char *tmp = git__strdup(value);

GITERR_CHECK_ALLOC(tmp);

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

var->entry->value = tmp;

replaced = 1;

}

if (var->next == NULL)

break;

var = var->next;

}

/* If we've reached the end of the variables and we haven't found it yet, we need to append it */

if (!replaced) {

newvar = git__malloc(sizeof(cvar_t));

GITERR_CHECK_ALLOC(newvar);

memset(newvar, 0x0, sizeof(cvar_t));

newvar->entry = git__malloc(sizeof(git_config_entry));

GITERR_CHECK_ALLOC(newvar->entry);

memset(newvar->entry, 0x0, sizeof(git_config_entry));

newvar->entry->name = git__strdup(var->entry->name);

GITERR_CHECK_ALLOC(newvar->entry->name);

newvar->entry->value = git__strdup(value);

GITERR_CHECK_ALLOC(newvar->entry->value);

newvar->entry->level = var->entry->level;

var->next = newvar;

}

result = config_write(b, key, &preg, value);

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;

char *key;

int result;

khiter_t pos;

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

return result;

pos = git_strmap_lookup_index(b->values, key);

git__free(key);

if (!git_strmap_valid_index(b->values, pos)) {

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

return GIT_ENOTFOUND;

}

var = git_strmap_value_at(b->values, pos);

if (var->next != NULL) {

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

return -1;

}

git_strmap_delete_at(b->values, pos);

result = config_write(b, var->entry->name, NULL, NULL);

cvar_free(var);

return result;

}

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

{

cvar_t *var, *prev = NULL, *new_head = NULL;

cvar_t **to_delete;

int to_delete_idx;

diskfile_backend *b = (diskfile_backend *)cfg;

char *key;

regex_t preg;

int result;

khiter_t pos;

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

return result;

pos = git_strmap_lookup_index(b->values, key);

if (!git_strmap_valid_index(b->values, pos)) {

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

git__free(key);

return GIT_ENOTFOUND;

}

var = git_strmap_value_at(b->values, pos);

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

if (result < 0) {

git__free(key);

giterr_set_regex(&preg, result);

regfree(&preg);

return -1;

}

to_delete = git__calloc(cvar_length(var), sizeof(cvar_t *));

GITERR_CHECK_ALLOC(to_delete);

to_delete_idx = 0;

while (var != NULL) {

cvar_t *next = var->next;

if (regexec(&preg, var->entry->value, 0, NULL, 0) == 0) {

// If we are past the head, reattach previous node to next one,

// otherwise set the new head for the strmap.

if (prev != NULL) {

prev->next = next;

} else {

new_head = next;

}

to_delete[to_delete_idx++] = var;

} else {

prev = var;

}

var = next;

}

if (new_head != NULL) {

git_strmap_set_value_at(b->values, pos, new_head);

} else {

git_strmap_delete_at(b->values, pos);

}

if (to_delete_idx > 0)

result = config_write(b, key, &preg, NULL);

while (to_delete_idx-- > 0)

cvar_free(to_delete[to_delete_idx]);

git__free(key);

git__free(to_delete);

regfree(&preg);

return result;

}

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->parent.version = GIT_CONFIG_BACKEND_VERSION;

backend->file_path = git__strdup(path);

GITERR_CHECK_ALLOC(backend->file_path);

backend->parent.open = config_open;

backend->parent.get = config_get;

backend->parent.set = config_set;

backend->parent.set_multivar = config_set_multivar;

backend->parent.del = config_delete;

backend->parent.del_multivar = config_delete_multivar;

backend->parent.iterator = config_iterator_new;

backend->parent.refresh = config_refresh;

backend->parent.free = backend_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 = '\n';

}

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 (skip_whitespace && git__isspace(c) &&

!reader->eof);

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

do {

c = reader_getchar_raw(reader);

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

}

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;

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;

line = git__malloc(line_len + 1);

if (line == 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++;

if (*line_end == '\0')

reader->eof = 1;

reader->line_number++;

reader->read_ptr = line_end;

}

GIT_INLINE(int) config_keychar(int c)

{

return isalnum(c) || c == '-';

}

static int parse_section_header_ext(struct reader *reader, const char *line, const char *base_name, char **section_name)

{

int c, rpos;

char *first_quote, *last_quote;

git_buf buf = GIT_BUF_INIT;

/*

first_quote = strchr(line, '"');

last_quote = strrchr(line, '"');

if (last_quote - first_quote == 0) {

set_parse_error(reader, 0, "Missing closing quotation mark in section header");

return -1;

}

git_buf_grow(&buf, strlen(base_name) + last_quote - first_quote + 2);

git_buf_printf(&buf, "%s.", base_name);

rpos = 0;

line = first_quote;

c = line[++rpos];

/*

do {

switch (c) {

case 0:

set_parse_error(reader, 0, "Unexpected end-of-line in section header");

git_buf_free(&buf);

return -1;

case '"':

goto end_parse;

case '\\':

c = line[++rpos];

if (c == 0) {

set_parse_error(reader, rpos, "Unexpected end-of-line in section header");

git_buf_free(&buf);

return -1;

}

default:

break;

}

git_buf_putc(&buf, (char)c);

c = line[++rpos];

} while (line + rpos < last_quote);

end_parse:

if (line[rpos] != '"' || line[rpos + 1] != ']') {

set_parse_error(reader, rpos, "Unexpected text after closing quotes");

git_buf_free(&buf);

return -1;

}

*section_name = git_buf_detach(&buf);

return 0;

}

static int parse_section_header(struct reader *reader, char **section_out)

{

char *name, *name_end;

int name_length, c, pos;

int result;

char *line;

line = reader_readline(reader, true);

if (line == NULL)

return -1;

/* find the end of the variable's name */

name_end = strrchr(line, ']');

if (name_end == NULL) {

git__free(line);

set_parse_error(reader, 0, "Missing ']' in section header");

return -1;

}

name = (char *)git__malloc((size_t)(name_end - line) + 1);

GITERR_CHECK_ALLOC(name);

name_length = 0;

pos = 0;

/* Make sure we were given a section header */

c = line[pos++];

assert(c == '[');

c = line[pos++];

do {

if (git__isspace(c)){

name[name_length] = '\0';

result = parse_section_header_ext(reader, line, name, section_out);

git__free(line);

git__free(name);

return result;

}

if (!config_keychar(c) && c != '.') {

set_parse_error(reader, pos, "Unexpected character in header");

goto fail_parse;

}

name[name_length++] = (char) tolower(c);

} while ((c = line[pos++]) != ']');

if (line[pos - 1] != ']') {

set_parse_error(reader, pos, "Unexpected end of file");

goto fail_parse;

}

git__free(line);

name[name_length] = 0;

*section_out = name;

return 0;

fail_parse:

git__free(line);

git__free(name);

return -1;

}

static int skip_bom(struct reader *reader)

{

git_bom_t bom;

int bom_offset = git_buf_text_detect_bom(&bom,

&reader->buffer, reader->read_ptr - reader->buffer.ptr);

if (bom == GIT_BOM_UTF8)

reader->read_ptr += bom_offset;

/* TODO: reference implementation is pretty stupid with BoM */

return 0;

}

static int strip_comments(char *line, int in_quotes)

{

int quote_count = in_quotes;

char *ptr;

for (ptr = line; *ptr; ++ptr) {

if (ptr[0] == '"' && ptr > line && ptr[-1] != '\\')

quote_count++;

if ((ptr[0] == ';' || ptr[0] == '#') && (quote_count % 2) == 0) {

ptr[0] = '\0';

break;

}

}

/* skip any space at the end */

if (ptr > line && git__isspace(ptr[-1])) {

ptr--;

}

ptr[0] = '\0';

return quote_count;

}