#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 <ctype.h>

#include <sys/types.h>

#include <regex.h>

GIT__USE_STRMAP;

typedef struct cvar_t {

struct cvar_t *next;

git_config_entry *entry;

} cvar_t;

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

typedef struct {

git_config_backend parent;

git_strmap *values;

struct {

git_buf buffer;

char *read_ptr;

int line_number;

int eof;

} reader;

char *file_path;

time_t file_mtime;

size_t file_size;

git_config_level_t level;

} diskfile_backend;

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

static int parse_variable(diskfile_backend *cfg, 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(diskfile_backend *backend, int col, const char *error_str)

{

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

error_str, backend->file_path, backend->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);

}

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

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

return GIT_EINVALIDSPEC;

}

if (scan == start)

return GIT_EINVALIDSPEC;

return 0;

}

static int normalize_name(const char *in, char **out)

{

char *name, *fdot, *ldot;

assert(in && out);

name = git__strdup(in);

GITERR_CHECK_ALLOC(name);

fdot = strchr(name, '.');

ldot = strrchr(name, '.');

if (fdot == NULL || fdot == name || ldot == NULL || !ldot[1])

goto invalid;

/* Validate and downcase up to first dot and after last dot */

if (git_config_file_normalize_section(name, fdot) < 0 ||

git_config_file_normalize_section(ldot + 1, NULL) < 0)

goto invalid;

/* If there is a middle range, make sure it doesn't have newlines */

while (fdot < ldot)

if (*fdot++ == '\n')

goto invalid;

*out = name;

return 0;

invalid:

git__free(name);

giterr_set(GITERR_CONFIG, "Invalid config item name '%s'", in);

return GIT_EINVALIDSPEC;

}

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;

diskfile_backend *b = (diskfile_backend *)cfg;

b->level = level;

b->values = git_strmap_alloc();

GITERR_CHECK_ALLOC(b->values);

git_buf_init(&b->reader.buffer, 0);

res = git_futils_readbuffer_updated(

&b->reader.buffer, b->file_path, &b->file_mtime, &b->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, level)) < 0) {

free_vars(b->values);

b->values = NULL;

}

git_buf_free(&b->reader.buffer);

return res;

}

static int config_refresh(git_config_backend *cfg)

{

int res, updated = 0;

diskfile_backend *b = (diskfile_backend *)cfg;

git_strmap *old_values;

res = git_futils_readbuffer_updated(

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

if (res < 0 || !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, b->level)) < 0) {

free_vars(b->values);

b->values = old_values;

} else {

free_vars(old_values);

}

git_buf_free(&b->reader.buffer);

return res;

}

static void backend_free(git_config_backend *_backend)

{

diskfile_backend *backend = (diskfile_backend *)_backend;

if (backend == NULL)

return;

git__free(backend->file_path);

free_vars(backend->values);

git__free(backend);

}

static int file_foreach(

void *data)

{

diskfile_backend *b = (diskfile_backend *)backend;

cvar_t *var, *next_var;

const char *key;

regex_t regex;

int result = 0;

if (!b->values)

return 0;

if (regexp != NULL) {

if ((result = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {

giterr_set_regex(&regex, result);

regfree(&regex);

return -1;

}

}

git_strmap_foreach(b->values, key, var,

for (; var != NULL; var = next_var) {

next_var = CVAR_LIST_NEXT(var);

/* skip non-matching keys if regexp was provided */

if (regexp && regexec(&regex, key, 0, NULL, 0) != 0)

continue;

/* abort iterator on non-zero return value */

if (fn(var->entry, data)) {

giterr_clear();

result = GIT_EUSER;

goto cleanup;

}

}

);

cleanup:

if (regexp != NULL)

regfree(&regex);

return result;

}

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 = 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 (config_write(b, key, NULL, esc_value) < 0) {

git__free(esc_value);

cvar_free(var);

return -1;

}

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 *name, const git_config_entry **out)

{

diskfile_backend *b = (diskfile_backend *)cfg;

char *key;

khiter_t pos;

int error;

if ((error = normalize_name(name, &key)) < 0)

return error;

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

git__free(key);

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

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

return GIT_ENOTFOUND;

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

return 0;

}

static int config_get_multivar(

void *data)

{

cvar_t *var;

diskfile_backend *b = (diskfile_backend *)cfg;

char *key;

khiter_t pos;

int error;

if ((error = normalize_name(name, &key)) < 0)

return error;

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

git__free(key);

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

return GIT_ENOTFOUND;

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

if (regex_str != NULL) {

regex_t regex;

int result;

/* regex matching; build the regex */

result = regcomp(&regex, regex_str, REG_EXTENDED);

if (result < 0) {

giterr_set_regex(&regex, result);

regfree(&regex);

return -1;

}

/* and throw the callback only on the variables that

do {

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

/* early termination by the user is not an error;

if (fn(var->entry, data) < 0)

break;

}

var = var->next;

} while (var != NULL);

regfree(&regex);

} else {

/* no regex; go through all the variables */

do {

/* early termination by the user is not an error;

if (fn(var->entry, data) < 0)

break;

var = var->next;

} while (var != NULL);

}

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

}

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.get_multivar = config_get_multivar;

backend->parent.set = config_set;

backend->parent.set_multivar = config_set_multivar;

backend->parent.del = config_delete;

backend->parent.foreach = file_foreach;

backend->parent.refresh = config_refresh;

backend->parent.free = backend_free;

*out = (git_config_backend *)backend;

return 0;

}

static int cfg_getchar_raw(diskfile_backend *cfg)

{

int c;

c = *cfg->reader.read_ptr++;

/*

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

cfg->reader.read_ptr++;

c = '\n';

}

if (c == '\n')

cfg->reader.line_number++;

if (c == 0) {

cfg->reader.eof = 1;

c = '\n';

}

return c;

}

#define SKIP_WHITESPACE (1 << 1)

#define SKIP_COMMENTS (1 << 2)

static int cfg_getchar(diskfile_backend *cfg_file, int flags)

{

const int skip_whitespace = (flags & SKIP_WHITESPACE);

const int skip_comments = (flags & SKIP_COMMENTS);

int c;

assert(cfg_file->reader.read_ptr);

do c = cfg_getchar_raw(cfg_file);

while (skip_whitespace && git__isspace(c) &&

!cfg_file->reader.eof);

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

do c = cfg_getchar_raw(cfg_file);

while (c != '\n');

}

return c;

}

static int cfg_peek(diskfile_backend *cfg, int flags)

{

void *old_read_ptr;

int old_lineno, old_eof;

int ret;

assert(cfg->reader.read_ptr);

old_read_ptr = cfg->reader.read_ptr;

old_lineno = cfg->reader.line_number;

old_eof = cfg->reader.eof;

ret = cfg_getchar(cfg, flags);

cfg->reader.read_ptr = old_read_ptr;

cfg->reader.line_number = old_lineno;

cfg->reader.eof = old_eof;

return ret;

}

static char *cfg_readline(diskfile_backend *cfg, bool skip_whitespace)

{

char *line = NULL;

char *line_src, *line_end;

size_t line_len;

line_src = cfg->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')

cfg->reader.eof = 1;

cfg->reader.line_number++;

cfg->reader.read_ptr = line_end;

return line;

}

static void cfg_consume_line(diskfile_backend *cfg)

{

char *line_start, *line_end;

line_start = cfg->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')

cfg->reader.eof = 1;

cfg->reader.line_number++;

cfg->reader.read_ptr = line_end;

}

GIT_INLINE(int) config_keychar(int c)

{

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

}

static int parse_section_header_ext(diskfile_backend *cfg, const char *line, const char *base_name, char **section_name)

{

int c, rpos;

char *first_quote, *last_quote;

git_buf buf = GIT_BUF_INIT;

int quote_marks;

/*

first_quote = strchr(line, '"');

last_quote = strrchr(line, '"');

if (last_quote - first_quote == 0) {

set_parse_error(cfg, 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;

quote_marks = 0;

line = first_quote;

c = line[rpos++];

/*

do {

if (quote_marks == 2) {

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

git_buf_free(&buf);

return -1;

}

switch (c) {

case '"':

++quote_marks;

continue;

case '\\':

c = line[rpos++];

switch (c) {

case '"':

case '\\':

break;

default:

set_parse_error(cfg, rpos, "Unsupported escape sequence");

git_buf_free(&buf);

return -1;

}

default:

break;

}

git_buf_putc(&buf, c);

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

*section_name = git_buf_detach(&buf);

return 0;

}

static int parse_section_header(diskfile_backend *cfg, char **section_out)

{

char *name, *name_end;

int name_length, c, pos;

int result;

char *line;

line = cfg_readline(cfg, true);

if (line == NULL)

return -1;

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

name_end = strchr(line, ']');

if (name_end == NULL) {

git__free(line);

set_parse_error(cfg, 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(cfg, line, name, section_out);

git__free(line);

git__free(name);

return result;

}

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

set_parse_error(cfg, 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(cfg, 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(diskfile_backend *cfg)

{

git_bom_t bom;

int bom_offset = git_buf_text_detect_bom(&bom,

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

if (bom == GIT_BOM_UTF8)

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

}

static int config_parse(diskfile_backend *cfg_file, git_config_level_t level)

{

int c;

char *current_section = NULL;

char *var_name;

char *var_value;

cvar_t *var, *existing;

git_buf buf = GIT_BUF_INIT;

int result = 0;

khiter_t pos;

/* Initialize the reading position */

cfg_file->reader.read_ptr = cfg_file->reader.buffer.ptr;

cfg_file->reader.eof = 0;

/* If the file is empty, there's nothing for us to do */

if (*cfg_file->reader.read_ptr == '\0')

return 0;

skip_bom(cfg_file);

while (result == 0 && !cfg_file->reader.eof) {

c = cfg_peek(cfg_file, SKIP_WHITESPACE);

switch (c) {

case '\n': /* EOF when peeking, set EOF in the reader to exit the loop */

cfg_file->reader.eof = 1;

break;

case '[': /* section header, new section begins */

git__free(current_section);

current_section = NULL;