Skip to content

G
git2
Commit c0335005 by Carlos Martín Nieto
Options

Move config to a backend structure 

Configuration options can come from different sources. Currently,
there is only support for reading them from a flat file, but it might
make sense to read it from a database at some point.

Move the parsing code into src/config_file.c and create an include
file include/git2/config_backend.h to allow for other backends to be
developed.

Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
parent ca8d2dfc
Showing with 1193 additions and 933 deletions
include/git2/config.h
......@@ -38,12 +38,22 @@
GIT_BEGIN_DECL
/**
* Allocate a new configuration
*/
GIT_EXTERN(int) git_config_new(git_config **out);
/**
* Open a configuration file
*
* @param cfg_out pointer to the configuration data
* @param path where to load the confiration from
*/
GIT_EXTERN(int) git_config_open(git_config **cfg_out, const char *path);
GIT_EXTERN(int) git_config_open_bare(git_config **cfg_out, const char *path);
/**
*
*/
GIT_EXTERN(int) git_config_add_backend(git_config *cfg, git_config_backend *backend, int priority);
/**
* Free the configuration and its associated memory
......
include/git2/config_backend.h 0 → 100644
/*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2,
* as published by the Free Software Foundation.
*
* In addition to the permissions in the GNU General Public License,
* the authors give you unlimited permission to link the compiled
* version of this file into combinations with other programs,
* and to distribute those combinations without any restriction
* coming from the use of this file. (The General Public License
* restrictions do apply in other respects; for example, they cover
* modification of the file, and distribution when not linked into
* a combined executable.)
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDE_git_config_backend_h__
#define INCLUDE_git_config_backend_h__
#include "common.h"
#include "types.h"
#include "config.h"
GIT_BEGIN_DECL
struct git_config;
struct git_config_backend {
struct git_config *cfg;
/* Open means open the file/database and parse if necessary */
int (*open)(struct git_config_backend *);
int (* get)(struct git_config_backend *, const char *key, const char **value);
int (* set)(struct git_config_backend *, const char *key, const char *value);
int (*foreach)(struct git_config_backend *, int (*fn)(const char *, void *), void *data);
void (*free)(struct git_config_backend *);
};
/**
* Create a file-backed configuration backend
*
* @param out the new backend
* @path where the config file is located
*/
GIT_EXTERN(int) git_config_backend_file(struct git_config_backend **out, const char *path);
GIT_END_DECL
#endif
include/git2/types.h
......@@ -133,6 +133,9 @@ typedef struct git_index git_index;
/** Memory representation of a config file */
typedef struct git_config git_config;
/** A specific implementation of a config backend */
typedef struct git_config_backend git_config_backend;
/** Memory representation of a config variable */
typedef struct git_cvar git_cvar;
......
src/config.c
......@@ -27,165 +27,89 @@
#include "fileops.h"
#include "hashtable.h"
#include "config.h"
#include "git2/config_backend.h"
#include "vector.h"
#include <ctype.h>
/**********************
* Forward declarations
***********************/
static int config_parse(git_config *cfg_file);
static int parse_variable(git_config *cfg, char **var_name, char **var_value);
void git_config_free(git_config *cfg);
typedef struct {
git_config_backend *backend;
int priority;
} backend_internal;
static void cvar_free(git_cvar *var)
{
if (var == NULL)
return;
free(var->section);
free(var->name);
free(var->value);
free(var);
}
static void cvar_list_free(git_cvar_list *list)
void git__strntolower(char *str, int len)
{
git_cvar *cur;
int i;
while (!CVAR_LIST_EMPTY(list)) {
cur = CVAR_LIST_HEAD(list);
CVAR_LIST_REMOVE_HEAD(list);
cvar_free(cur);
for (i = 0; i < len; ++i) {
str[i] = tolower(str[i]);
}
}
/*
* Compare two strings according to the git section-subsection
* rules. The order of the strings is important because local is
* assumed to have the internal format (only the section name and with
* case information) and input the normalized one (only dots, no case
* information).
*/
static int cvar_match_section(const char *local, const char *input)
{
char *first_dot, *last_dot;
char *local_sp = strchr(local, ' ');
int comparison_len;
/*
* If the local section name doesn't contain a space, then we can
* just do a case-insensitive compare.
*/
if (local_sp == NULL)
return !strncasecmp(local, input, strlen(local));
/*
* From here onwards, there is a space diving the section and the
* subsection. Anything before the space in local is
* case-insensitive.
*/
if (strncasecmp(local, input, local_sp - local))
return 0;
/*
* We compare starting from the first character after the
* quotation marks, which is two characters beyond the space. For
* the input, we start one character beyond the dot. If the names
* have different lengths, then we can fail early, as we know they
* can't be the same.
* The length is given by the length between the quotation marks.
*/
first_dot = strchr(input, '.');
last_dot = strrchr(input, '.');
comparison_len = strlen(local_sp + 2) - 1;
if (last_dot == first_dot || last_dot - first_dot - 1 != comparison_len)
return 0;
return !strncmp(local_sp + 2, first_dot + 1, comparison_len);
}
static int cvar_match_name(const git_cvar *var, const char *str)
void git__strtolower(char *str)
{
const char *name_start;
if (!cvar_match_section(var->section, str)) {
return 0;
}
/* Early exit if the lengths are different */
name_start = strrchr(str, '.') + 1;
if (strlen(var->name) != strlen(name_start))
return 0;
return !strcasecmp(var->name, name_start);
git__strntolower(str, strlen(str));
}
static git_cvar *cvar_list_find(git_cvar_list *list, const char *name)
int git_config_open_bare(git_config **out, const char *path)
{
git_cvar *iter;
git_config_backend *backend = NULL;
git_config *cfg = NULL;
int error = GIT_SUCCESS;
CVAR_LIST_FOREACH (list, iter) {
if (cvar_match_name(iter, name))
return iter;
}
error = git_config_new(&cfg);
if (error < GIT_SUCCESS)
goto error;
return NULL;
}
error = git_config_backend_file(&backend, path);
if (error < GIT_SUCCESS)
goto error;
static int cvar_name_normalize(const char *input, char **output)
{
char *input_sp = strchr(input, ' ');
char *quote, *str;
int i;
git_config_add_backend(cfg, backend, 1);
/* We need to make a copy anyway */
str = git__strdup(input);
if (str == NULL)
return GIT_ENOMEM;
error = backend->open(backend);
if (error < GIT_SUCCESS)
goto error;
*output = str;
*out = cfg;
/* If there aren't any spaces, we don't need to do anything */
if (input_sp == NULL)
return GIT_SUCCESS;
return error;
/*
* If there are spaces, we replace the space by a dot, move the
* variable name so that the dot before it replaces the last
* quotation mark and repeat so that the first quotation mark
* disappears.
*/
str[input_sp - input] = '.';
for (i = 0; i < 2; ++i) {
quote = strrchr(str, '"');
memmove(quote, quote + 1, strlen(quote));
}
error:
if(backend)
backend->free(backend);
return GIT_SUCCESS;
return error;
}
void git__strntolower(char *str, int len)
void git_config_free(git_config *cfg)
{
int i;
unsigned int i;
git_config_backend *backend;
backend_internal *internal;
for (i = 0; i < len; ++i) {
str[i] = tolower(str[i]);
for(i = 0; i < cfg->backends.length; ++i){
internal = git_vector_get(&cfg->backends, i);
backend = internal->backend;
backend->free(backend);
free(internal);
}
git_vector_free(&cfg->backends);
free(cfg);
}
void git__strtolower(char *str)
static int config_backend_cmp(const void *a, const void *b)
{
git__strntolower(str, strlen(str));
const backend_internal *bk_a = *(const backend_internal **)(a);
const backend_internal *bk_b = *(const backend_internal **)(b);
return bk_b->priority - bk_a->priority;
}
int git_config_open(git_config **cfg_out, const char *path)
int git_config_new(git_config **out)
{
git_config *cfg;
int error = GIT_SUCCESS;
assert(cfg_out && path);
cfg = git__malloc(sizeof(git_config));
if (cfg == NULL)
......@@ -193,45 +117,38 @@ int git_config_open(git_config **cfg_out, const char *path)
memset(cfg, 0x0, sizeof(git_config));
cfg->file_path = git__strdup(path);
if (cfg->file_path == NULL) {
error = GIT_ENOMEM;
goto cleanup;
if (git_vector_init(&cfg->backends, 3, config_backend_cmp) < 0) {
free(cfg);
return GIT_ENOMEM;
}
error = gitfo_read_file(&cfg->reader.buffer, cfg->file_path);
if(error < GIT_SUCCESS)
goto cleanup;
*out = cfg;
error = config_parse(cfg);
if (error < GIT_SUCCESS)
goto cleanup;
else
*cfg_out = cfg;
return GIT_SUCCESS;
}
gitfo_free_buf(&cfg->reader.buffer);
int git_config_add_backend(git_config *cfg, git_config_backend *backend, int priority)
{
backend_internal *internal;
return error;
assert(cfg && backend);
cleanup:
cvar_list_free(&cfg->var_list);
if (cfg->file_path)
free(cfg->file_path);
gitfo_free_buf(&cfg->reader.buffer);
free(cfg);
internal = git__malloc(sizeof(backend_internal));
if (internal == NULL)
return GIT_ENOMEM;
return error;
}
internal->backend = backend;
internal->priority = priority;
void git_config_free(git_config *cfg)
{
if (cfg == NULL)
return;
if (git_vector_insert(&cfg->backends, internal) < 0) {
free(internal);
return GIT_ENOMEM;
}
free(cfg->file_path);
cvar_list_free(&cfg->var_list);
git_vector_sort(&cfg->backends);
internal->backend->cfg = cfg;
free(cfg);
return GIT_SUCCESS;
}
/*
......@@ -241,23 +158,20 @@ void git_config_free(git_config *cfg)
int git_config_foreach(git_config *cfg, int (*fn)(const char *, void *), void *data)
{
int ret = GIT_SUCCESS;
git_cvar *var;
char *normalized;
CVAR_LIST_FOREACH(&cfg->var_list, var) {
ret = cvar_name_normalize(var->name, &normalized);
if (ret < GIT_SUCCESS)
return ret;
ret = fn(normalized, data);
free(normalized);
if (ret)
break;
unsigned int i;
backend_internal *internal;
git_config_backend *backend;
for(i = 0; i < cfg->backends.length && ret == 0; ++i) {
internal = git_vector_get(&cfg->backends, i);
backend = internal->backend;
ret = backend->foreach(backend, fn, data);
}
return ret;
}
/**************
* Setters
**************/
......@@ -265,70 +179,6 @@ int git_config_foreach(git_config *cfg, int (*fn)(const char *, void *), void *d
/*
* Internal function to actually set the string value of a variable
*/
static int config_set(git_config *cfg, const char *name, const char *value)
{
git_cvar *var = NULL;
git_cvar *existing = NULL;
int error = GIT_SUCCESS;
const char *last_dot;
/*
* If it already exists, we just need to update its value.
*/
existing = cvar_list_find(&cfg->var_list, name);
if (existing != NULL) {
char *tmp = value ? git__strdup(value) : NULL;
if (tmp == NULL && value != NULL)
return GIT_ENOMEM;
free(existing->value);
existing->value = tmp;
return GIT_SUCCESS;
}
/*
* Otherwise, create it and stick it at the end of the queue.
*/
var = git__malloc(sizeof(git_cvar));
if (var == NULL)
return GIT_ENOMEM;
memset(var, 0x0, sizeof(git_cvar));
last_dot = strrchr(name, '.');
if (last_dot == NULL) {
error = GIT_ERROR;
goto out;
}
var->section = git__strndup(name, last_dot - name);
if (var->section == NULL) {
error = GIT_ENOMEM;
goto out;
}
var->name = git__strdup(last_dot + 1);
if (var->name == NULL) {
error = GIT_ENOMEM;
goto out;
}
var->value = value ? git__strdup(value) : NULL;
if (var->value == NULL && value != NULL) {
error = GIT_ENOMEM;
goto out;
}
CVAR_LIST_APPEND(&cfg->var_list, var);
out:
if (error < GIT_SUCCESS)
cvar_free(var);
return error;
}
int git_config_set_long(git_config *cfg, const char *name, long int value)
{
......@@ -341,10 +191,10 @@ int git_config_set_long(git_config *cfg, const char *name, long int value)
buf_len = ret + 1;
help_buf = git__malloc(buf_len);
snprintf(help_buf, buf_len, "%ld", value);
ret = config_set(cfg, name, help_buf);
ret = git_config_set_string(cfg, name, help_buf);
free(help_buf);
} else {
ret = config_set(cfg, name, str_value);
ret = git_config_set_string(cfg, name, str_value);
}
return ret;
......@@ -364,43 +214,33 @@ int git_config_set_bool(git_config *cfg, const char *name, int value)
else
str_value = "true";
return config_set(cfg, name, str_value);
return git_config_set_string(cfg, name, str_value);
}
int git_config_set_string(git_config *cfg, const char *name, const char *value)
{
return config_set(cfg, name, value);
backend_internal *internal;
git_config_backend *backend;
assert(cfg->backends.length > 0);
internal = git_vector_get(&cfg->backends, 0);
backend = internal->backend;
return backend->set(backend, name, value);
}
/***********
* Getters
***********/
/*
* Internal function that actually gets the value in string form
*/
static int config_get(git_config *cfg, const char *name, const char **out)
{
git_cvar *var;
int error = GIT_SUCCESS;
var = cvar_list_find(&cfg->var_list, name);
if (var == NULL)
return GIT_ENOTFOUND;
*out = var->value;
return error;
}
int git_config_get_long(git_config *cfg, const char *name, long int *out)
{
const char *value, *num_end;
int ret;
long int num;
ret = config_get(cfg, name, &value);
ret = git_config_get_string(cfg, name, &value);
if (ret < GIT_SUCCESS)
return ret;
......@@ -449,7 +289,7 @@ int git_config_get_bool(git_config *cfg, const char *name, int *out)
const char *value;
int error = GIT_SUCCESS;
error = config_get(cfg, name, &value);
error = git_config_get_string(cfg, name, &value);
if (error < GIT_SUCCESS)
return error;
......@@ -482,618 +322,14 @@ int git_config_get_bool(git_config *cfg, const char *name, int *out)
int git_config_get_string(git_config *cfg, const char *name, const char **out)
{
return config_get(cfg, name, out);
}
static int cfg_getchar_raw(git_config *cfg)
{
int c;
c = *cfg->reader.read_ptr++;
/*
Win 32 line breaks: if we find a \r\n sequence,
return only the \n as a newline
*/
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(git_config *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 && isspace(c));
if (skip_comments && (c == '#' || c == ';')) {
do c = cfg_getchar_raw(cfg_file);
while (c != '\n');
}
return c;
}
/*
* Read the next char, but don't move the reading pointer.
*/
static int cfg_peek(git_config *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 const char *LINEBREAK_UNIX = "\\\n";
static const char *LINEBREAK_WIN32 = "\\\r\n";
static int is_linebreak(const char *pos)
{
return memcmp(pos - 1, LINEBREAK_UNIX, sizeof(LINEBREAK_UNIX)) == 0 ||
memcmp(pos - 2, LINEBREAK_WIN32, sizeof(LINEBREAK_WIN32)) == 0;
}
/*
* Read and consume a line, returning it in newly-allocated memory.
*/
static char *cfg_readline(git_config *cfg)
{
char *line = NULL;
char *line_src, *line_end;
int line_len;
line_src = cfg->reader.read_ptr;
line_end = strchr(line_src, '\n');
/* no newline at EOF */
if (line_end == NULL)
line_end = strchr(line_src, 0);
else
while (is_linebreak(line_end))
line_end = strchr(line_end + 1, '\n');
while (line_src < line_end && isspace(*line_src))
line_src++;
line = (char *)git__malloc((size_t)(line_end - line_src) + 1);
if (line == NULL)
return NULL;
line_len = 0;
while (line_src < line_end) {
if (memcmp(line_src, LINEBREAK_UNIX, sizeof(LINEBREAK_UNIX)) == 0) {
line_src += sizeof(LINEBREAK_UNIX);
continue;
}
if (memcmp(line_src, LINEBREAK_WIN32, sizeof(LINEBREAK_WIN32)) == 0) {
line_src += sizeof(LINEBREAK_WIN32);
continue;
}
line[line_len++] = *line_src++;
}
line[line_len] = '\0';
while (--line_len >= 0 && isspace(line[line_len]))
line[line_len] = '\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;
return line;
}
/*
* Consume a line, without storing it anywhere
*/
void cfg_consume_line(git_config *cfg)
{
char *line_start, *line_end;
int len;
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');
}
len = line_end - line_start;
if (*line_end == '\n')
line_end++;
if (*line_end == '\0')
cfg->reader.eof = 1;
cfg->reader.line_number++;
cfg->reader.read_ptr = line_end;
}
static inline int config_keychar(int c)
{
return isalnum(c) || c == '-';
}
static int parse_section_header_ext(const char *line, const char *base_name, char **section_name)
{
int buf_len, total_len, pos, rpos;
int c, ret;
char *subsection, *first_quote, *last_quote;
int error = GIT_SUCCESS;
int quote_marks;
/*
* base_name is what came before the space. We should be at the
* first quotation mark, except for now, line isn't being kept in
* sync so we only really use it to calculate the length.
*/
first_quote = strchr(line, '"');
last_quote = strrchr(line, '"');
if (last_quote - first_quote == 0)
return GIT_EOBJCORRUPTED;
buf_len = last_quote - first_quote + 2;
subsection = git__malloc(buf_len + 2);
if (subsection == NULL)
return GIT_ENOMEM;
pos = 0;
rpos = 0;
quote_marks = 0;
line = first_quote;
c = line[rpos++];
/*
* At the end of each iteration, whatever is stored in c will be
* added to the string. In case of error, jump to out
*/
do {
switch (c) {
case '"':
if (quote_marks++ >= 2)
return GIT_EOBJCORRUPTED;
break;
case '\\':
c = line[rpos++];
switch (c) {
case '"':
case '\\':
break;
default:
error = GIT_EOBJCORRUPTED;
goto out;
}
default:
break;
}
subsection[pos++] = c;
} while ((c = line[rpos++]) != ']');
subsection[pos] = '\0';
total_len = strlen(base_name) + strlen(subsection) + 2;
*section_name = git__malloc(total_len);
if (*section_name == NULL) {
error = GIT_ENOMEM;
goto out;
}
ret = snprintf(*section_name, total_len, "%s %s", base_name, subsection);
if (ret >= total_len) {
/* If this fails, we've checked the length wrong */
error = GIT_ERROR;
goto out;
} else if (ret < 0) {
error = GIT_EOSERR;
goto out;
}
git__strntolower(*section_name, strchr(*section_name, ' ') - *section_name);
out:
free(subsection);
return error;
}
static int parse_section_header(git_config *cfg, char **section_out)
{
char *name, *name_end;
int name_length, c, pos;
int error = GIT_SUCCESS;
char *line;
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
/* find the end of the variable's name */
name_end = strchr(line, ']');
if (name_end == NULL)
return GIT_EOBJCORRUPTED;
name = (char *)git__malloc((size_t)(name_end - line) + 1);
if (name == NULL)
return GIT_EOBJCORRUPTED;
name_length = 0;
pos = 0;
/* Make sure we were given a section header */
c = line[pos++];
if (c != '[') {
error = GIT_EOBJCORRUPTED;
goto error;
}
c = line[pos++];
do {
if (cfg->reader.eof){
error = GIT_EOBJCORRUPTED;
goto error;
}
if (isspace(c)){
name[name_length] = '\0';
error = parse_section_header_ext(line, name, section_out);
free(line);
free(name);
return error;
}
if (!config_keychar(c) && c != '.') {
error = GIT_EOBJCORRUPTED;
goto error;
}
name[name_length++] = tolower(c);
} while ((c = line[pos++]) != ']');
name[name_length] = 0;
free(line);
git__strtolower(name);
*section_out = name;
return GIT_SUCCESS;
error:
free(line);
free(name);
return error;
}
static int skip_bom(git_config *cfg)
{
static const unsigned char *utf8_bom = "\xef\xbb\xbf";
if (memcmp(cfg->reader.read_ptr, utf8_bom, sizeof(utf8_bom)) == 0)
cfg->reader.read_ptr += sizeof(utf8_bom);
/* TODO: the reference implementation does pretty stupid
shit with the BoM
*/
return GIT_SUCCESS;
}
/*
(* basic types *)
digit = "0".."9"
integer = digit { digit }
alphabet = "a".."z" + "A" .. "Z"
section_char = alphabet | "." | "-"
extension_char = (* any character except newline *)
any_char = (* any character *)
variable_char = "alphabet" | "-"
(* actual grammar *)
config = { section }
section = header { definition }
header = "[" section [subsection | subsection_ext] "]"
subsection = "." section
subsection_ext = "\"" extension "\""
section = section_char { section_char }
extension = extension_char { extension_char }
definition = variable_name ["=" variable_value] "\n"
variable_name = variable_char { variable_char }
variable_value = string | boolean | integer
string = quoted_string | plain_string
quoted_string = "\"" plain_string "\""
plain_string = { any_char }
boolean = boolean_true | boolean_false
boolean_true = "yes" | "1" | "true" | "on"
boolean_false = "no" | "0" | "false" | "off"
*/
static void strip_comments(char *line)
{
int quote_count = 0;
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;
}
}
if (isspace(ptr[-1])) {
/* TODO skip whitespace */
}
}
static int config_parse(git_config *cfg_file)
{
int error = GIT_SUCCESS, c;
char *current_section = NULL;
char *var_name;
char *var_value;
git_cvar *var;
/* Initialise the reading position */
cfg_file->reader.read_ptr = cfg_file->reader.buffer.data;
cfg_file->reader.eof = 0;
skip_bom(cfg_file);
while (error == GIT_SUCCESS && !cfg_file->reader.eof) {
c = cfg_peek(cfg_file, SKIP_WHITESPACE);
switch (c) {
case '\0': /* We've arrived at the end of the file */
break;
case '[': /* section header, new section begins */
free(current_section);
error = parse_section_header(cfg_file, &current_section);
break;
case ';':
case '#':
cfg_consume_line(cfg_file);
break;
default: /* assume variable declaration */
error = parse_variable(cfg_file, &var_name, &var_value);
if (error < GIT_SUCCESS)
break;
var = malloc(sizeof(git_cvar));
if (var == NULL) {
error = GIT_ENOMEM;
break;
}
memset(var, 0x0, sizeof(git_cvar));
var->section = git__strdup(current_section);
if (var->section == NULL) {
error = GIT_ENOMEM;
free(var);
break;
}
var->name = var_name;
var->value = var_value;
git__strtolower(var->name);
CVAR_LIST_APPEND(&cfg_file->var_list, var);
break;
}
}
if (current_section)
free(current_section);
return error;
}
static int is_multiline_var(const char *str)
{
char *end = strrchr(str, '\0') - 1;
while (isspace(*end))
--end;
return *end == '\\';
}
static int parse_multiline_variable(git_config *cfg, const char *first, char **out)
{
char *line = NULL, *end;
int error = GIT_SUCCESS, len, ret;
char *buf;
backend_internal *internal;
git_config_backend *backend;
/* Check that the next line exists */
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
/* We've reached the end of the file, there is input missing */
if (line[0] == '\0') {
error = GIT_EOBJCORRUPTED;
goto out;
}
strip_comments(line);
/* If it was just a comment, pretend it didn't exist */
if (line[0] == '\0') {
error = parse_multiline_variable(cfg, first, out);
goto out;
}
/* Find the continuation character '\' and strip the whitespace */
end = strrchr(first, '\\');
while (isspace(end[-1]))
--end;
*end = '\0'; /* Terminate the string here */
len = strlen(first) + strlen(line) + 2;
buf = git__malloc(len);
if (buf == NULL) {
error = GIT_ENOMEM;
goto out;
}
assert(cfg->backends.length > 0);
ret = snprintf(buf, len, "%s %s", first, line);
if (ret < 0) {
error = GIT_EOSERR;
free(buf);
goto out;
}
/*
* If we need to continue reading the next line, pretend
* everything we've read up to now was in one line and call
* ourselves.
*/
if (is_multiline_var(buf)) {
char *final_val;
error = parse_multiline_variable(cfg, buf, &final_val);
free(buf);
buf = final_val;
}
internal = git_vector_get(&cfg->backends, 0);
backend = internal->backend;
*out = buf;
out:
free(line);
return error;
return backend->get(backend, name, out);
}
static int parse_variable(git_config *cfg, char **var_name, char **var_value)
{
char *tmp;
int error = GIT_SUCCESS;
const char *var_end = NULL;
const char *value_start = NULL;
char *line;
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
strip_comments(line);
var_end = strchr(line, '=');
if (var_end == NULL)
var_end = strchr(line, '\0');
else
value_start = var_end + 1;
if (isspace(var_end[-1])) {
do var_end--;
while (isspace(var_end[0]));
}
tmp = strndup(line, var_end - line + 1);
if (tmp == NULL) {
error = GIT_ENOMEM;
goto out;
}
*var_name = tmp;
/*
* Now, let's try to parse the value
*/
if (value_start != NULL) {
while (isspace(value_start[0]))
value_start++;
if (value_start[0] == '\0')
goto out;
if (is_multiline_var(value_start)) {
error = parse_multiline_variable(cfg, value_start, var_value);
if (error < GIT_SUCCESS)
free(*var_name);
goto out;
}
tmp = strdup(value_start);
if (tmp == NULL) {
free(*var_name);
error = GIT_ENOMEM;
goto out;
}
*var_value = tmp;
} else {
/* If thre is no value, boolean true is assumed */
*var_value = NULL;
}
out:
free(line);
return error;
}
src/config.h
#ifndef INCLUDE_config_h__
#define INCLUDE_config_h__
#include "git2.h"
#include "git2/config.h"
typedef struct {
git_cvar *head;
git_cvar *tail;
} git_cvar_list;
#include "vector.h"
struct git_config {
git_cvar_list var_list;
struct {
gitfo_buf buffer;
char *read_ptr;
int line_number;
int eof;
} reader;
char *file_path;
};
struct git_cvar {
git_cvar *next;
char *section;
char *name;
char *value;
git_vector backends;
};
#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))
/*
* Inspired by the FreeBSD functions
*/
#define CVAR_LIST_FOREACH_SAFE(start, iter, tmp)\
for ((iter) = CVAR_LIST_HEAD(vars);\
(iter) && (((tmp) = CVAR_LIST_NEXT(iter) || 1));\
(iter) = (tmp))
void git__strtolower(char *str);
void git__strntolower(char *str, int len);
......
src/config_file.c 0 → 100644
/*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License, version 2,
* as published by the Free Software Foundation.
*
* In addition to the permissions in the GNU General Public License,
* the authors give you unlimited permission to link the compiled
* version of this file into combinations with other programs,
* and to distribute those combinations without any restriction
* coming from the use of this file. (The General Public License
* restrictions do apply in other respects; for example, they cover
* modification of the file, and distribution when not linked into
* a combined executable.)
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "common.h"
#include "config.h"
#include "fileops.h"
#include "git2/config_backend.h"
#include "git2/types.h"
#include <ctype.h>
struct git_cvar {
git_cvar *next;
char *section;
char *name;
char *value;
};
typedef struct {
git_cvar *head;
git_cvar *tail;
} git_cvar_list;
#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))
/*
* Inspired by the FreeBSD functions
*/
#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_cvar_list var_list;
struct {
gitfo_buf buffer;
char *read_ptr;
int line_number;
int eof;
} reader;
char *file_path;
} file_backend;
static int config_parse(file_backend *cfg_file);
static int parse_variable(file_backend *cfg, char **var_name, char **var_value);
static void cvar_free(git_cvar *var)
{
if (var == NULL)
return;
free(var->section);
free(var->name);
free(var->value);
free(var);
}
static void cvar_list_free(git_cvar_list *list)
{
git_cvar *cur;
while (!CVAR_LIST_EMPTY(list)) {
cur = CVAR_LIST_HEAD(list);
CVAR_LIST_REMOVE_HEAD(list);
cvar_free(cur);
}
}
/*
* Compare two strings according to the git section-subsection
* rules. The order of the strings is important because local is
* assumed to have the internal format (only the section name and with
* case information) and input the normalized one (only dots, no case
* information).
*/
static int cvar_match_section(const char *local, const char *input)
{
char *first_dot, *last_dot;
char *local_sp = strchr(local, ' ');
int comparison_len;
/*
* If the local section name doesn't contain a space, then we can
* just do a case-insensitive compare.
*/
if (local_sp == NULL)
return !strncasecmp(local, input, strlen(local));
/*
* From here onwards, there is a space diving the section and the
* subsection. Anything before the space in local is
* case-insensitive.
*/
if (strncasecmp(local, input, local_sp - local))
return 0;
/*
* We compare starting from the first character after the
* quotation marks, which is two characters beyond the space. For
* the input, we start one character beyond the dot. If the names
* have different lengths, then we can fail early, as we know they
* can't be the same.
* The length is given by the length between the quotation marks.
*/
first_dot = strchr(input, '.');
last_dot = strrchr(input, '.');
comparison_len = strlen(local_sp + 2) - 1;
if (last_dot == first_dot || last_dot - first_dot - 1 != comparison_len)
return 0;
return !strncmp(local_sp + 2, first_dot + 1, comparison_len);
}
static int cvar_match_name(const git_cvar *var, const char *str)
{
const char *name_start;
if (!cvar_match_section(var->section, str)) {
return 0;
}
/* Early exit if the lengths are different */
name_start = strrchr(str, '.') + 1;
if (strlen(var->name) != strlen(name_start))
return 0;
return !strcasecmp(var->name, name_start);
}
static git_cvar *cvar_list_find(git_cvar_list *list, const char *name)
{
git_cvar *iter;
CVAR_LIST_FOREACH (list, iter) {
if (cvar_match_name(iter, name))
return iter;
}
return NULL;
}
static int cvar_name_normalize(const char *input, char **output)
{
char *input_sp = strchr(input, ' ');
char *quote, *str;
int i;
/* We need to make a copy anyway */
str = git__strdup(input);
if (str == NULL)
return GIT_ENOMEM;
*output = str;
/* If there aren't any spaces, we don't need to do anything */
if (input_sp == NULL)
return GIT_SUCCESS;
/*
* If there are spaces, we replace the space by a dot, move the
* variable name so that the dot before it replaces the last
* quotation mark and repeat so that the first quotation mark
* disappears.
*/
str[input_sp - input] = '.';
for (i = 0; i < 2; ++i) {
quote = strrchr(str, '"');
memmove(quote, quote + 1, strlen(quote));
}
return GIT_SUCCESS;
}
static int config_open(git_config_backend *cfg)
{
int error;
file_backend *b = (file_backend *)cfg;
error = gitfo_read_file(&b->reader.buffer, b->file_path);
if(error < GIT_SUCCESS)
goto cleanup;
error = config_parse(b);
if (error < GIT_SUCCESS)
goto cleanup;
gitfo_free_buf(&b->reader.buffer);
return error;
cleanup:
cvar_list_free(&b->var_list);
gitfo_free_buf(&b->reader.buffer);
free(cfg);
return error;
}
static void backend_free(git_config_backend *_backend)
{
file_backend *backend = (file_backend *)_backend;
if (backend == NULL)
return;
free(backend->file_path);
cvar_list_free(&backend->var_list);
free(backend);
}
static int file_foreach(git_config_backend *backend, int (*fn)(const char *, void *), void *data)
{
int ret;
git_cvar *var;
char *normalized;
file_backend *b = (file_backend *)backend;
CVAR_LIST_FOREACH(&b->var_list, var) {
ret = cvar_name_normalize(var->name, &normalized);
if (ret < GIT_SUCCESS)
return ret;
ret = fn(normalized, data);
free(normalized);
if (ret)
break;
}
return ret;
}
static int config_set(git_config_backend *cfg, const char *name, const char *value)
{
git_cvar *var = NULL;
git_cvar *existing = NULL;
int error = GIT_SUCCESS;
const char *last_dot;
file_backend *b = (file_backend *)cfg;
/*
* If it already exists, we just need to update its value.
*/
existing = cvar_list_find(&b->var_list, name);
if (existing != NULL) {
char *tmp = value ? git__strdup(value) : NULL;
if (tmp == NULL && value != NULL)
return GIT_ENOMEM;
free(existing->value);
existing->value = tmp;
return GIT_SUCCESS;
}
/*
* Otherwise, create it and stick it at the end of the queue.
*/
var = git__malloc(sizeof(git_cvar));
if (var == NULL)
return GIT_ENOMEM;
memset(var, 0x0, sizeof(git_cvar));
last_dot = strrchr(name, '.');
if (last_dot == NULL) {
error = GIT_ERROR;
goto out;
}
var->section = git__strndup(name, last_dot - name);
if (var->section == NULL) {
error = GIT_ENOMEM;
goto out;
}
var->name = git__strdup(last_dot + 1);
if (var->name == NULL) {
error = GIT_ENOMEM;
goto out;
}
var->value = value ? git__strdup(value) : NULL;
if (var->value == NULL && value != NULL) {
error = GIT_ENOMEM;
goto out;
}
CVAR_LIST_APPEND(&b->var_list, var);
out:
if (error < GIT_SUCCESS)
cvar_free(var);
return error;
}
/*
* Internal function that actually gets the value in string form
*/
static int config_get(git_config_backend *cfg, const char *name, const char **out)
{
git_cvar *var;
int error = GIT_SUCCESS;
file_backend *b = (file_backend *)cfg;
var = cvar_list_find(&b->var_list, name);
if (var == NULL)
return GIT_ENOTFOUND;
*out = var->value;
return error;
}
int git_config_backend_file(git_config_backend **out, const char *path)
{
file_backend *backend;
backend = git__malloc(sizeof(file_backend));
if (backend == NULL)
return GIT_ENOMEM;
memset(backend, 0x0, sizeof(file_backend));
backend->file_path = git__strdup(path);
if (backend->file_path == NULL) {
free(backend);
return GIT_ENOMEM;
}
backend->parent.open = config_open;
backend->parent.get = config_get;
backend->parent.set = config_set;
backend->parent.foreach = file_foreach;
backend->parent.free = backend_free;
*out = (git_config_backend *)backend;
return GIT_SUCCESS;
}
static int cfg_getchar_raw(file_backend *cfg)
{
int c;
c = *cfg->reader.read_ptr++;
/*
Win 32 line breaks: if we find a \r\n sequence,
return only the \n as a newline
*/
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(file_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 && isspace(c));
if (skip_comments && (c == '#' || c == ';')) {
do c = cfg_getchar_raw(cfg_file);
while (c != '\n');
}
return c;
}
/*
* Read the next char, but don't move the reading pointer.
*/
static int cfg_peek(file_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 const char *LINEBREAK_UNIX = "\\\n";
static const char *LINEBREAK_WIN32 = "\\\r\n";
static int is_linebreak(const char *pos)
{
return memcmp(pos - 1, LINEBREAK_UNIX, sizeof(LINEBREAK_UNIX)) == 0 ||
memcmp(pos - 2, LINEBREAK_WIN32, sizeof(LINEBREAK_WIN32)) == 0;
}
/*
* Read and consume a line, returning it in newly-allocated memory.
*/
static char *cfg_readline(file_backend *cfg)
{
char *line = NULL;
char *line_src, *line_end;
int line_len;
line_src = cfg->reader.read_ptr;
line_end = strchr(line_src, '\n');
/* no newline at EOF */
if (line_end == NULL)
line_end = strchr(line_src, 0);
else
while (is_linebreak(line_end))
line_end = strchr(line_end + 1, '\n');
while (line_src < line_end && isspace(*line_src))
line_src++;
line = (char *)git__malloc((size_t)(line_end - line_src) + 1);
if (line == NULL)
return NULL;
line_len = 0;
while (line_src < line_end) {
if (memcmp(line_src, LINEBREAK_UNIX, sizeof(LINEBREAK_UNIX)) == 0) {
line_src += sizeof(LINEBREAK_UNIX);
continue;
}
if (memcmp(line_src, LINEBREAK_WIN32, sizeof(LINEBREAK_WIN32)) == 0) {
line_src += sizeof(LINEBREAK_WIN32);
continue;
}
line[line_len++] = *line_src++;
}
line[line_len] = '\0';
while (--line_len >= 0 && isspace(line[line_len]))
line[line_len] = '\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;
return line;
}
/*
* Consume a line, without storing it anywhere
*/
void cfg_consume_line(file_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;
}
static inline int config_keychar(int c)
{
return isalnum(c) || c == '-';
}
static int parse_section_header_ext(const char *line, const char *base_name, char **section_name)
{
int buf_len, total_len, pos, rpos;
int c, ret;
char *subsection, *first_quote, *last_quote;
int error = GIT_SUCCESS;
int quote_marks;
/*
* base_name is what came before the space. We should be at the
* first quotation mark, except for now, line isn't being kept in
* sync so we only really use it to calculate the length.
*/
first_quote = strchr(line, '"');
last_quote = strrchr(line, '"');
if (last_quote - first_quote == 0)
return GIT_EOBJCORRUPTED;
buf_len = last_quote - first_quote + 2;
subsection = git__malloc(buf_len + 2);
if (subsection == NULL)
return GIT_ENOMEM;
pos = 0;
rpos = 0;
quote_marks = 0;
line = first_quote;
c = line[rpos++];
/*
* At the end of each iteration, whatever is stored in c will be
* added to the string. In case of error, jump to out
*/
do {
switch (c) {
case '"':
if (quote_marks++ >= 2)
return GIT_EOBJCORRUPTED;
break;
case '\\':
c = line[rpos++];
switch (c) {
case '"':
case '\\':
break;
default:
error = GIT_EOBJCORRUPTED;
goto out;
}
default:
break;
}
subsection[pos++] = c;
} while ((c = line[rpos++]) != ']');
subsection[pos] = '\0';
total_len = strlen(base_name) + strlen(subsection) + 2;
*section_name = git__malloc(total_len);
if (*section_name == NULL) {
error = GIT_ENOMEM;
goto out;
}
ret = snprintf(*section_name, total_len, "%s %s", base_name, subsection);
if (ret >= total_len) {
/* If this fails, we've checked the length wrong */
error = GIT_ERROR;
goto out;
} else if (ret < 0) {
error = GIT_EOSERR;
goto out;
}
git__strntolower(*section_name, strchr(*section_name, ' ') - *section_name);
out:
free(subsection);
return error;
}
static int parse_section_header(file_backend *cfg, char **section_out)
{
char *name, *name_end;
int name_length, c, pos;
int error = GIT_SUCCESS;
char *line;
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
/* find the end of the variable's name */
name_end = strchr(line, ']');
if (name_end == NULL)
return GIT_EOBJCORRUPTED;
name = (char *)git__malloc((size_t)(name_end - line) + 1);
if (name == NULL)
return GIT_EOBJCORRUPTED;
name_length = 0;
pos = 0;
/* Make sure we were given a section header */
c = line[pos++];
if (c != '[') {
error = GIT_EOBJCORRUPTED;
goto error;
}
c = line[pos++];
do {
if (cfg->reader.eof){
error = GIT_EOBJCORRUPTED;
goto error;
}
if (isspace(c)){
name[name_length] = '\0';
error = parse_section_header_ext(line, name, section_out);
free(line);
free(name);
return error;
}
if (!config_keychar(c) && c != '.') {
error = GIT_EOBJCORRUPTED;
goto error;
}
name[name_length++] = tolower(c);
} while ((c = line[pos++]) != ']');
name[name_length] = 0;
free(line);
git__strtolower(name);
*section_out = name;
return GIT_SUCCESS;
error:
free(line);
free(name);
return error;
}
static int skip_bom(file_backend *cfg)
{
static const unsigned char *utf8_bom = "\xef\xbb\xbf";
if (memcmp(cfg->reader.read_ptr, utf8_bom, sizeof(utf8_bom)) == 0)
cfg->reader.read_ptr += sizeof(utf8_bom);
/* TODO: the reference implementation does pretty stupid
shit with the BoM
*/
return GIT_SUCCESS;
}
/*
(* basic types *)
digit = "0".."9"
integer = digit { digit }
alphabet = "a".."z" + "A" .. "Z"
section_char = alphabet | "." | "-"
extension_char = (* any character except newline *)
any_char = (* any character *)
variable_char = "alphabet" | "-"
(* actual grammar *)
config = { section }
section = header { definition }
header = "[" section [subsection | subsection_ext] "]"
subsection = "." section
subsection_ext = "\"" extension "\""
section = section_char { section_char }
extension = extension_char { extension_char }
definition = variable_name ["=" variable_value] "\n"
variable_name = variable_char { variable_char }
variable_value = string | boolean | integer
string = quoted_string | plain_string
quoted_string = "\"" plain_string "\""
plain_string = { any_char }
boolean = boolean_true | boolean_false
boolean_true = "yes" | "1" | "true" | "on"
boolean_false = "no" | "0" | "false" | "off"
*/
static void strip_comments(char *line)
{
int quote_count = 0;
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;
}
}
if (isspace(ptr[-1])) {
/* TODO skip whitespace */
}
}
static int config_parse(file_backend *cfg_file)
{
int error = GIT_SUCCESS, c;
char *current_section = NULL;
char *var_name;
char *var_value;
git_cvar *var;
/* Initialise the reading position */
cfg_file->reader.read_ptr = cfg_file->reader.buffer.data;
cfg_file->reader.eof = 0;
skip_bom(cfg_file);
while (error == GIT_SUCCESS && !cfg_file->reader.eof) {
c = cfg_peek(cfg_file, SKIP_WHITESPACE);
switch (c) {
case '\0': /* We've arrived at the end of the file */
break;
case '[': /* section header, new section begins */
free(current_section);
error = parse_section_header(cfg_file, &current_section);
break;
case ';':
case '#':
cfg_consume_line(cfg_file);
break;
default: /* assume variable declaration */
error = parse_variable(cfg_file, &var_name, &var_value);
if (error < GIT_SUCCESS)
break;
var = malloc(sizeof(git_cvar));
if (var == NULL) {
error = GIT_ENOMEM;
break;
}
memset(var, 0x0, sizeof(git_cvar));
var->section = git__strdup(current_section);
if (var->section == NULL) {
error = GIT_ENOMEM;
free(var);
break;
}
var->name = var_name;
var->value = var_value;
git__strtolower(var->name);
CVAR_LIST_APPEND(&cfg_file->var_list, var);
break;
}
}
if (current_section)
free(current_section);
return error;
}
static int is_multiline_var(const char *str)
{
char *end = strrchr(str, '\0') - 1;
while (isspace(*end))
--end;
return *end == '\\';
}
static int parse_multiline_variable(file_backend *cfg, const char *first, char **out)
{
char *line = NULL, *end;
int error = GIT_SUCCESS, len, ret;
char *buf;
/* Check that the next line exists */
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
/* We've reached the end of the file, there is input missing */
if (line[0] == '\0') {
error = GIT_EOBJCORRUPTED;
goto out;
}
strip_comments(line);
/* If it was just a comment, pretend it didn't exist */
if (line[0] == '\0') {
error = parse_multiline_variable(cfg, first, out);
goto out;
}
/* Find the continuation character '\' and strip the whitespace */
end = strrchr(first, '\\');
while (isspace(end[-1]))
--end;
*end = '\0'; /* Terminate the string here */
len = strlen(first) + strlen(line) + 2;
buf = git__malloc(len);
if (buf == NULL) {
error = GIT_ENOMEM;
goto out;
}
ret = snprintf(buf, len, "%s %s", first, line);
if (ret < 0) {
error = GIT_EOSERR;
free(buf);
goto out;
}
/*
* If we need to continue reading the next line, pretend
* everything we've read up to now was in one line and call
* ourselves.
*/
if (is_multiline_var(buf)) {
char *final_val;
error = parse_multiline_variable(cfg, buf, &final_val);
free(buf);
buf = final_val;
}
*out = buf;
out:
free(line);
return error;
}
static int parse_variable(file_backend *cfg, char **var_name, char **var_value)
{
char *tmp;
int error = GIT_SUCCESS;
const char *var_end = NULL;
const char *value_start = NULL;
char *line;
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
strip_comments(line);
var_end = strchr(line, '=');
if (var_end == NULL)
var_end = strchr(line, '\0');
else
value_start = var_end + 1;
if (isspace(var_end[-1])) {
do var_end--;
while (isspace(var_end[0]));
}
tmp = strndup(line, var_end - line + 1);
if (tmp == NULL) {
error = GIT_ENOMEM;
goto out;
}
*var_name = tmp;
/*
* Now, let's try to parse the value
*/
if (value_start != NULL) {
while (isspace(value_start[0]))
value_start++;
if (value_start[0] == '\0')
goto out;
if (is_multiline_var(value_start)) {
error = parse_multiline_variable(cfg, value_start, var_value);
if (error < GIT_SUCCESS)
free(*var_name);
goto out;
}
tmp = strdup(value_start);
if (tmp == NULL) {
free(*var_name);
error = GIT_ENOMEM;
goto out;
}
*var_value = tmp;
} else {
/* If thre is no value, boolean true is assumed */
*var_value = NULL;
}
out:
free(line);
return error;
}
tests/t15-config.c
......@@ -36,7 +36,7 @@ BEGIN_TEST(config0, "read a simple configuration")
git_config *cfg;
int i;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config0"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config0"));
must_pass(git_config_get_int(cfg, "core.repositoryformatversion", &i));
must_be_true(i == 0);
must_pass(git_config_get_bool(cfg, "core.filemode", &i));
......@@ -58,7 +58,7 @@ BEGIN_TEST(config1, "case sensitivity")
int i;
const char *str;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config1"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config1"));
must_pass(git_config_get_string(cfg, "this.that.other", &str));
must_be_true(!strcmp(str, "true"));
......@@ -84,7 +84,7 @@ BEGIN_TEST(config2, "parse a multiline value")
git_config *cfg;
const char *str;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config2"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config2"));
must_pass(git_config_get_string(cfg, "this.That.and", &str));
must_be_true(!strcmp(str, "one one one two two three three"));
......@@ -99,7 +99,7 @@ BEGIN_TEST(config3, "parse a [section.subsection] header")
git_config *cfg;
const char *str;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config3"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config3"));
must_pass(git_config_get_string(cfg, "section.subsection.var", &str));
must_be_true(!strcmp(str, "hello"));
......@@ -117,7 +117,7 @@ BEGIN_TEST(config4, "a variable name on its own is valid")
const char *str;
int i;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config4"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config4"));
must_pass(git_config_get_string(cfg, "some.section.variable", &str));
must_be_true(str == NULL);
......@@ -134,7 +134,7 @@ BEGIN_TEST(config5, "test number suffixes")
const char *str;
long int i;
must_pass(git_config_open(&cfg, CONFIG_BASE "/config5"));
must_pass(git_config_open_bare(&cfg, CONFIG_BASE "/config5"));
must_pass(git_config_get_long(cfg, "number.simple", &i));
must_be_true(i == 1);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment