rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/libgit2/buf.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "buf.h"
+#include "common.h"
+
+int git_buf_sanitize(git_buf *buf)
+{
+	GIT_ASSERT_ARG(buf);
+
+	if (buf->reserved > 0)
+		buf->ptr[0] = '\0';
+	else
+		buf->ptr = git_str__initstr;
+
+	buf->size = 0;
+	return 0;
+}
+
+int git_buf_tostr(git_str *out, git_buf *buf)
+{
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(buf);
+
+	if (git_buf_sanitize(buf) < 0)
+		return -1;
+
+	out->ptr = buf->ptr;
+	out->asize = buf->reserved;
+	out->size = buf->size;
+
+	buf->ptr = git_str__initstr;
+	buf->reserved = 0;
+	buf->size = 0;
+
+	return 0;
+}
+
+int git_buf_fromstr(git_buf *out, git_str *str)
+{
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(str);
+
+	out->ptr = str->ptr;
+	out->reserved = str->asize;
+	out->size = str->size;
+
+	str->ptr = git_str__initstr;
+	str->asize = 0;
+	str->size = 0;
+
+	return 0;
+}
+
+void git_buf_dispose(git_buf *buf)
+{
+	if (!buf)
+		return;
+
+	if (buf->ptr != git_str__initstr)
+		git__free(buf->ptr);
+
+	buf->ptr = git_str__initstr;
+	buf->reserved = 0;
+	buf->size = 0;
+}
+
+#ifndef GIT_DEPRECATE_HARD
+int git_buf_grow(git_buf *buffer, size_t target_size)
+{
+	char *newptr;
+
+	if (buffer->reserved >= target_size)
+		return 0;
+
+	if (buffer->ptr == git_str__initstr)
+		newptr = git__malloc(target_size);
+	else
+		newptr = git__realloc(buffer->ptr, target_size);
+
+	if (!newptr)
+		return -1;
+
+	buffer->ptr = newptr;
+	buffer->reserved = target_size;
+	return 0;
+}
+
+int git_buf_set(git_buf *buffer, const void *data, size_t datalen)
+{
+	size_t alloclen;
+
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, datalen, 1);
+
+	if (git_buf_grow(buffer, alloclen) < 0)
+		return -1;
+
+	memmove(buffer->ptr, data, datalen);
+	buffer->size = datalen;
+	buffer->ptr[buffer->size] = '\0';
+
+	return 0;
+}
+
+int git_buf_is_binary(const git_buf *buf)
+{
+	git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size);
+	return git_str_is_binary(&str);
+}
+
+int git_buf_contains_nul(const git_buf *buf)
+{
+	git_str str = GIT_STR_INIT_CONST(buf->ptr, buf->size);
+	return git_str_contains_nul(&str);
+}
+
+void git_buf_free(git_buf *buffer)
+{
+	git_buf_dispose(buffer);
+}
+
+#endif

data/vendor/libgit2/src/libgit2/buf.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_buf_h__
+#define INCLUDE_buf_h__
+
+#include "git2/buffer.h"
+#include "common.h"
+
+/*
+ * Adapts a private API that takes a `git_str` into a public API that
+ * takes a `git_buf`.
+ */
+
+#define GIT_BUF_WRAP_PRIVATE(buf, fn, ...) \
+  { \
+	git_str str = GIT_STR_INIT; \
+	int error; \
+	if ((error = git_buf_tostr(&str, buf)) == 0 && \
+	    (error = fn(&str, __VA_ARGS__)) == 0) \
+		error = git_buf_fromstr(buf, &str); \
+	git_str_dispose(&str); \
+	return error; \
+}
+
+/**
+ * "Sanitizes" a buffer from user input.  This simply ensures that the
+ * `git_buf` has nice defaults if the user didn't set the members to
+ * anything, so that if we return early we don't leave it populated
+ * with nonsense.
+ */
+extern int git_buf_sanitize(git_buf *from_user);
+
+/**
+ * Populate a `git_str` from a `git_buf` for passing to libgit2 internal
+ * functions.  Sanitizes the given `git_buf` before proceeding.  The
+ * `git_buf` will no longer point to this memory.
+ */
+extern int git_buf_tostr(git_str *out, git_buf *buf);
+
+/**
+ * Populate a `git_buf` from a `git_str` for returning to a user.
+ * The `git_str` will no longer point to this memory.
+ */
+extern int git_buf_fromstr(git_buf *out, git_str *str);
+
+#endif

data/vendor/libgit2/src/{cache.c → libgit2/cache.c}

@@ -14,6 +14,9 @@
 #include "odb.h"
 #include "object.h"
 #include "git2/oid.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_FUNCTIONS(git_cache_oidmap, GIT_HASHMAP_INLINE, git_cached_obj *);
 
 bool git_cache__enabled = true;
 ssize_t git_cache__max_storage = (256 * 1024 * 1024);
@@ -45,9 +48,6 @@ int git_cache_init(git_cache *cache)
 {
 	memset(cache, 0, sizeof(*cache));
 
-	if ((git_oidmap_new(&cache->map)) < 0)
-		return -1;
-
 	if (git_rwlock_init(&cache->lock)) {
 		git_error_set(GIT_ERROR_OS, "failed to initialize cache rwlock");
 		return -1;
@@ -60,15 +60,15 @@ int git_cache_init(git_cache *cache)
 static void clear_cache(git_cache *cache)
 {
 	git_cached_obj *evict = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	if (git_cache_size(cache) == 0)
 		return;
 
-	git_oidmap_foreach_value(cache->map, evict, {
+	while (git_cache_oidmap_iterate(&iter, NULL, &evict, &cache->map) == 0)
 		git_cached_obj_decref(evict);
-	});
 
-	git_oidmap_clear(cache->map);
+	git_cache_oidmap_clear(&cache->map);
 	git_atomic_ssize_add(&git_cache__current_storage, -cache->used_memory);
 	cache->used_memory = 0;
 }
@@ -83,10 +83,15 @@ void git_cache_clear(git_cache *cache)
 	git_rwlock_wrunlock(&cache->lock);
 }
 
+size_t git_cache_size(git_cache *cache)
+{
+	return git_cache_oidmap_size(&cache->map);
+}
+
 void git_cache_dispose(git_cache *cache)
 {
 	git_cache_clear(cache);
-	git_oidmap_free(cache->map);
+	git_cache_oidmap_dispose(&cache->map);
 	git_rwlock_free(&cache->lock);
 	git__memzero(cache, sizeof(*cache));
 }
@@ -94,8 +99,9 @@ void git_cache_dispose(git_cache *cache)
 /* Called with lock */
 static void cache_evict_entries(git_cache *cache)
 {
-	size_t evict_count = git_cache_size(cache) / 2048, i;
+	size_t evict_count = git_cache_size(cache) / 2048;
 	ssize_t evicted_memory = 0;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	if (evict_count < 8)
 		evict_count = 8;
@@ -106,17 +112,16 @@ static void cache_evict_entries(git_cache *cache)
 		return;
 	}
 
-	i = 0;
 	while (evict_count > 0) {
-		git_cached_obj *evict;
 		const git_oid *key;
+		git_cached_obj *evict;
 
-		if (git_oidmap_iterate((void **) &evict, cache->map, &i, &key) == GIT_ITEROVER)
+		if (git_cache_oidmap_iterate(&iter, &key, &evict, &cache->map) != 0)
 			break;
 
 		evict_count--;
 		evicted_memory += evict->size;
-		git_oidmap_delete(cache->map, key);
+		git_cache_oidmap_remove(&cache->map, key);
 		git_cached_obj_decref(evict);
 	}
 
@@ -132,12 +137,12 @@ static bool cache_should_store(git_object_t object_type, size_t object_size)
 
 static void *cache_get(git_cache *cache, const git_oid *oid, unsigned int flags)
 {
-	git_cached_obj *entry;
+	git_cached_obj *entry = NULL;
 
 	if (!git_cache__enabled || git_rwlock_rdlock(&cache->lock) < 0)
 		return NULL;
 
-	if ((entry = git_oidmap_get(cache->map, oid)) != NULL) {
+	if (git_cache_oidmap_get(&entry, &cache->map, oid) == 0) {
 		if (flags && entry->flags != flags) {
 			entry = NULL;
 		} else {
@@ -172,8 +177,8 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 		cache_evict_entries(cache);
 
 	/* not found */
-	if ((stored_entry = git_oidmap_get(cache->map, &entry->oid)) == NULL) {
-		if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+	if (git_cache_oidmap_get(&stored_entry, &cache->map, &entry->oid) != 0) {
+		if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
 			git_cached_obj_incref(entry);
 			cache->used_memory += entry->size;
 			git_atomic_ssize_add(&git_cache__current_storage, (ssize_t)entry->size);
@@ -187,7 +192,7 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 			entry = stored_entry;
 		} else if (stored_entry->flags == GIT_CACHE_STORE_RAW &&
 			   entry->flags == GIT_CACHE_STORE_PARSED) {
-			if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+			if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
 				git_cached_obj_decref(stored_entry);
 				git_cached_obj_incref(entry);
 			} else {

data/vendor/libgit2/src/{cache.h → libgit2/cache.h}

@@ -14,7 +14,7 @@
 #include "git2/odb.h"
 
 #include "thread.h"
-#include "oidmap.h"
+#include "hashmap_oid.h"
 
 enum {
 	GIT_CACHE_STORE_ANY = 0,
@@ -30,10 +30,12 @@ typedef struct {
 	git_atomic32 refcount;
 } git_cached_obj;
 
+GIT_HASHMAP_OID_STRUCT(git_cache_oidmap, git_cached_obj *);
+
 typedef struct {
-	git_oidmap *map;
-	git_rwlock  lock;
-	ssize_t     used_memory;
+	git_cache_oidmap map;
+	git_rwlock       lock;
+	ssize_t          used_memory;
 } git_cache;
 
 extern bool git_cache__enabled;
@@ -45,6 +47,7 @@ int git_cache_set_max_object_size(git_object_t type, size_t size);
 int git_cache_init(git_cache *cache);
 void git_cache_dispose(git_cache *cache);
 void git_cache_clear(git_cache *cache);
+size_t git_cache_size(git_cache *cache);
 
 void *git_cache_store_raw(git_cache *cache, git_odb_object *entry);
 void *git_cache_store_parsed(git_cache *cache, git_object *entry);
@@ -53,11 +56,6 @@ git_odb_object *git_cache_get_raw(git_cache *cache, const git_oid *oid);
 git_object *git_cache_get_parsed(git_cache *cache, const git_oid *oid);
 void *git_cache_get_any(git_cache *cache, const git_oid *oid);
 
-GIT_INLINE(size_t) git_cache_size(git_cache *cache)
-{
-	return (size_t)git_oidmap_size(cache->map);
-}
-
 GIT_INLINE(void) git_cached_obj_incref(void *_obj)
 {
 	git_cached_obj *obj = _obj;