char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
{
void *ptr = NULL;
assert(pool && str && pool->item_size == sizeof(char));
if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) {
memcpy(ptr, str, n);
*(((char *)ptr) + n) = '\0';
}
pool->has_string_alloc = 1;
return ptr;
}
int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
{
size_t name_len;
git_tree_cache *tree;
name_len = strlen(name);
tree = git_pool_malloc(pool, sizeof(git_tree_cache) + name_len + 1);
GITERR_CHECK_ALLOC(tree);
memset(tree, 0x0, sizeof(git_tree_cache));
/* NUL-terminated tree name */
tree->namelen = name_len;
memcpy(tree->name, name, name_len);
tree->name[name_len] = '\0';
*out = tree;
return 0;
}
int git_attr_file__new(
git_attr_file **attrs_ptr,
git_attr_file_source from,
const char *path,
git_pool *pool)
{
git_attr_file *attrs = NULL;
attrs = git__calloc(1, sizeof(git_attr_file));
GITERR_CHECK_ALLOC(attrs);
if (pool)
attrs->pool = pool;
else {
attrs->pool = git__calloc(1, sizeof(git_pool));
if (!attrs->pool || git_pool_init(attrs->pool, 1, 0) < 0)
goto fail;
attrs->pool_is_allocated = true;
}
if (path) {
size_t len = strlen(path);
attrs->key = git_pool_malloc(attrs->pool, (uint32_t)len + 3);
GITERR_CHECK_ALLOC(attrs->key);
attrs->key[0] = '0' + from;
attrs->key[1] = '#';
memcpy(&attrs->key[2], path, len);
attrs->key[len + 2] = '\0';
}
if (git_vector_init(&attrs->rules, 4, NULL) < 0)
goto fail;
*attrs_ptr = attrs;
return 0;
fail:
git_attr_file__free(attrs);
attrs_ptr = NULL;
return -1;
}
char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
{
void *ptr;
size_t len_a, len_b;
assert(pool && a && b && pool->item_size == sizeof(char));
len_a = a ? strlen(a) : 0;
len_b = b ? strlen(b) : 0;
if ((ptr = git_pool_malloc(pool, (uint32_t)(len_a + len_b + 1))) != NULL) {
if (len_a)
memcpy(ptr, a, len_a);
if (len_b)
memcpy(((char *)ptr) + len_a, b, len_b);
*(((char *)ptr) + len_a + len_b) = '\0';
}
pool->has_string_alloc = 1;
return ptr;
}
int git_futils_mkdir_relative(
const char *relative_path,
const char *base,
mode_t mode,
uint32_t flags,
struct git_futils_mkdir_options *opts)
{
git_buf make_path = GIT_BUF_INIT;
ssize_t root = 0, min_root_len;
char lastch = '/', *tail;
struct stat st;
struct git_futils_mkdir_options empty_opts = {0};
int error;
if (!opts)
opts = &empty_opts;
/* build path and find "root" where we should start calling mkdir */
if (git_path_join_unrooted(&make_path, relative_path, base, &root) < 0)
return -1;
if ((error = mkdir_canonicalize(&make_path, flags)) < 0 ||
make_path.size == 0)
goto done;
/* if we are not supposed to make the whole path, reset root */
if ((flags & GIT_MKDIR_PATH) == 0)
root = git_buf_rfind(&make_path, '/');
/* advance root past drive name or network mount prefix */
min_root_len = git_path_root(make_path.ptr);
if (root < min_root_len)
root = min_root_len;
while (root >= 0 && make_path.ptr[root] == '/')
++root;
/* clip root to make_path length */
if (root > (ssize_t)make_path.size)
root = (ssize_t)make_path.size; /* i.e. NUL byte of string */
if (root < 0)
root = 0;
/* walk down tail of path making each directory */
for (tail = &make_path.ptr[root]; *tail; *tail = lastch) {
bool mkdir_attempted = false;
/* advance tail to include next path component */
while (*tail == '/')
tail++;
while (*tail && *tail != '/')
tail++;
/* truncate path at next component */
lastch = *tail;
*tail = '\0';
st.st_mode = 0;
if (opts->dir_map && git_strmap_exists(opts->dir_map, make_path.ptr))
continue;
/* See what's going on with this path component */
opts->perfdata.stat_calls++;
retry_lstat:
if (p_lstat(make_path.ptr, &st) < 0) {
if (mkdir_attempted || errno != ENOENT) {
giterr_set(GITERR_OS, "cannot access component in path '%s'", make_path.ptr);
error = -1;
goto done;
}
giterr_clear();
opts->perfdata.mkdir_calls++;
mkdir_attempted = true;
if (p_mkdir(make_path.ptr, mode) < 0) {
if (errno == EEXIST)
goto retry_lstat;
giterr_set(GITERR_OS, "failed to make directory '%s'", make_path.ptr);
error = -1;
goto done;
}
} else {
if ((error = mkdir_validate_dir(
make_path.ptr, &st, mode, flags, opts)) < 0)
goto done;
}
/* chmod if requested and necessary */
if ((error = mkdir_validate_mode(
make_path.ptr, &st, (lastch == '\0'), mode, flags, opts)) < 0)
goto done;
if (opts->dir_map && opts->pool) {
char *cache_path;
size_t alloc_size;
GITERR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
if (!git__is_uint32(alloc_size))
return -1;
cache_path = git_pool_malloc(opts->pool, (uint32_t)alloc_size);
GITERR_CHECK_ALLOC(cache_path);
memcpy(cache_path, make_path.ptr, make_path.size + 1);
git_strmap_insert(opts->dir_map, cache_path, cache_path, &error);
if (error < 0)
goto done;
}
}
error = 0;
/* check that full path really is a directory if requested & needed */
if ((flags & GIT_MKDIR_VERIFY_DIR) != 0 &&
lastch != '\0') {
opts->perfdata.stat_calls++;
if (p_stat(make_path.ptr, &st) < 0 || !S_ISDIR(st.st_mode)) {
giterr_set(GITERR_OS, "path is not a directory '%s'",
make_path.ptr);
error = GIT_ENOTFOUND;
}
}
done:
git_buf_free(&make_path);
return error;
}
git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk)
{
return (git_commit_list_node *)git_pool_malloc(&walk->commit_pool, COMMIT_ALLOC);
}
static int tree_iterator__push_frame(tree_iterator *ti)
{
int error = 0;
tree_iterator_frame *head = ti->head, *tf = NULL;
size_t i, n_entries = 0;
if (head->current >= head->n_entries || !head->entries[head->current]->tree)
return GIT_ITEROVER;
for (i = head->current; i < head->next; ++i)
n_entries += git_tree_entrycount(head->entries[i]->tree);
tf = git__calloc(sizeof(tree_iterator_frame) +
n_entries * sizeof(tree_iterator_entry *), 1);
GITERR_CHECK_ALLOC(tf);
tf->n_entries = n_entries;
tf->up = head;
head->down = tf;
ti->head = tf;
for (i = head->current, n_entries = 0; i < head->next; ++i) {
git_tree *tree = head->entries[i]->tree;
size_t j, max_j = git_tree_entrycount(tree);
for (j = 0; j < max_j; ++j) {
tree_iterator_entry *entry = git_pool_malloc(&ti->pool, 1);
GITERR_CHECK_ALLOC(entry);
entry->parent = head->entries[i];
entry->te = git_tree_entry_byindex(tree, j);
entry->tree = NULL;
tf->entries[n_entries++] = entry;
}
}
/* if ignore_case, sort entries case insensitively */
if (iterator__ignore_case(ti))
git__tsort_r(
(void **)tf->entries, tf->n_entries, tree_iterator__ci_cmp, tf);
/* pick tf->current based on "start" (or start at zero) */
if (head->startlen > 0) {
git__bsearch_r((void **)tf->entries, tf->n_entries, head,
tree_iterator__search_cmp, ti, &tf->current);
while (tf->current &&
!tree_iterator__search_cmp(head, tf->entries[tf->current-1], ti))
tf->current--;
if ((tf->start = strchr(head->start, '/')) != NULL) {
tf->start++;
tf->startlen = strlen(tf->start);
}
}
ti->path_has_filename = ti->entry_is_current = false;
if ((error = tree_iterator__set_next(ti, tf)) < 0)
return error;
/* autoexpand as needed */
if (!iterator__include_trees(ti) && tree_iterator__at_tree(ti))
return tree_iterator__push_frame(ti);
return 0;
}
int git_futils_mkdir_ext(
const char *path,
const char *base,
mode_t mode,
uint32_t flags,
struct git_futils_mkdir_options *opts)
{
int error = -1;
git_buf make_path = GIT_BUF_INIT;
ssize_t root = 0, min_root_len, root_len;
char lastch = '/', *tail;
struct stat st;
/* build path and find "root" where we should start calling mkdir */
if (git_path_join_unrooted(&make_path, path, base, &root) < 0)
return -1;
if (make_path.size == 0) {
giterr_set(GITERR_OS, "Attempt to create empty path");
goto done;
}
/* Trim trailing slashes (except the root) */
if ((root_len = git_path_root(make_path.ptr)) < 0)
root_len = 0;
else
root_len++;
while (make_path.size > (size_t)root_len &&
make_path.ptr[make_path.size - 1] == '/')
make_path.ptr[--make_path.size] = '\0';
/* if we are not supposed to made the last element, truncate it */
if ((flags & GIT_MKDIR_SKIP_LAST2) != 0) {
git_path_dirname_r(&make_path, make_path.ptr);
flags |= GIT_MKDIR_SKIP_LAST;
}
if ((flags & GIT_MKDIR_SKIP_LAST) != 0) {
git_path_dirname_r(&make_path, make_path.ptr);
}
/* We were either given the root path (or trimmed it to
* the root), we don't have anything to do.
*/
if (make_path.size <= (size_t)root_len) {
error = 0;
goto done;
}
/* if we are not supposed to make the whole path, reset root */
if ((flags & GIT_MKDIR_PATH) == 0)
root = git_buf_rfind(&make_path, '/');
/* advance root past drive name or network mount prefix */
min_root_len = git_path_root(make_path.ptr);
if (root < min_root_len)
root = min_root_len;
while (root >= 0 && make_path.ptr[root] == '/')
++root;
/* clip root to make_path length */
if (root > (ssize_t)make_path.size)
root = (ssize_t)make_path.size; /* i.e. NUL byte of string */
if (root < 0)
root = 0;
/* walk down tail of path making each directory */
for (tail = &make_path.ptr[root]; *tail; *tail = lastch) {
/* advance tail to include next path component */
while (*tail == '/')
tail++;
while (*tail && *tail != '/')
tail++;
/* truncate path at next component */
lastch = *tail;
*tail = '\0';
st.st_mode = 0;
if (opts->dir_map && git_strmap_exists(opts->dir_map, make_path.ptr))
continue;
/* See what's going on with this path component */
opts->perfdata.stat_calls++;
if (p_lstat(make_path.ptr, &st) < 0) {
opts->perfdata.mkdir_calls++;
if (errno != ENOENT || p_mkdir(make_path.ptr, mode) < 0) {
giterr_set(GITERR_OS, "Failed to make directory '%s'", make_path.ptr);
error = GIT_EEXISTS;
goto done;
}
giterr_clear();
} else {
/* with exclusive create, existing dir is an error */
if ((flags & GIT_MKDIR_EXCL) != 0) {
giterr_set(GITERR_FILESYSTEM, "Failed to make directory '%s': directory exists", make_path.ptr);
error = GIT_EEXISTS;
goto done;
}
if ((error = validate_existing(
make_path.ptr, &st, mode, flags, &opts->perfdata)) < 0)
goto done;
}
/* chmod if requested and necessary */
if (((flags & GIT_MKDIR_CHMOD_PATH) != 0 ||
(lastch == '\0' && (flags & GIT_MKDIR_CHMOD) != 0)) &&
st.st_mode != mode) {
opts->perfdata.chmod_calls++;
if ((error = p_chmod(make_path.ptr, mode)) < 0 &&
lastch == '\0') {
giterr_set(GITERR_OS, "Failed to set permissions on '%s'",
make_path.ptr);
goto done;
}
}
if (opts->dir_map && opts->pool) {
char *cache_path;
size_t alloc_size;
GITERR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
if (!git__is_uint32(alloc_size))
return -1;
cache_path = git_pool_malloc(opts->pool, (uint32_t)alloc_size);
GITERR_CHECK_ALLOC(cache_path);
memcpy(cache_path, make_path.ptr, make_path.size + 1);
git_strmap_insert(opts->dir_map, cache_path, cache_path, error);
if (error < 0)
goto done;
}
}
error = 0;
/* check that full path really is a directory if requested & needed */
if ((flags & GIT_MKDIR_VERIFY_DIR) != 0 &&
lastch != '\0') {
opts->perfdata.stat_calls++;
if (p_stat(make_path.ptr, &st) < 0 || !S_ISDIR(st.st_mode)) {
giterr_set(GITERR_OS, "Path is not a directory '%s'",
make_path.ptr);
error = GIT_ENOTFOUND;
}
}
done:
git_buf_free(&make_path);
return error;
}
static int read_tree_internal(git_tree_cache **out,
const char **buffer_in, const char *buffer_end,
git_pool *pool)
{
git_tree_cache *tree = NULL;
const char *name_start, *buffer;
int count;
buffer = name_start = *buffer_in;
if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL)
goto corrupted;
if (++buffer >= buffer_end)
goto corrupted;
if (git_tree_cache_new(&tree, name_start, pool) < 0)
return -1;
/* Blank-terminated ASCII decimal number of entries in this tree */
if (git__strtol32(&count, buffer, &buffer, 10) < 0)
goto corrupted;
tree->entry_count = count;
if (*buffer != ' ' || ++buffer >= buffer_end)
goto corrupted;
/* Number of children of the tree, newline-terminated */
if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < 0)
goto corrupted;
tree->children_count = count;
if (*buffer != '\n' || ++buffer > buffer_end)
goto corrupted;
/* The SHA1 is only there if it's not invalidated */
if (tree->entry_count >= 0) {
/* 160-bit SHA-1 for this tree and it's children */
if (buffer + GIT_OID_RAWSZ > buffer_end)
goto corrupted;
git_oid_fromraw(&tree->oid, (const unsigned char *)buffer);
buffer += GIT_OID_RAWSZ;
}
/* Parse children: */
if (tree->children_count > 0) {
unsigned int i;
tree->children = git_pool_malloc(pool, tree->children_count * sizeof(git_tree_cache *));
GITERR_CHECK_ALLOC(tree->children);
memset(tree->children, 0x0, tree->children_count * sizeof(git_tree_cache *));
for (i = 0; i < tree->children_count; ++i) {
if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
goto corrupted;
}
}
*buffer_in = buffer;
*out = tree;
return 0;
corrupted:
giterr_set(GITERR_INDEX, "Corrupted TREE extension in index");
return -1;
}
