rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/util/pool.h

@@ -83,6 +83,11 @@ typedef struct {
  */
 extern int git_pool_init(git_pool *pool, size_t item_size);
 
+GIT_INLINE(bool) git_pool_is_initialized(git_pool *pool)
+{
+	return (pool->item_size > 0);
+}
+
 /**
  * Free all items in pool
  */

data/vendor/libgit2/src/util/posix.c

@@ -301,3 +301,57 @@ int p_munmap(git_map *map)
 }
 
 #endif
+
+#if defined(GIT_IO_POLL) || defined(GIT_IO_WSAPOLL)
+
+/* Handled by posix.h; this test simplifies the final else */
+
+#elif defined(GIT_IO_SELECT)
+
+int p_poll(struct pollfd *fds, unsigned int nfds, int timeout_ms)
+{
+	fd_set read_fds, write_fds, except_fds;
+	struct timeval timeout = { 0, 0 };
+	unsigned int i;
+	int max_fd = -1, ret;
+
+	FD_ZERO(&read_fds);
+	FD_ZERO(&write_fds);
+	FD_ZERO(&except_fds);
+
+	for (i = 0; i < nfds; i++) {
+		if ((fds[i].events & POLLIN))
+			FD_SET(fds[i].fd, &read_fds);
+
+		if ((fds[i].events & POLLOUT))
+			FD_SET(fds[i].fd, &write_fds);
+
+		if ((fds[i].events & POLLPRI))
+			FD_SET(fds[i].fd, &except_fds);
+
+		max_fd = MAX(max_fd, fds[i].fd);
+	}
+
+	if (timeout_ms > 0) {
+		timeout.tv_sec = timeout_ms / 1000;
+		timeout.tv_usec = (timeout_ms % 1000) * 1000;
+	}
+
+	if ((ret = select(max_fd + 1, &read_fds, &write_fds, &except_fds,
+	                  timeout_ms < 0 ? NULL : &timeout)) < 0)
+		goto done;
+
+	for (i = 0; i < nfds; i++) {
+		fds[i].revents = 0 |
+			FD_ISSET(fds[i].fd, &read_fds) ? POLLIN : 0 |
+			FD_ISSET(fds[i].fd, &write_fds) ? POLLOUT : 0 |
+			FD_ISSET(fds[i].fd, &except_fds) ? POLLPRI : 0;
+	}
+
+done:
+	return ret;
+}
+
+#else
+# error no poll compatible implementation
+#endif

data/vendor/libgit2/src/util/posix.h

@@ -195,4 +195,26 @@ extern const char *p_gai_strerror(int ret);
 #	define p_gai_strerror(c) gai_strerror(c)
 #endif /* NO_ADDRINFO */
 
+#ifdef GIT_IO_POLL
+# include <poll.h>
+# define p_poll poll
+#elif GIT_IO_WSAPOLL
+# include <winsock2.h>
+# define p_poll WSAPoll
+#else
+# define POLLIN  0x01
+# define POLLPRI 0x02
+# define POLLOUT 0x04
+# define POLLERR 0x08
+# define POLLHUP 0x10
+
+struct pollfd {
+	int fd;
+	short events;
+	short revents;
+};
+
+extern int p_poll(struct pollfd *fds, unsigned int nfds, int timeout);
+#endif
+
 #endif

data/vendor/libgit2/src/util/pqueue.h

@@ -33,7 +33,7 @@ extern int git_pqueue_init(
 	size_t init_size,
 	git_vector_cmp cmp);
 
-#define git_pqueue_free  git_vector_free
+#define git_pqueue_free  git_vector_dispose
 #define git_pqueue_clear git_vector_clear
 #define git_pqueue_size  git_vector_length
 #define git_pqueue_get   git_vector_get

data/vendor/libgit2/src/util/process.h

@@ -0,0 +1,222 @@
+/*
+ * 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_process_h__
+#define INCLUDE_process_h__
+
+typedef struct git_process git_process;
+
+typedef struct {
+	unsigned int capture_in  : 1,
+	             capture_out : 1,
+	             capture_err : 1,
+	             exclude_env : 1;
+
+	char *cwd;
+} git_process_options;
+
+typedef enum {
+	GIT_PROCESS_STATUS_NONE,
+	GIT_PROCESS_STATUS_NORMAL,
+	GIT_PROCESS_STATUS_ERROR
+} git_process_result_status;
+
+#define GIT_PROCESS_RESULT_INIT { GIT_PROCESS_STATUS_NONE }
+
+typedef struct {
+	git_process_result_status status;
+	int exitcode;
+	int signal;
+} git_process_result;
+
+#define GIT_PROCESS_OPTIONS_INIT { 0 }
+
+#ifdef GIT_WIN32
+# define p_pid_t DWORD
+#else
+# define p_pid_t pid_t
+#endif
+
+/**
+ * Create a new process.  The command to run should be specified as the
+ * element of the `arg` array, execv-style. This should be the full path
+ * to the command to run, the PATH is not obeyed.
+ *
+ * This function will add the given environment variables (in `env`)
+ * to the current environment.  Operations on environment variables
+ * are not thread safe, so you may not modify the environment during
+ * this call.  You can avoid this by setting `exclude_env` in the
+ * options and providing the entire environment yourself.
+ *
+ * @param out location to store the process
+ * @param args the command (with arguments) to run
+ * @param args_len the length of the args array
+ * @param env environment variables to add (or NULL)
+ * @param env_len the length of the env len
+ * @param opts the options for creating the process
+ * @return 0 or an error code
+ */
+extern int git_process_new(
+	git_process **out,
+	const char **args,
+	size_t args_len,
+	const char **env,
+	size_t env_len,
+	git_process_options *opts);
+
+/**
+ * Create a new process. The command to run should be specified as the
+ * `cmdline` option - which is the full text of the command line as it
+ * would be specified or run by a user. The command to run will be
+ * looked up in the PATH.
+ *
+ * On Unix, this will be executed by the system's shell (`/bin/sh`)
+ * and may contain _Bourne-style_ shell quoting rules. On Windows,
+ * this will be passed to `CreateProcess`, and similarly, may
+ * contain _Windows-style_ shell quoting rules.
+ *
+ * This function will add the given environment variables (in `env`)
+ * to the current environment.  Operations on environment variables
+ * are not thread safe, so you may not modify the environment during
+ * this call.  You can avoid this by setting `exclude_env` in the
+ * options and providing the entire environment yourself.
+ */
+extern int git_process_new_from_cmdline(
+	git_process **out,
+	const char *cmdline,
+	const char **env,
+	size_t env_len,
+	git_process_options *opts);
+
+#ifdef GIT_WIN32
+
+extern int git_process__appname(
+	git_str *out,
+	const char *cmdline);
+
+/* Windows path parsing is tricky; this helper function is for testing. */
+extern int git_process__cmdline(
+	git_str *out,
+	const char **in,
+	size_t in_len);
+
+#endif
+
+/*
+ * Whether the given string looks like a command line option (starts
+ * with a dash). This is useful for examining strings that will become
+ * cmdline arguments to ensure that they are not erroneously treated
+ * as an option. For example, arguments to `ssh`.
+ */
+GIT_INLINE(bool) git_process__is_cmdline_option(const char *str)
+{
+	return (str && str[0] == '-');
+}
+
+/**
+ * Start the process.
+ *
+ * @param process the process to start
+ * @return 0 or an error code
+ */
+extern int git_process_start(git_process *process);
+
+/**
+ * Returns the process id of the process.
+ *
+ * @param out pointer to a pid_t to store the process id
+ * @param process the process to query
+ * @return 0 or an error code
+ */
+extern int git_process_id(p_pid_t *out, git_process *process);
+
+/**
+ * Read from the process's stdout.  The process must have been created with
+ * `capture_out` set to true.
+ *
+ * @param process the process to read from
+ * @param buf the buf to read into
+ * @param count maximum number of bytes to read
+ * @return number of bytes read or an error code
+ */
+extern ssize_t git_process_read(git_process *process, void *buf, size_t count);
+
+/**
+ * Read from the process's stderr.  The process must have been created with
+ * `capture_err` set to true.
+ *
+ * @param process the process to read from
+ * @param buf the buf to read into
+ * @param count maximum number of bytes to read
+ * @return number of bytes read or an error code
+ */
+extern ssize_t git_process_read_err(git_process *process, void *buf, size_t count);
+
+/**
+ * Write to the process's stdin.  The process must have been created with
+ * `capture_in` set to true.
+ *
+ * @param process the process to write to
+ * @param buf the buf to write
+ * @param count maximum number of bytes to write
+ * @return number of bytes written or an error code
+ */
+extern ssize_t git_process_write(git_process *process, const void *buf, size_t count);
+
+/**
+ * Wait for the process to finish.
+ *
+ * @param result the result of the process or NULL
+ * @param process the process to wait on
+ */
+extern int git_process_wait(git_process_result *result, git_process *process);
+
+/**
+ * Close the input pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_in(git_process *process);
+
+/**
+ * Close the output pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_out(git_process *process);
+
+/**
+ * Close the error pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_err(git_process *process);
+
+/**
+ * Close all resources that are used by the process.  This does not
+ * wait for the process to complete.
+ *
+ * @parma process the process to close
+ */
+extern int git_process_close(git_process *process);
+
+/**
+ * Place a human-readable error message in the given git buffer.
+ *
+ * @param msg the buffer to store the message
+ * @param result the process result that produced an error
+ */
+extern int git_process_result_msg(git_str *msg, git_process_result *result);
+
+/**
+ * Free a process structure
+ *
+ * @param process the process to free
+ */
+extern void git_process_free(git_process *process);
+
+#endif

data/vendor/libgit2/src/util/rand.c

@@ -10,10 +10,6 @@ See <http://creativecommons.org/publicdomain/zero/1.0/>. */
 #include "rand.h"
 #include "runtime.h"
 
-#if defined(GIT_RAND_GETENTROPY)
-# include <sys/random.h>
-#endif
-
 #if defined(GIT_WIN32)
 # include <wincrypt.h>
 #endif
@@ -32,7 +28,6 @@ GIT_INLINE(int) getseed(uint64_t *seed)
 	HCRYPTPROV provider;
 	SYSTEMTIME systemtime;
 	FILETIME filetime, idletime, kerneltime, usertime;
-	bits convert;
 
 	if (CryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL,
 	                        CRYPT_VERIFYCONTEXT|CRYPT_SILENT)) {
@@ -67,7 +62,7 @@ GIT_INLINE(int) getseed(uint64_t *seed)
 	*seed ^= ((uint64_t)GetCurrentProcessId() << 32);
 	*seed ^= ((uint64_t)GetCurrentThreadId() << 48);
 
-	convert.f = git__timer(); *seed ^= (convert.d);
+	*seed ^= git_time_monotonic();
 
 	/* Mix in the addresses of some functions and variables */
 	*seed ^= (((uint64_t)((uintptr_t)seed) << 32));
@@ -81,9 +76,12 @@ GIT_INLINE(int) getseed(uint64_t *seed)
 GIT_INLINE(int) getseed(uint64_t *seed)
 {
 	struct timeval tv;
+	int fd;
+
+# if defined(GIT_RAND_GETLOADAVG)
 	double loadavg[3];
 	bits convert;
-	int fd;
+# endif
 
 # if defined(GIT_RAND_GETENTROPY)
 	GIT_UNUSED((fd = 0));
@@ -127,11 +125,9 @@ GIT_INLINE(int) getseed(uint64_t *seed)
 	convert.f = loadavg[0]; *seed ^= (convert.d >> 36);
 	convert.f = loadavg[1]; *seed ^= (convert.d);
 	convert.f = loadavg[2]; *seed ^= (convert.d >> 16);
-# else
-	GIT_UNUSED(loadavg[0]);
 # endif
 
-	convert.f = git__timer(); *seed ^= (convert.d);
+	*seed ^= git_time_monotonic();
 
 	/* Mix in the addresses of some variables */
 	*seed ^= ((uint64_t)((size_t)((void *)seed)) << 32);

data/vendor/libgit2/src/util/regexp.c

@@ -125,7 +125,7 @@ int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches,
 
 	if ((data = pcre2_match_data_create(nmatches, NULL)) == NULL) {
 		git_error_set_oom();
-		goto out;
+		return -1;
 	}
 
 	if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string),

data/vendor/libgit2/src/util/sortedcache.c

@@ -6,6 +6,7 @@
  */
 
 #include "sortedcache.h"
+#include "hashmap.h"
 
 int git_sortedcache_new(
 	git_sortedcache **out,
@@ -26,8 +27,7 @@ int git_sortedcache_new(
 	GIT_ERROR_CHECK_ALLOC(sc);
 
 	if (git_pool_init(&sc->pool, 1) < 0 ||
-	    git_vector_init(&sc->items, 4, item_cmp) < 0 ||
-	    git_strmap_new(&sc->map) < 0)
+	    git_vector_init(&sc->items, 4, item_cmp) < 0)
 		goto fail;
 
 	if (git_rwlock_init(&sc->lock)) {
@@ -46,8 +46,7 @@ int git_sortedcache_new(
 	return 0;
 
 fail:
-	git_strmap_free(sc->map);
-	git_vector_free(&sc->items);
+	git_vector_dispose(&sc->items);
 	git_pool_clear(&sc->pool);
 	git__free(sc);
 	return -1;
@@ -65,7 +64,7 @@ const char *git_sortedcache_path(git_sortedcache *sc)
 
 static void sortedcache_clear(git_sortedcache *sc)
 {
-	git_strmap_clear(sc->map);
+	git_hashmap_str_clear(&sc->map);
 
 	if (sc->free_item) {
 		size_t i;
@@ -88,8 +87,8 @@ static void sortedcache_free(git_sortedcache *sc)
 		return;
 
 	sortedcache_clear(sc);
-	git_vector_free(&sc->items);
-	git_strmap_free(sc->map);
+	git_vector_dispose(&sc->items);
+	git_hashmap_str_dispose(&sc->map);
 
 	git_sortedcache_wunlock(sc);
 
@@ -274,7 +273,7 @@ int git_sortedcache_upsert(void **out, git_sortedcache *sc, const char *key)
 	char *item_key;
 	void *item;
 
-	if ((item = git_strmap_get(sc->map, key)) != NULL)
+	if (git_hashmap_str_get(&item, &sc->map, key) == 0)
 		goto done;
 
 	keylen  = strlen(key);
@@ -294,11 +293,11 @@ int git_sortedcache_upsert(void **out, git_sortedcache *sc, const char *key)
 	item_key = ((char *)item) + sc->item_path_offset;
 	memcpy(item_key, key, keylen);
 
-	if ((error = git_strmap_set(sc->map, item_key, item)) < 0)
+	if ((error = git_hashmap_str_put(&sc->map, item_key, item)) < 0)
 		goto done;
 
 	if ((error = git_vector_insert(&sc->items, item)) < 0)
-		git_strmap_delete(sc->map, item_key);
+		git_hashmap_str_remove(&sc->map, item_key);
 
 done:
 	if (out)
@@ -307,9 +306,11 @@ done:
 }
 
 /* lookup item by key */
-void *git_sortedcache_lookup(const git_sortedcache *sc, const char *key)
+void *git_sortedcache_lookup(git_sortedcache *sc, const char *key)
 {
-	return git_strmap_get(sc->map, key);
+	void *value;
+
+	return git_hashmap_str_get(&value, &sc->map, key) == 0 ? value : NULL;
 }
 
 /* find out how many items are in the cache */
@@ -370,7 +371,7 @@ int git_sortedcache_remove(git_sortedcache *sc, size_t pos)
 
 	(void)git_vector_remove(&sc->items, pos);
 
-	git_strmap_delete(sc->map, item + sc->item_path_offset);
+	git_hashmap_str_remove(&sc->map, item + sc->item_path_offset);
 
 	if (sc->free_item)
 		sc->free_item(sc->free_item_payload, item);

data/vendor/libgit2/src/util/sortedcache.h

@@ -14,7 +14,7 @@
 #include "vector.h"
 #include "thread.h"
 #include "pool.h"
-#include "strmap.h"
+#include "hashmap_str.h"
 
 #include <stddef.h>
 
@@ -36,7 +36,7 @@ typedef struct {
 	void         *free_item_payload;
 	git_pool     pool;
 	git_vector   items;
-	git_strmap   *map;
+	git_hashmap_str map;
 	git_futils_filestamp stamp;
 	char         path[GIT_FLEX_ARRAY];
 } git_sortedcache;
@@ -163,7 +163,7 @@ GIT_WARN_UNUSED_RESULT int git_sortedcache_rlock(git_sortedcache *sc);
 void git_sortedcache_runlock(git_sortedcache *sc);
 
 /* Lookup item by key - returns NULL if not found */
-void *git_sortedcache_lookup(const git_sortedcache *sc, const char *key);
+void *git_sortedcache_lookup(git_sortedcache *sc, const char *key);
 
 /* Get how many items are in the cache
  *

data/vendor/libgit2/src/util/staticstr.h

@@ -0,0 +1,66 @@
+/*
+ * 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_stackstr_h__
+#define INCLUDE_stackstr_h__
+
+#include "git2_util.h"
+
+typedef struct {
+	/* Length of / number of bytes used by `data`. */
+	size_t len;
+
+	/* Size of the allocated `data` buffer. */
+	size_t size;
+
+	/* The actual string buffer data. */
+	char data[GIT_FLEX_ARRAY];
+} git_staticstr;
+
+#define git_staticstr_with_size(__size) \
+	struct { \
+		size_t len; \
+		size_t size; \
+		char data[__size]; \
+	}
+
+#define git_staticstr_init(__str, __size) \
+	do { \
+		(__str)->len = 0; \
+		(__str)->size = __size; \
+		(__str)->data[0] = '\0'; \
+	} while(0)
+
+#define git_staticstr_offset(__str) \
+	((__str)->data + (__str)->len)
+
+#define git_staticstr_remain(__str) \
+	((__str)->len > (__str)->size ? 0 : ((__str)->size - (__str)->len))
+
+#define git_staticstr_increase(__str, __len) \
+	do { ((__str)->len += __len); } while(0)
+
+#define git_staticstr_consume_bytes(__str, __len) \
+	do { git_staticstr_consume(__str, (__str)->data + __len); } while(0)
+
+#define git_staticstr_consume(__str, __end) \
+	do { \
+		if (__end > (__str)->data && \
+		    __end <= (__str)->data + (__str)->len) { \
+			size_t __consumed = __end - (__str)->data; \
+			memmove((__str)->data, __end, (__str)->len - __consumed); \
+			(__str)->len -= __consumed; \
+			(__str)->data[(__str)->len] = '\0'; \
+		} \
+	} while(0)
+
+#define git_staticstr_clear(__str) \
+	do { \
+		(__str)->len = 0; \
+		(__str)->data[0] = 0; \
+	} while(0)
+
+#endif

data/vendor/libgit2/src/util/str.c

@@ -485,8 +485,8 @@ int git_str_decode_percent(
 	for (str_pos = 0; str_pos < str_len; buf->size++, str_pos++) {
 		if (str[str_pos] == '%' &&
 			str_len > str_pos + 2 &&
-			isxdigit(str[str_pos + 1]) &&
-			isxdigit(str[str_pos + 2])) {
+			git__isxdigit(str[str_pos + 1]) &&
+			git__isxdigit(str[str_pos + 2])) {
 			buf->ptr[buf->size] = (HEX_DECODE(str[str_pos + 1]) << 4) +
 				HEX_DECODE(str[str_pos + 2]);
 			str_pos += 2;

data/vendor/libgit2/src/util/strlist.c

@@ -0,0 +1,108 @@
+/*
+ * 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 <stdio.h>
+
+#include "git2_util.h"
+#include "vector.h"
+#include "strlist.h"
+
+int git_strlist_copy(char ***out, const char **in, size_t len)
+{
+	char **dup;
+	size_t i;
+
+	dup = git__calloc(len, sizeof(char *));
+	GIT_ERROR_CHECK_ALLOC(dup);
+
+	for (i = 0; i < len; i++) {
+		dup[i] = git__strdup(in[i]);
+		GIT_ERROR_CHECK_ALLOC(dup[i]);
+	}
+
+	*out = dup;
+	return 0;
+}
+
+int git_strlist_copy_with_null(char ***out, const char **in, size_t len)
+{
+	char **dup;
+	size_t new_len, i;
+
+	GIT_ERROR_CHECK_ALLOC_ADD(&new_len, len, 1);
+
+	dup = git__calloc(new_len, sizeof(char *));
+	GIT_ERROR_CHECK_ALLOC(dup);
+
+	for (i = 0; i < len; i++) {
+		dup[i] = git__strdup(in[i]);
+		GIT_ERROR_CHECK_ALLOC(dup[i]);
+	}
+
+	*out = dup;
+	return 0;
+}
+
+bool git_strlist_contains_prefix(
+	const char **strings,
+	size_t len,
+	const char *str,
+	size_t n)
+{
+	size_t i;
+
+	for (i = 0; i < len; i++) {
+		if (strncmp(strings[i], str, n) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+bool git_strlist_contains_key(
+	const char **strings,
+	size_t len,
+	const char *key,
+	char delimiter)
+{
+	const char *c;
+
+	for (c = key; *c; c++) {
+		if (*c == delimiter)
+			break;
+	}
+
+	return *c ?
+	       git_strlist_contains_prefix(strings, len, key, (c - key)) :
+	       false;
+}
+
+void git_strlist_free(char **strings, size_t len)
+{
+	size_t i;
+
+	if (!strings)
+		return;
+
+	for (i = 0; i < len; i++)
+		git__free(strings[i]);
+
+	git__free(strings);
+}
+
+void git_strlist_free_with_null(char **strings)
+{
+	char **s;
+
+	if (!strings)
+		return;
+
+	for (s = strings; *s; s++)
+		git__free(*s);
+
+	git__free(strings);
+}