Skip to content

G
git2
Commit dda708e7 by Vicent Martí
Options

error-handling: On-disk config file backend 

Includes:

	- Proper error reporting when encountering syntax errors in a
	config file (file, line number, column).

	- Rewritten `config_write`, now with 99% less goto-spaghetti

	- Error state in `git_filebuf`: filebuf write functions no longer
	need to be checked for error returns. If any of the writes performed
	on a buffer fail, the last call to `git_filebuf_commit` or
	`git_filebuf_hash` will fail accordingly and set the appropiate error
	message. Baller!
parent 6af24ce3
Showing with 480 additions and 486 deletions
include/git2/errors.h
......@@ -127,14 +127,9 @@ typedef enum {
GITERR_ZLIB,
GITERR_REPOSITORY,
GITERR_CONFIG,
GITERR_REGEX,
} git_error_class;
#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
GIT_EXTERN(void) giterr_set_oom(void);
GIT_EXTERN(void) giterr_set(int error_class, const char *string, ...);
GIT_EXTERN(void) giterr_clear(void);
/**
* Return a detailed error string with the latest error
* that occurred in the library.
......
src/common.h
......@@ -46,6 +46,8 @@
#include "thread-utils.h"
#include "bswap.h"
#include <regex.h>
extern void git___throw(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
#define git__throw(error, ...) \
(git___throw(__VA_ARGS__), error)
......@@ -54,6 +56,16 @@ extern void git___rethrow(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
#define git__rethrow(error, ...) \
(git___rethrow(__VA_ARGS__), error)
#define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
void giterr_set_oom(void);
void giterr_set(int error_class, const char *string, ...);
void giterr_clear(void);
void giterr_set_str(int error_class, const char *string);
void giterr_set_regex(const regex_t *regex, int error_code);
#include "util.h"
......
src/config.c
......@@ -401,13 +401,15 @@ int git_config_get_string(git_config *cfg, const char *name, const char **out)
if (ret == 0)
return 0;
/* File backend doesn't set error message on variable
* not found */
if (ret == GIT_ENOTFOUND)
continue;
return ret;
}
giterr_set(GITERR_CONFIG, "Config value '%s' not found", name);
giterr_set(GITERR_CONFIG, "Config variable '%s' not found", name);
return GIT_ENOTFOUND;
}
......
src/config_file.c
......@@ -86,6 +86,12 @@ static int config_parse(diskfile_backend *cfg_file);
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 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)
......@@ -104,15 +110,16 @@ static int normalize_name(const char *in, char **out)
assert(in && out);
name = git__strdup(in);
if (name == NULL)
return GIT_ENOMEM;
GITERR_CHECK_ALLOC(name);
fdot = strchr(name, '.');
ldot = strrchr(name, '.');
if (fdot == NULL || ldot == NULL) {
git__free(name);
return git__throw(GIT_EINVALIDARGS, "Bad format. No dot in '%s'", in);
giterr_set(GITERR_CONFIG,
"Invalid variable name: '%s'", in);
return -1;
}
/* Downcase up to the first dot and after the last one */
......@@ -120,7 +127,7 @@ static int normalize_name(const char *in, char **out)
git__strtolower(ldot);
*out = name;
return GIT_SUCCESS;
return 0;
}
static void free_vars(git_hashtable *values)
......@@ -143,37 +150,28 @@ static void free_vars(git_hashtable *values)
static int config_open(git_config_file *cfg)
{
int error;
int res;
diskfile_backend *b = (diskfile_backend *)cfg;
b->values = git_hashtable_alloc (20, git_hash__strhash_cb, git_hash__strcmp_cb);
if (b->values == NULL)
return GIT_ENOMEM;
GITERR_CHECK_ALLOC(b->values);
git_buf_init(&b->reader.buffer, 0);
error = git_futils_readbuffer(&b->reader.buffer, b->file_path);
res = git_futils_readbuffer(&b->reader.buffer, b->file_path);
/* It's fine if the file doesn't exist */
if (error == GIT_ENOTFOUND)
return GIT_SUCCESS;
if (error < GIT_SUCCESS)
goto cleanup;
error = config_parse(b);
if (error < GIT_SUCCESS)
goto cleanup;
git_buf_free(&b->reader.buffer);
return GIT_SUCCESS;
if (res == GIT_ENOTFOUND)
return 0;
if (res < 0 || config_parse(b) < 0) {
free_vars(b->values);
b->values = NULL;
git_buf_free(&b->reader.buffer);
return -1;
}
cleanup:
free_vars(b->values);
b->values = NULL;
git_buf_free(&b->reader.buffer);
return git__rethrow(error, "Failed to open config");
return 0;
}
static void backend_free(git_config_file *_backend)
......@@ -184,42 +182,37 @@ static void backend_free(git_config_file *_backend)
return;
git__free(backend->file_path);
free_vars(backend->values);
git__free(backend);
}
static int file_foreach(git_config_file *backend, int (*fn)(const char *, const char *, void *), void *data)
{
int ret = GIT_SUCCESS;
cvar_t *var;
diskfile_backend *b = (diskfile_backend *)backend;
cvar_t *var;
const char *key;
GIT_HASHTABLE_FOREACH(b->values, key, var,
do {
ret = fn(key, var->value, data);
if (ret)
break;
var = CVAR_LIST_NEXT(var);
} while (var != NULL);
)
do {
if (fn(key, var->value, data) < 0)
break;
var = CVAR_LIST_NEXT(var);
} while (var != NULL);
)
return ret;
return 0;
}
static int config_set(git_config_file *cfg, const char *name, const char *value)
{
cvar_t *var = NULL;
cvar_t *existing = NULL, *old_value = NULL;
int error = GIT_SUCCESS;
diskfile_backend *b = (diskfile_backend *)cfg;
char *key;
if ((error = normalize_name(name, &key)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to normalize variable name '%s'", name);
if (normalize_name(name, &key) < 0)
return -1;
/*
* Try to find it in the existing values and update it if it
......@@ -227,15 +220,18 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
*/
existing = git_hashtable_lookup(b->values, key);
if (existing != NULL) {
char *tmp;
char *tmp = NULL;
git__free(key);
if (existing->next != NULL)
return git__throw(GIT_EINVALIDARGS, "Multivar incompatible with simple set");
if (existing->next != NULL) {
giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set");
return -1;
}
tmp = value ? git__strdup(value) : NULL;
if (tmp == NULL && value != NULL)
return GIT_ENOMEM;
if (value) {
tmp = git__strdup(value);
GITERR_CHECK_ALLOC(tmp);
}
git__free(existing->value);
existing->value = tmp;
......@@ -244,32 +240,29 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
}
var = git__malloc(sizeof(cvar_t));
if (var == NULL)
return GIT_ENOMEM;
GITERR_CHECK_ALLOC(var);
memset(var, 0x0, sizeof(cvar_t));
var->key = key;
var->value = NULL;
var->value = value ? git__strdup(value) : NULL;
if (var->value == NULL && value != NULL) {
error = GIT_ENOMEM;
goto out;
if (value) {
var->value = git__strdup(value);
GITERR_CHECK_ALLOC(var->value);
}
error = git_hashtable_insert2(b->values, key, var, (void **)&old_value);
if (error < GIT_SUCCESS)
goto out;
if (git_hashtable_insert2(b->values, key, var, (void **)&old_value) < 0)
return -1;
cvar_free(old_value);
error = config_write(b, key, NULL, value);
out:
if (error < GIT_SUCCESS)
if (config_write(b, key, NULL, value) < 0) {
cvar_free(var);
return -1;
}
return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to set config value");
return 0;
}
/*
......@@ -278,171 +271,172 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
static int config_get(git_config_file *cfg, const char *name, const char **out)
{
cvar_t *var;
int error = GIT_SUCCESS;
diskfile_backend *b = (diskfile_backend *)cfg;
char *key;
if ((error = normalize_name(name, &key)) < GIT_SUCCESS)
return error;
if (normalize_name(name, &key) < 0)
return -1;
var = git_hashtable_lookup(b->values, key);
git__free(key);
/* no error message; the config system will write one */
if (var == NULL)
return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name);
return GIT_ENOTFOUND;
*out = var->value;
return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to get config value for %s", name);
return 0;
}
static int config_get_multivar(git_config_file *cfg, const char *name, const char *regexp, int (*fn)(const char *, void *), void *data)
static int config_get_multivar(
git_config_file *cfg,
const char *name,
const char *regex_str,
int (*fn)(const char *, void *),
void *data)
{
cvar_t *var;
int error = GIT_SUCCESS;
diskfile_backend *b = (diskfile_backend *)cfg;
char *key;
regex_t preg;
if ((error = normalize_name(name, &key)) < GIT_SUCCESS)
return error;
if (normalize_name(name, &key) < 0)
return -1;
var = git_hashtable_lookup(b->values, key);
git__free(key);
if (var == NULL)
return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name);
return GIT_ENOTFOUND;
if (regexp != NULL) {
error = regcomp(&preg, regexp, REG_EXTENDED);
if (error < 0)
return git__throw(GIT_EINVALIDARGS, "Failed to compile regex");
}
if (regex_str != NULL) {
regex_t regex;
int result;
do {
if (regexp == NULL || !regexec(&preg, var->value, 0, NULL, 0)) {
error = fn(var->value, data);
if (error < GIT_SUCCESS)
goto exit;
/* regex matching; build the regex */
result = regcomp(&regex, regex_str, REG_EXTENDED);
if (result < 0) {
giterr_set_regex(&regex, result);
return -1;
}
var = var->next;
} while (var != NULL);
/* and throw the callback only on the variables that
* match the regex */
do {
if (regexec(&regex, var->value, 0, NULL, 0) == 0) {
/* early termination by the user is not an error;
* just break and return successfully */
if (fn(var->value, data) < 0)
break;
}
exit:
if (regexp != NULL)
regfree(&preg);
return error;
var = var->next;
} while (var != NULL);
} else {
/* no regex; go through all the variables */
do {
/* early termination by the user is not an error;
* just break and return successfully */
if (fn(var->value, data) < 0)
break;
var = var->next;
} while (var != NULL);
}
return 0;
}
static int config_set_multivar(git_config_file *cfg, const char *name, const char *regexp, const char *value)
{
int error, replaced = 0;
int replaced = 0;
cvar_t *var, *newvar;
diskfile_backend *b = (diskfile_backend *)cfg;
char *key;
regex_t preg;
int result;
if (regexp == NULL)
return git__throw(GIT_EINVALIDARGS, "No regex supplied");
assert(regexp);
if ((error = normalize_name(name, &key)) < GIT_SUCCESS)
return error;
if (normalize_name(name, &key) < 0)
return -1;
var = git_hashtable_lookup(b->values, key);
if (var == NULL) {
free(key);
return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name);
}
if (var == NULL)
return GIT_ENOTFOUND;
error = regcomp(&preg, regexp, REG_EXTENDED);
if (error < 0) {
result = regcomp(&preg, regexp, REG_EXTENDED);
if (result < 0) {
free(key);
return git__throw(GIT_EINVALIDARGS, "Failed to compile regex");
giterr_set_regex(&preg, result);
return -1;
}
do {
if (!regexec(&preg, var->value, 0, NULL, 0)) {
for (;;) {
if (regexec(&preg, var->value, 0, NULL, 0) == 0) {
char *tmp = git__strdup(value);
if (tmp == NULL) {
error = GIT_ENOMEM;
goto exit;
}
GITERR_CHECK_ALLOC(tmp);
free(var->value);
var->value = tmp;
replaced = 1;
}
if (var->next != NULL)
var = var->next;
else
if (var->next == NULL)
break;
} while (var != NULL);
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));
if (newvar == NULL) {
error = GIT_ENOMEM;
goto exit;
}
GITERR_CHECK_ALLOC(newvar);
memset(newvar, 0x0, sizeof(cvar_t));
newvar->key = git__strdup(var->key);
if (newvar->key == NULL) {
error = GIT_ENOMEM;
goto exit;
}
GITERR_CHECK_ALLOC(newvar->key);
newvar->value = git__strdup(value);
if (newvar->value == NULL) {
error = GIT_ENOMEM;
goto exit;
}
GITERR_CHECK_ALLOC(newvar->value);
var->next = newvar;
}
error = config_write(b, key, &preg, value);
if (error < GIT_SUCCESS) {
error = git__rethrow(error, "Failed to update value in file");
goto exit;
}
result = config_write(b, key, &preg, value);
exit:
free(key);
regfree(&preg);
return error;
return result;
}
static int config_delete(git_config_file *cfg, const char *name)
{
int error;
const cvar_t *var;
cvar_t *old_value;
cvar_t *var;
diskfile_backend *b = (diskfile_backend *)cfg;
char *key;
int result;
if ((error = normalize_name(name, &key)) < GIT_SUCCESS)
return error;
if (normalize_name(name, &key) < 0)
return -1;
var = git_hashtable_lookup(b->values, key);
free(key);
if (var == NULL)
return git__throw(GIT_ENOTFOUND, "Variable '%s' not found", name);
if (var->next != NULL)
return git__throw(GIT_EINVALIDARGS, "Multivar incompatible with simple delete");
return GIT_ENOTFOUND;
if (var->next != NULL) {
giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete");
return -1;
}
if ((error = git_hashtable_remove2(b->values, var->key, (void **)&old_value)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to remove %s from hashtable", key);
error = config_write(b, var->key, NULL, NULL);
cvar_free(old_value);
git_hashtable_remove(b->values, var->key);
result = config_write(b, var->key, NULL, NULL);
return error;
cvar_free(var);
return result;
}
int git_config_file__ondisk(git_config_file **out, const char *path)
......@@ -450,16 +444,12 @@ int git_config_file__ondisk(git_config_file **out, const char *path)
diskfile_backend *backend;
backend = git__malloc(sizeof(diskfile_backend));
if (backend == NULL)
return GIT_ENOMEM;
GITERR_CHECK_ALLOC(backend);
memset(backend, 0x0, sizeof(diskfile_backend));
backend->file_path = git__strdup(path);
if (backend->file_path == NULL) {
git__free(backend);
return GIT_ENOMEM;
}
GITERR_CHECK_ALLOC(backend->file_path);
backend->parent.open = config_open;
backend->parent.get = config_get;
......@@ -472,7 +462,7 @@ int git_config_file__ondisk(git_config_file **out, const char *path)
*out = (git_config_file *)backend;
return GIT_SUCCESS;
return 0;
}
static int cfg_getchar_raw(diskfile_backend *cfg)
......@@ -621,12 +611,11 @@ GIT_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)
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 error = GIT_SUCCESS;
int quote_marks;
/*
* base_name is what came before the space. We should be at the
......@@ -637,8 +626,10 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha
first_quote = strchr(line, '"');
last_quote = strrchr(line, '"');
if (last_quote - first_quote == 0)
return git__throw(GIT_EOBJCORRUPTED, "Failed to parse ext header. There is no final quotation mark");
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);
......@@ -655,27 +646,30 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha
*/
do {
if (quote_marks == 2) {
puts("too many marks");
error = git__throw(GIT_EOBJCORRUPTED, "Falied to parse ext header. Text after closing quote");
goto out;
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:
error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse ext header. Unsupported escape char \\%c", c);
goto out;
set_parse_error(cfg, rpos, "Unsupported escape sequence");
git_buf_free(&buf);
return -1;
}
break;
default:
break;
}
......@@ -683,61 +677,53 @@ static int parse_section_header_ext(const char *line, const char *base_name, cha
git_buf_putc(&buf, c);
} while ((c = line[rpos++]) != ']');
*section_name = git__strdup(git_buf_cstr(&buf));
out:
git_buf_free(&buf);
return error;
*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 error = GIT_SUCCESS;
int result;
char *line;
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
return -1;
/* find the end of the variable's name */
name_end = strchr(line, ']');
if (name_end == NULL) {
git__free(line);
return git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Can't find header name end");
set_parse_error(cfg, 0, "Missing ']' in section header");
return -1;
}
name = (char *)git__malloc((size_t)(name_end - line) + 1);
if (name == NULL) {
git__free(line);
return GIT_ENOMEM;
}
GITERR_CHECK_ALLOC(name);
name_length = 0;
pos = 0;
/* Make sure we were given a section header */
c = line[pos++];
if (c != '[') {
error = git__throw(GIT_ERROR, "Failed to parse header. Didn't get section header. This is a bug");
goto error;
}
assert(c == '[');
c = line[pos++];
do {
if (isspace(c)){
name[name_length] = '\0';
error = parse_section_header_ext(line, name, section_out);
result = parse_section_header_ext(cfg, line, name, section_out);
git__free(line);
git__free(name);
return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse header");
return result;
}
if (!config_keychar(c) && c != '.') {
error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Wrong format on header");
goto error;
set_parse_error(cfg, pos, "Unexpected character in header");
goto fail_parse;
}
name[name_length++] = (char) tolower(c);
......@@ -745,20 +731,21 @@ static int parse_section_header(diskfile_backend *cfg, char **section_out)
} while ((c = line[pos++]) != ']');
if (line[pos - 1] != ']') {
error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse header. Config file ended unexpectedly");
goto error;
set_parse_error(cfg, pos, "Unexpected end of file");
goto fail_parse;
}
name[name_length] = 0;
git__free(line);
git__strtolower(name);
name[name_length] = 0;
*section_out = name;
return GIT_SUCCESS;
error:
return 0;
fail_parse:
git__free(line);
git__free(name);
return error;
return -1;
}
static int skip_bom(diskfile_backend *cfg)
......@@ -766,7 +753,7 @@ static int skip_bom(diskfile_backend *cfg)
static const char utf8_bom[] = "\xef\xbb\xbf";
if (cfg->reader.buffer.size < sizeof(utf8_bom))
return GIT_SUCCESS;
return 0;
if (memcmp(cfg->reader.read_ptr, utf8_bom, sizeof(utf8_bom)) == 0)
cfg->reader.read_ptr += sizeof(utf8_bom);
......@@ -775,7 +762,7 @@ static int skip_bom(diskfile_backend *cfg)
shit with the BoM
*/
return GIT_SUCCESS;
return 0;
}
/*
......@@ -839,12 +826,13 @@ static void strip_comments(char *line)
static int config_parse(diskfile_backend *cfg_file)
{
int error = GIT_SUCCESS, c;
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;
/* Initialize the reading position */
cfg_file->reader.read_ptr = cfg_file->reader.buffer.ptr;
......@@ -852,11 +840,11 @@ static int config_parse(diskfile_backend *cfg_file)
/* If the file is empty, there's nothing for us to do */
if (*cfg_file->reader.read_ptr == '\0')
return GIT_SUCCESS;
return 0;
skip_bom(cfg_file);
while (error == GIT_SUCCESS && !cfg_file->reader.eof) {
while (result == 0 && !cfg_file->reader.eof) {
c = cfg_peek(cfg_file, SKIP_WHITESPACE);
......@@ -868,7 +856,7 @@ static int config_parse(diskfile_backend *cfg_file)
case '[': /* section header, new section begins */
git__free(current_section);
current_section = NULL;
error = parse_section_header(cfg_file, &current_section);
result = parse_section_header(cfg_file, &current_section);
break;
case ';':
......@@ -877,16 +865,12 @@ static int config_parse(diskfile_backend *cfg_file)
break;
default: /* assume variable declaration */
error = parse_variable(cfg_file, &var_name, &var_value);
if (error < GIT_SUCCESS)
result = parse_variable(cfg_file, &var_name, &var_value);
if (result < 0)
break;
var = git__malloc(sizeof(cvar_t));
if (var == NULL) {
error = GIT_ENOMEM;
break;
}
GITERR_CHECK_ALLOC(var);
memset(var, 0x0, sizeof(cvar_t));
......@@ -894,10 +878,8 @@ static int config_parse(diskfile_backend *cfg_file)
git_buf_printf(&buf, "%s.%s", current_section, var_name);
git__free(var_name);
if (git_buf_oom(&buf)) {
error = GIT_ENOMEM;
break;
}
if (git_buf_oom(&buf))
return -1;
var->key = git_buf_detach(&buf);
var->value = var_value;
......@@ -905,7 +887,7 @@ static int config_parse(diskfile_backend *cfg_file)
/* Add or append the new config option */
existing = git_hashtable_lookup(cfg_file->values, var->key);
if (existing == NULL) {
error = git_hashtable_insert(cfg_file->values, var->key, var);
result = git_hashtable_insert(cfg_file->values, var->key, var);
} else {
while (existing->next != NULL) {
existing = existing->next;
......@@ -918,13 +900,12 @@ static int config_parse(diskfile_backend *cfg_file)
}
git__free(current_section);
return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse config");
return result;
}
static int write_section(git_filebuf *file, const char *key)
{
int error;
int result;
const char *fdot, *ldot;
git_buf buf = GIT_BUF_INIT;
......@@ -943,13 +924,14 @@ static int write_section(git_filebuf *file, const char *key)
git_buf_putc(&buf, '"');
}
git_buf_puts(&buf, "]\n");
if (git_buf_oom(&buf))
return GIT_ENOMEM;
return -1;
error = git_filebuf_write(file, git_buf_cstr(&buf), buf.size);
result = git_filebuf_write(file, git_buf_cstr(&buf), buf.size);
git_buf_free(&buf);
return error;
return result;
}
/*
......@@ -957,50 +939,45 @@ static int write_section(git_filebuf *file, const char *key)
*/
static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char* value)
{
int error = GIT_SUCCESS, c;
int section_matches = 0, last_section_matched = 0, preg_replaced = 0;
int result, c;
int section_matches = 0, last_section_matched = 0, preg_replaced = 0, write_trailer = 0;
const char *pre_end = NULL, *post_start = NULL, *data_start;
char *current_section = NULL, *section, *name, *ldot;
char *var_name, *var_value;
git_filebuf file = GIT_FILEBUF_INIT;
const char *pre_end = NULL, *post_start = NULL, *data_start;
/* We need to read in our own config file */
error = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path);
if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) {
return git__rethrow(error, "Failed to read existing config file %s", cfg->file_path);
}
result = git_futils_readbuffer(&cfg->reader.buffer, cfg->file_path);
/* Initialise the reading position */
if (error == GIT_ENOTFOUND) {
error = GIT_SUCCESS;
if (result == GIT_ENOTFOUND) {
cfg->reader.read_ptr = NULL;
cfg->reader.eof = 1;
data_start = NULL;
git_buf_clear(&cfg->reader.buffer);
} else {
} else if (result == 0) {
cfg->reader.read_ptr = cfg->reader.buffer.ptr;
cfg->reader.eof = 0;
data_start = cfg->reader.read_ptr;
} else {
return -1; /* OS error when reading the file */
}
/* Lock the file */
error = git_filebuf_open(&file, cfg->file_path, 0);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to lock config file");
if (git_filebuf_open(&file, cfg->file_path, 0) < 0)
return -1;
skip_bom(cfg);
ldot = strrchr(key, '.');
name = ldot + 1;
section = git__strndup(key, ldot - key);
while (error == GIT_SUCCESS && !cfg->reader.eof) {
while (!cfg->reader.eof) {
c = cfg_peek(cfg, SKIP_WHITESPACE);
switch (c) {
case '\0': /* We've arrived at the end of the file */
if (c == '\0') { /* We've arrived at the end of the file */
break;
case '[': /* section header, new section begins */
} else if (c == '[') { /* section header, new section begins */
/*
* We set both positions to the current one in case we
* need to add a variable to the end of a section. In that
......@@ -1009,23 +986,21 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
* default case will take care of updating them.
*/
pre_end = post_start = cfg->reader.read_ptr;
if (current_section)
git__free(current_section);
error = parse_section_header(cfg, &current_section);
if (error < GIT_SUCCESS)
break;
git__free(current_section);
if (parse_section_header(cfg, &current_section) < 0)
goto rewrite_fail;
/* Keep track of when it stops matching */
last_section_matched = section_matches;
section_matches = !strcmp(current_section, section);
break;
}
case ';':
case '#':
else if (c == ';' || c == '#') {
cfg_consume_line(cfg);
break;
}
default:
else {
/*
* If the section doesn't match, but the last section did,
* it means we need to add a variable (so skip the line
......@@ -1039,67 +1014,54 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
if (!section_matches) {
if (!last_section_matched) {
cfg_consume_line(cfg);
break;
continue;
}
} else {
int cmp = -1;
int has_matched = 0;
char *var_name, *var_value;
pre_end = cfg->reader.read_ptr;
if ((error = parse_variable(cfg, &var_name, &var_value)) == GIT_SUCCESS)
cmp = strcasecmp(name, var_name);
if (parse_variable(cfg, &var_name, &var_value) < 0)
goto rewrite_fail;
if (cmp == 0 && preg != NULL)
cmp = regexec(preg, var_value, 0, NULL, 0);
/* First try to match the name of the variable */
if (strcasecmp(name, var_name) == 0)
has_matched = 1;
/* If the name matches, and we have a regex to match the
* value, try to match it */
if (has_matched && preg != NULL)
has_matched = (regexec(preg, var_value, 0, NULL, 0) == 0);
git__free(var_name);
git__free(var_value);
if (cmp != 0)
break;
/* if there is no match, keep going */
if (!has_matched)
continue;
post_start = cfg->reader.read_ptr;
}
/*
* We've found the variable we wanted to change, so
* write anything up to it
*/
/* We've found the variable we wanted to change, so
* write anything up to it */
git_filebuf_write(&file, data_start, pre_end - data_start);
preg_replaced = 1;
error = git_filebuf_write(&file, data_start, pre_end - data_start);
if (error < GIT_SUCCESS) {
git__rethrow(error, "Failed to write the first part of the file");
break;
}
/*
* Then replace the variable. If the value is NULL, it
* means we want to delete it, so pretend everything went
* fine
*/
if (value == NULL)
error = GIT_SUCCESS;
else
error = git_filebuf_printf(&file, "\t%s = %s\n", name, value);
if (error < GIT_SUCCESS) {
git__rethrow(error, "Failed to overwrite the variable");
break;
/* Then replace the variable. If the value is NULL, it
* means we want to delete it, so don't write anything. */
if (value != NULL) {
git_filebuf_printf(&file, "\t%s = %s\n", name, value);
}
/* multiline variable? we need to keep reading lines to match */
if (preg != NULL) {
data_start = post_start;
continue;
}
/* And then the write out rest of the file */
error = git_filebuf_write(&file, post_start,
cfg->reader.buffer.size - (post_start - data_start));
if (error < GIT_SUCCESS) {
git__rethrow(error, "Failed to write the rest of the file");
break;
}
goto cleanup;
write_trailer = 1;
break; /* break from the loop */
}
}
......@@ -1119,132 +1081,108 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
* want to write the rest of the file. Otherwise we need to write
* out the whole file and then the new variable.
*/
if (preg_replaced) {
error = git_filebuf_printf(&file, "\n%s", data_start);
if (error < GIT_SUCCESS)
error = git__rethrow(error, "Failed to write the rest of the file");
goto cleanup;
}
if (write_trailer) {
/* Write out rest of the file */
git_filebuf_write(&file, post_start, cfg->reader.buffer.size - (post_start - data_start));
} else {
if (preg_replaced) {
git_filebuf_printf(&file, "\n%s", data_start);
} else {
git_filebuf_write(&file, cfg->reader.buffer.ptr, cfg->reader.buffer.size);
/* And now if we just need to add a variable */
if (!section_matches && write_section(&file, section) < 0)
goto rewrite_fail;
/* Sanity check: if we are here, and value is NULL, that means that somebody
* touched the config file after our intial read. We should probably assert()
* this, but instead we'll handle it gracefully with an error. */
if (value == NULL) {
giterr_set(GITERR_CONFIG,
"Race condition when writing a config file (a cvar has been removed)");
goto rewrite_fail;
}
error = git_filebuf_write(&file, cfg->reader.buffer.ptr, cfg->reader.buffer.size);
if (error < GIT_SUCCESS) {
git__rethrow(error, "Failed to write original config content");
goto cleanup;
git_filebuf_printf(&file, "\t%s = %s\n", name, value);
}
}
/* And now if we just need to add a variable */
if (section_matches) {
error = git_filebuf_printf(&file, "\t%s = %s\n", name, value);
goto cleanup;
}
git__free(section);
git__free(current_section);
/* Or maybe we need to write out a whole section */
error = write_section(&file, section);
if (error < GIT_SUCCESS)
git__rethrow(error, "Failed to write new section");
result = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE);
git_buf_free(&cfg->reader.buffer);
return result;
error = git_filebuf_printf(&file, "\t%s = %s\n", name, value);
cleanup:
rewrite_fail:
git__free(section);
git__free(current_section);
if (error < GIT_SUCCESS)
git_filebuf_cleanup(&file);
else
error = git_filebuf_commit(&file, GIT_CONFIG_FILE_MODE);
git_filebuf_cleanup(&file);
git_buf_free(&cfg->reader.buffer);
return error;
return -1;
}
static int is_multiline_var(const char *str)
{
char *end = strrchr(str, '\0') - 1;
while (isspace(*end))
--end;
return *end == '\\';
const char *end = str + strlen(str);
return (end > str) && (end[-1] == '\\');
}
static int parse_multiline_variable(diskfile_backend *cfg, const char *first, char **out)
static int parse_multiline_variable(diskfile_backend *cfg, git_buf *value)
{
char *line = NULL, *end;
int error = GIT_SUCCESS, ret;
size_t len;
char *buf;
char *line = NULL;
/* Check that the next line exists */
line = cfg_readline(cfg);
if (line == NULL)
return GIT_ENOMEM;
return -1;
/* We've reached the end of the file, there is input missing */
if (line[0] == '\0') {
error = git__throw(GIT_EOBJCORRUPTED, "Failed to parse multiline var. File ended unexpectedly");
goto out;
set_parse_error(cfg, 0, "Unexpected end of file while parsing multine var");
git__free(line);
return -1;
}
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;
git__free(line);
return parse_multiline_variable(cfg, value);
/* TODO: unbounded recursion. This **could** be exploitable */
}
/* Find the continuation character '\' and strip the whitespace */
end = strrchr(first, '\\');
while (isspace(end[-1]))
--end;
*end = '\0'; /* Terminate the string here */
/* Drop the continuation character '\': to closely follow the UNIX
* standard, this character **has** to be last one in the buf, with
* no whitespace after it */
assert(is_multiline_var(value->ptr));
git_buf_truncate(value, value->size - 1);
len = strlen(first) + strlen(line) + 2;
buf = git__malloc(len);
if (buf == NULL) {
error = GIT_ENOMEM;
goto out;
}
ret = p_snprintf(buf, len, "%s %s", first, line);
if (ret < 0) {
error = git__throw(GIT_EOSERR, "Failed to parse multiline var. Failed to put together two lines. OS err: %s", strerror(errno));
git__free(buf);
goto out;
}
/* add this line to the multiline var */
git_buf_puts(value, line);
git__free(line);
/*
* 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 we need to continue reading the next line, let's just
* keep putting stuff in the buffer
*/
if (is_multiline_var(buf)) {
char *final_val;
error = parse_multiline_variable(cfg, buf, &final_val);
git__free(buf);
buf = final_val;
}
*out = buf;
if (is_multiline_var(value->ptr))
return parse_multiline_variable(cfg, value);
out:
git__free(line);
return error;
return 0;
}
static int parse_variable(diskfile_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;
return -1;
strip_comments(line);
......@@ -1260,52 +1198,39 @@ static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_val
while (isspace(var_end[0]));
}
tmp = git__strndup(line, var_end - line + 1);
if (tmp == NULL) {
error = GIT_ENOMEM;
goto out;
}
*var_name = git__strndup(line, var_end - line + 1);
GITERR_CHECK_ALLOC(*var_name);
*var_name = tmp;
/* If there is no value, boolean true is assumed */
*var_value = NULL;
/*
* Now, let's try to parse the value
*/
if (value_start != NULL) {
while (isspace(value_start[0]))
value_start++;
if (value_start[0] == '\0') {
*var_value = NULL;
goto out;
}
if (is_multiline_var(value_start)) {
error = parse_multiline_variable(cfg, value_start, var_value);
if (error != GIT_SUCCESS)
{
*var_value = NULL;
git_buf multi_value = GIT_BUF_INIT;
git_buf_puts(&multi_value, value_start);
if (parse_multiline_variable(cfg, &multi_value) < 0 || git_buf_oom(&multi_value)) {
git__free(*var_name);
git__free(line);
git_buf_free(&multi_value);
return -1;
}
goto out;
}
tmp = git__strdup(value_start);
if (tmp == NULL) {
git__free(*var_name);
*var_value = NULL;
error = GIT_ENOMEM;
goto out;
*var_value = git_buf_detach(&multi_value);
}
else if (value_start[0] != '\0') {
*var_value = git__strdup(value_start);
GITERR_CHECK_ALLOC(*var_value);
}
*var_value = tmp;
} else {
/* If there is no value, boolean true is assumed */
*var_value = NULL;
}
out:
git__free(line);
return error;
return 0;
}
src/errors.c
......@@ -122,25 +122,28 @@ void giterr_set(int error_class, const char *string, ...)
{
char error_str[1024];
va_list arglist;
git_error *error;
const char *oserr =
(error_class == GITERR_OS && errno != 0) ? strerror(errno) : NULL;
error = &GIT_GLOBAL->error_t;
free(error->message);
va_start(arglist, string);
p_vsnprintf(error_str, sizeof(error_str), string, arglist);
va_end(arglist);
/* automatically suffix strerror(errno) for GITERR_OS errors */
if (oserr != NULL) {
if (error_class == GITERR_OS) {
strncat(error_str, ": ", sizeof(error_str));
strncat(error_str, oserr, sizeof(error_str));
strncat(error_str, strerror(errno), sizeof(error_str));
errno = 0;
}
error->message = git__strdup(error_str);
giterr_set_str(error_class, error_str);
}
void giterr_set_str(int error_class, const char *string)
{
git_error *error = &GIT_GLOBAL->error_t;
free(error->message);
error->message = git__strdup(string);
error->klass = error_class;
if (error->message == NULL) {
......@@ -151,6 +154,13 @@ void giterr_set(int error_class, const char *string, ...)
GIT_GLOBAL->last_error = error;
}
void giterr_set_regex(const regex_t *regex, int error_code)
{
char error_buf[1024];
regerror(error_code, regex, error_buf, sizeof(error_buf));
giterr_set_str(GITERR_REGEX, error_buf);
}
void giterr_clear(void)
{
GIT_GLOBAL->last_error = NULL;
......
src/filebuf.c
......@@ -14,6 +14,36 @@
static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
enum buferr_t {
BUFERR_OK = 0,
BUFERR_WRITE,
BUFERR_ZLIB,
BUFERR_MEM
};
#define ENSURE_BUF_OK(buf) if ((buf)->last_error != BUFERR_OK) { return -1; }
static int verify_last_error(git_filebuf *file)
{
switch (file->last_error) {
case BUFERR_WRITE:
giterr_set(GITERR_OS, "Failed to write out file");
return -1;
case BUFERR_MEM:
giterr_set_oom();
return -1;
case BUFERR_ZLIB:
giterr_set(GITERR_ZLIB,
"Buffer error when writing out ZLib data");
return -1;
default:
return 0;
}
}
static int lock_file(git_filebuf *file, int flags)
{
if (git_path_exists(file->path_lock) == true) {
......@@ -100,20 +130,21 @@ GIT_INLINE(int) flush_buffer(git_filebuf *file)
static int write_normal(git_filebuf *file, void *source, size_t len)
{
int result = 0;
if (len > 0) {
result = p_write(file->fd, (void *)source, len);
if (p_write(file->fd, (void *)source, len) < 0) {
file->last_error = BUFERR_WRITE;
return -1;
}
if (file->digest)
git_hash_update(file->digest, source, len);
}
return result;
return 0;
}
static int write_deflate(git_filebuf *file, void *source, size_t len)
{
int result = Z_OK;
z_stream *zs = &file->zs;
if (len > 0 || file->flush_mode == Z_FINISH) {
......@@ -126,14 +157,17 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
zs->next_out = file->z_buf;
zs->avail_out = (uInt)file->buf_size;
result = deflate(zs, file->flush_mode);
if (result == Z_STREAM_ERROR)
return git__throw(GIT_ERROR, "Failed to deflate input");
if (deflate(zs, file->flush_mode) == Z_STREAM_ERROR) {
file->last_error = BUFERR_ZLIB;
return -1;
}
have = file->buf_size - (size_t)zs->avail_out;
if (p_write(file->fd, file->z_buf, have) < GIT_SUCCESS)
return git__throw(GIT_EOSERR, "Failed to write to file");
if (p_write(file->fd, file->z_buf, have) < 0) {
file->last_error = BUFERR_WRITE;
return -1;
}
} while (zs->avail_out == 0);
......@@ -143,7 +177,7 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
git_hash_update(file->digest, source, len);
}
return GIT_SUCCESS;
return 0;
}
int git_filebuf_open(git_filebuf *file, const char *path, int flags)
......@@ -161,6 +195,7 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags)
file->buf_size = WRITE_BUFFER_SIZE;
file->buf_pos = 0;
file->fd = -1;
file->last_error = BUFERR_OK;
/* Allocate the main cache buffer */
file->buffer = git__malloc(file->buf_size);
......@@ -237,58 +272,61 @@ cleanup:
int git_filebuf_hash(git_oid *oid, git_filebuf *file)
{
int error;
assert(oid && file && file->digest);
if ((error = flush_buffer(file)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to get hash for file");
flush_buffer(file);
if (verify_last_error(file) < 0)
return -1;
git_hash_final(oid, file->digest);
git_hash_free_ctx(file->digest);
file->digest = NULL;
return GIT_SUCCESS;
return 0;
}
int git_filebuf_commit_at(git_filebuf *file, const char *path, mode_t mode)
{
git__free(file->path_original);
file->path_original = git__strdup(path);
if (file->path_original == NULL)
return GIT_ENOMEM;
GITERR_CHECK_ALLOC(file->path_original);
return git_filebuf_commit(file, mode);
}
int git_filebuf_commit(git_filebuf *file, mode_t mode)
{
int error;
/* temporary files cannot be committed */
assert(file && file->path_original);
file->flush_mode = Z_FINISH;
if ((error = flush_buffer(file)) < GIT_SUCCESS)
goto cleanup;
flush_buffer(file);
if (verify_last_error(file) < 0)
goto on_error;
p_close(file->fd);
file->fd = -1;
if (p_chmod(file->path_lock, mode)) {
error = git__throw(GIT_EOSERR, "Failed to chmod locked file before committing");
goto cleanup;
giterr_set(GITERR_OS, "Failed to set attributes for file at '%s'", file->path_lock);
goto on_error;
}
p_unlink(file->path_original);
error = p_rename(file->path_lock, file->path_original);
if (p_rename(file->path_lock, file->path_original) < 0) {
giterr_set(GITERR_OS, "Failed to rename lockfile to '%s'", file->path_original);
goto on_error;
}
cleanup:
git_filebuf_cleanup(file);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to commit locked file from buffer");
return GIT_SUCCESS;
return 0;
on_error:
git_filebuf_cleanup(file);
return -1;
}
GIT_INLINE(void) add_to_cache(git_filebuf *file, const void *buf, size_t len)
......@@ -299,22 +337,22 @@ GIT_INLINE(void) add_to_cache(git_filebuf *file, const void *buf, size_t len)
int git_filebuf_write(git_filebuf *file, const void *buff, size_t len)
{
int error;
const unsigned char *buf = buff;
ENSURE_BUF_OK(file);
for (;;) {
size_t space_left = file->buf_size - file->buf_pos;
/* cache if it's small */
if (space_left > len) {
add_to_cache(file, buf, len);
return GIT_SUCCESS;
return 0;
}
add_to_cache(file, buf, space_left);
if ((error = flush_buffer(file)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to write to buffer");
if (flush_buffer(file) < 0)
return -1;
len -= space_left;
buf += space_left;
......@@ -323,32 +361,37 @@ int git_filebuf_write(git_filebuf *file, const void *buff, size_t len)
int git_filebuf_reserve(git_filebuf *file, void **buffer, size_t len)
{
int error;
size_t space_left = file->buf_size - file->buf_pos;
*buffer = NULL;
if (len > file->buf_size)
return GIT_ENOMEM;
ENSURE_BUF_OK(file);
if (len > file->buf_size) {
file->last_error = BUFERR_MEM;
return -1;
}
if (space_left <= len) {
if ((error = flush_buffer(file)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to reserve buffer");
if (flush_buffer(file) < 0)
return -1;
}
*buffer = (file->buffer + file->buf_pos);
file->buf_pos += len;
return GIT_SUCCESS;
return 0;
}
int git_filebuf_printf(git_filebuf *file, const char *format, ...)
{
va_list arglist;
size_t space_left;
int len, error;
int len, res;
char *tmp_buffer;
ENSURE_BUF_OK(file);
space_left = file->buf_size - file->buf_pos;
do {
......@@ -356,24 +399,28 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...)
len = p_vsnprintf((char *)file->buffer + file->buf_pos, space_left, format, arglist);
va_end(arglist);
if (len < 0)
return git__throw(GIT_EOSERR, "Failed to format string");
if (len < 0) {
file->last_error = BUFERR_MEM;
return -1;
}
if ((size_t)len + 1 <= space_left) {
file->buf_pos += len;
return GIT_SUCCESS;
return 0;
}
if ((error = flush_buffer(file)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to output to buffer");
if (flush_buffer(file) < 0)
return -1;
space_left = file->buf_size - file->buf_pos;
} while ((size_t)len + 1 <= space_left);
tmp_buffer = git__malloc(len + 1);
if (!tmp_buffer)
return GIT_ENOMEM;
if (!tmp_buffer) {
file->last_error = BUFERR_MEM;
return -1;
}
va_start(arglist, format);
len = p_vsnprintf(tmp_buffer, len + 1, format, arglist);
......@@ -381,12 +428,13 @@ int git_filebuf_printf(git_filebuf *file, const char *format, ...)
if (len < 0) {
git__free(tmp_buffer);
return git__throw(GIT_EOSERR, "Failed to format string");
file->last_error = BUFERR_MEM;
return -1;
}
error = git_filebuf_write(file, tmp_buffer, len);
res = git_filebuf_write(file, tmp_buffer, len);
git__free(tmp_buffer);
return error;
return res;
}
src/filebuf.h
......@@ -40,25 +40,35 @@ struct git_filebuf {
size_t buf_size, buf_pos;
git_file fd;
int last_error;
};
typedef struct git_filebuf git_filebuf;
#define GIT_FILEBUF_INIT {0}
/* The git_filebuf object lifecycle is:
/*
* The git_filebuf object lifecycle is:
* - Allocate git_filebuf, preferably using GIT_FILEBUF_INIT.
*
* - Call git_filebuf_open() to initialize the filebuf for use.
*
* - Make as many calls to git_filebuf_write(), git_filebuf_printf(),
* git_filebuf_reserve() as you like.
* git_filebuf_reserve() as you like. The error codes for these
* functions don't need to be checked. They are stored internally
* by the file buffer.
*
* - While you are writing, you may call git_filebuf_hash() to get
* the hash of all you have written so far.
* the hash of all you have written so far. This function will
* fail if any of the previous writes to the buffer failed.
*
* - To close the git_filebuf, you may call git_filebuf_commit() or
* git_filebuf_commit_at() to save the file, or
* git_filebuf_cleanup() to abandon the file. All of these will
* clear the git_filebuf object.
* free the git_filebuf object. Likewise, all of these will fail
* if any of the previous writes to the buffer failed, and set
* an error code accordingly.
*/
int git_filebuf_write(git_filebuf *lock, const void *buff, size_t len);
int git_filebuf_reserve(git_filebuf *file, void **buff, size_t len);
int git_filebuf_printf(git_filebuf *file, const char *format, ...) GIT_FORMAT_PRINTF(2, 3);
......
src/hashtable.c
......@@ -227,11 +227,11 @@ int git_hashtable_remove2(git_hashtable *self, const void *key, void **old_value
node->key = NULL;
node->value = NULL;
self->key_count--;
return GIT_SUCCESS;
return 0;
}
}
return git__throw(GIT_ENOTFOUND, "Entry not found in hash table");
return GIT_ENOTFOUND;
}
int git_hashtable_merge(git_hashtable *self, git_hashtable *other)
......
src/posix.c
......@@ -31,10 +31,9 @@ int p_getcwd(char *buffer_out, size_t size)
cwd_buffer = getcwd(buffer_out, size);
if (cwd_buffer == NULL)
return git__throw(GIT_EOSERR, "Failed to retrieve current working directory");
return -1;
git_path_mkposix(buffer_out);
git_path_string_to_dir(buffer_out, size); //Ensure the path ends with a trailing slash
return GIT_SUCCESS;
......@@ -44,14 +43,13 @@ int p_rename(const char *from, const char *to)
{
if (!link(from, to)) {
p_unlink(from);
return GIT_SUCCESS;
return 0;
}
if (!rename(from, to))
return GIT_SUCCESS;
return GIT_ERROR;
return 0;
return -1;
}
#endif
......@@ -64,7 +62,7 @@ int p_read(git_file fd, void *buf, size_t cnt)
if (r < 0) {
if (errno == EINTR || errno == EAGAIN)
continue;
return GIT_EOSERR;
return -1;
}
if (!r)
break;
......@@ -82,14 +80,14 @@ int p_write(git_file fd, const void *buf, size_t cnt)
if (r < 0) {
if (errno == EINTR || errno == EAGAIN)
continue;
return GIT_EOSERR;
return -1;
}
if (!r) {
errno = EPIPE;
return GIT_EOSERR;
return -1;
}
cnt -= r;
b += r;
}
return GIT_SUCCESS;
return 0;
}
src/util.h
......@@ -7,8 +7,6 @@
#ifndef INCLUDE_util_h__
#define INCLUDE_util_h__
#include "git2/errors.h"
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define bitsizeof(x) (CHAR_BIT * sizeof(x))
#define MSB(x, bits) ((x) & (~0ULL << (bitsizeof(x) - (bits))))
......@@ -24,24 +22,21 @@
GIT_INLINE(void *) git__malloc(size_t len)
{
void *ptr = malloc(len);
if (!ptr)
giterr_set(GITERR_NOMEMORY, "Out of memory. Failed to allocate %d bytes.", (int)len);
if (!ptr) giterr_set_oom();
return ptr;
}
GIT_INLINE(void *) git__calloc(size_t nelem, size_t elsize)
{
void *ptr = calloc(nelem, elsize);
if (!ptr)
giterr_set(GITERR_NOMEMORY, "Out of memory. Failed to allocate %d bytes.", (int)nelem*elsize);
if (!ptr) giterr_set_oom();
return ptr;
}
GIT_INLINE(char *) git__strdup(const char *str)
{
char *ptr = strdup(str);
if (!ptr)
giterr_set(GITERR_NOMEMORY, "Out of memory. Failed to duplicate string");
if (!ptr) giterr_set_oom();
return ptr;
}
......@@ -56,7 +51,7 @@ GIT_INLINE(char *) git__strndup(const char *str, size_t n)
ptr = (char*)malloc(length + 1);
if (!ptr) {
giterr_set(GITERR_NOMEMORY, "Out of memory. Failed to duplicate string");
giterr_set_oom();
return NULL;
}
......@@ -69,8 +64,7 @@ GIT_INLINE(char *) git__strndup(const char *str, size_t n)
GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
{
void *new_ptr = realloc(ptr, size);
if (!new_ptr)
giterr_set(GITERR_NOMEMORY, "Out of memory. Failed to allocate %d bytes.", (int)size);
if (!new_ptr) giterr_set_oom();
return new_ptr;
}
......
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