rugged 1.7.2 → 1.9.6

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

@@ -0,0 +1,223 @@
+/*
+ * 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 use_shell   : 1,
+	             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
@@ -80,10 +76,10 @@ GIT_INLINE(int) getseed(uint64_t *seed)
 GIT_INLINE(int) getseed(uint64_t *seed)
 {
 	struct timeval tv;
-	double loadavg[3];
 	int fd;
 
 # if defined(GIT_RAND_GETLOADAVG)
+	double loadavg[3];
 	bits convert;
 # endif
 
@@ -129,8 +125,6 @@ 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
 
 	*seed ^= git_time_monotonic();

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

@@ -7,7 +7,7 @@
 
 #include "regexp.h"
 
-#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
+#if defined(GIT_REGEX_PCRE)
 
 int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 {
@@ -73,7 +73,7 @@ out:
 	return 0;
 }
 
-#elif defined(GIT_REGEX_PCRE2)
+#elif defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE2)
 
 int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 {
@@ -84,8 +84,9 @@ int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 	if (flags & GIT_REGEXP_ICASE)
 		cflags |= PCRE2_CASELESS;
 
-	if ((*r = pcre2_compile((const unsigned char *) pattern, PCRE2_ZERO_TERMINATED,
-				cflags, &error, &erroff, NULL)) == NULL) {
+	if ((*r = pcre2_compile((const unsigned char *) pattern,
+			PCRE2_ZERO_TERMINATED,
+			cflags, &error, &erroff, NULL)) == NULL) {
 		pcre2_get_error_message(error, errmsg, sizeof(errmsg));
 		git_error_set_str(GIT_ERROR_REGEX, (char *) errmsg);
 		return GIT_EINVALIDSPEC;
@@ -110,37 +111,51 @@ int git_regexp_match(const git_regexp *r, const char *string)
 
 	error = pcre2_match(*r, (const unsigned char *) string, strlen(string), 0, 0, data, NULL);
 	pcre2_match_data_free(data);
+
 	if (error < 0)
 		return (error == PCRE2_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
 
 	return 0;
 }
 
-int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches)
+int git_regexp_search(
+	const git_regexp *r,
+	const char *string,
+	size_t given_nmatches,
+	git_regmatch *matches)
 {
 	pcre2_match_data *data = NULL;
 	PCRE2_SIZE *ovec;
+	size_t i, captures;
+	uint32_t nmatches;
 	int error;
-	size_t i;
+
+	GIT_ASSERT(given_nmatches <= UINT32_MAX);
+
+	nmatches = (uint32_t) given_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),
-			     0, 0, data, NULL)) < 0)
+	if ((error = pcre2_match(*r, (const unsigned char *) string,
+			strlen(string), 0, 0, data, NULL)) < 0)
 		goto out;
 
-	if (error == 0 || (unsigned int) error  > nmatches)
-		error = nmatches;
+	captures = (size_t) error;
+
+	if (!captures || captures > nmatches)
+		captures = nmatches;
+
 	ovec = pcre2_get_ovector_pointer(data);
 
-	for (i = 0; i < (unsigned int) error; i++) {
+	for (i = 0; i < captures; i++) {
 		matches[i].start = (ovec[i * 2] == PCRE2_UNSET) ? -1 : (ssize_t) ovec[i * 2];
 		matches[i].end = (ovec[i * 2 + 1] == PCRE2_UNSET) ? -1 :  (ssize_t) ovec[i * 2 + 1];
 	}
-	for (i = (unsigned int) error; i < nmatches; i++)
+
+	for (i = captures; i < nmatches; i++)
 		matches[i].start = matches[i].end = -1;
 
 out:

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

@@ -10,8 +10,13 @@
 
 #include "git2_util.h"
 
-#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
-# include "pcre.h"
+#if defined(GIT_REGEX_BUILTIN)
+# define PCRE2_CODE_UNIT_WIDTH 8
+# include "pcre2.h"
+typedef pcre2_code *git_regexp;
+# define GIT_REGEX_INIT NULL
+#elif defined(GIT_REGEX_PCRE)
+# include <pcre.h>
 typedef pcre *git_regexp;
 # define GIT_REGEX_INIT NULL
 #elif defined(GIT_REGEX_PCRE2)

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

@@ -16,7 +16,7 @@ static git_atomic32 init_count;
 static int init_common(git_runtime_init_fn init_fns[], size_t cnt)
 {
 	size_t i;
-	int ret;
+	int ret = 0;
 
 	/* Initialize subsystems that have global state */
 	for (i = 0; i < cnt; i++) {
@@ -110,7 +110,7 @@ GIT_INLINE(int) init_unlock(void)
 
 int git_runtime_init(git_runtime_init_fn init_fns[], size_t cnt)
 {
-	int ret;
+	int ret = 0;
 
 	if (init_lock() < 0)
 		return -1;

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/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;
@@ -1065,10 +1065,13 @@ int git_str_puts_escaped(
 	git_str *buf,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with)
+	const char *esc_prefix,
+	const char *esc_suffix)
 {
 	const char *scan;
-	size_t total = 0, esc_len = strlen(esc_with), count, alloclen;
+	size_t total = 0, count, alloclen;
+	size_t esc_prefix_len = esc_prefix ? strlen(esc_prefix) : 0;
+	size_t esc_suffix_len = esc_suffix ? strlen(esc_suffix) : 0;
 
 	if (!string)
 		return 0;
@@ -1080,7 +1083,7 @@ int git_str_puts_escaped(
 		scan += count;
 		/* count run of escaped characters */
 		count = strspn(scan, esc_chars);
-		total += count * (esc_len + 1);
+		total += count * (esc_prefix_len + esc_suffix_len + 1);
 		scan += count;
 	}
 
@@ -1096,13 +1099,22 @@ int git_str_puts_escaped(
 		buf->size += count;
 
 		for (count = strspn(scan, esc_chars); count > 0; --count) {
-			/* copy escape sequence */
-			memmove(buf->ptr + buf->size, esc_with, esc_len);
-			buf->size += esc_len;
+			/* copy escape prefix sequence */
+			if (esc_prefix) {
+				memmove(buf->ptr + buf->size, esc_prefix, esc_prefix_len);
+				buf->size += esc_prefix_len;
+			}
+
 			/* copy character to be escaped */
 			buf->ptr[buf->size] = *scan;
 			buf->size++;
 			scan++;
+
+			/* copy escape suffix sequence */
+			if (esc_suffix) {
+				memmove(buf->ptr + buf->size, esc_suffix, esc_suffix_len);
+				buf->size += esc_suffix_len;
+			}
 		}
 	}
 

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

@@ -268,21 +268,23 @@ int git_str_splice(
  * @param str String buffer to append data to
  * @param string String to escape and append
  * @param esc_chars Characters to be escaped
- * @param esc_with String to insert in from of each found character
+ * @param esc_prefix String to insert as prefix of each found character
+ * @param esc_suffix String to insert as suffix of each found character
  * @return 0 on success, <0 on failure (probably allocation problem)
  */
 extern int git_str_puts_escaped(
 	git_str *str,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with);
+	const char *esc_prefix,
+	const char *esc_suffix);
 
 /**
  * Append string escaping characters that are regex special
  */
 GIT_INLINE(int) git_str_puts_escape_regex(git_str *str, const char *string)
 {
-	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\");
+	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\", NULL);
 }
 
 /**

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);
+}