rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/merge_driver.c

@@ -181,7 +181,7 @@ static int merge_driver_registry_insert(
 	git_merge_driver_entry *entry;
 
 	entry = git__calloc(1, sizeof(git_merge_driver_entry) + strlen(name) + 1);
-	GIT_ERROR_CHECK_ALLOC(entry);
+	GITERR_CHECK_ALLOC(entry);
 
 	strcpy(entry->name, name);
 	entry->driver = driver;
@@ -265,12 +265,12 @@ int git_merge_driver_register(const char *name, git_merge_driver *driver)
 	assert(name && driver);
 
 	if (git_rwlock_wrlock(&merge_driver_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
+		giterr_set(GITERR_OS, "failed to lock merge driver registry");
 		return -1;
 	}
 
 	if (!merge_driver_registry_find(NULL, name)) {
-		git_error_set(GIT_ERROR_MERGE, "attempt to reregister existing driver '%s'",
+		giterr_set(GITERR_MERGE, "attempt to reregister existing driver '%s'",
 			name);
 		error = GIT_EEXISTS;
 		goto done;
@@ -290,12 +290,12 @@ int git_merge_driver_unregister(const char *name)
 	int error = 0;
 
 	if (git_rwlock_wrlock(&merge_driver_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
+		giterr_set(GITERR_OS, "failed to lock merge driver registry");
 		return -1;
 	}
 
 	if ((entry = merge_driver_registry_lookup(&pos, name)) == NULL) {
-		git_error_set(GIT_ERROR_MERGE, "cannot find merge driver '%s' to unregister",
+		giterr_set(GITERR_MERGE, "cannot find merge driver '%s' to unregister",
 			name);
 		error = GIT_ENOTFOUND;
 		goto done;
@@ -332,7 +332,7 @@ git_merge_driver *git_merge_driver_lookup(const char *name)
 		return &git_merge_driver__binary;
 
 	if (git_rwlock_rdlock(&merge_driver_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
+		giterr_set(GITERR_OS, "failed to lock merge driver registry");
 		return NULL;
 	}
 
@@ -341,7 +341,7 @@ git_merge_driver *git_merge_driver_lookup(const char *name)
 	git_rwlock_rdunlock(&merge_driver_registry.lock);
 
 	if (entry == NULL) {
-		git_error_set(GIT_ERROR_MERGE, "cannot use an unregistered filter");
+		giterr_set(GITERR_MERGE, "cannot use an unregistered filter");
 		return NULL;
 	}
 
@@ -371,17 +371,17 @@ static int merge_driver_name_for_path(
 		return error;
 
 	/* set: use the built-in 3-way merge driver ("text") */
-	if (GIT_ATTR_IS_TRUE(value))
+	if (GIT_ATTR_TRUE(value))
 		*out = merge_driver_name__text;
 
 	/* unset: do not merge ("binary") */
-	else if (GIT_ATTR_IS_FALSE(value))
+	else if (GIT_ATTR_FALSE(value))
 		*out = merge_driver_name__binary;
 
-	else if (GIT_ATTR_IS_UNSPECIFIED(value) && default_driver)
+	else if (GIT_ATTR_UNSPECIFIED(value) && default_driver)
 		*out = default_driver;
 
-	else if (GIT_ATTR_IS_UNSPECIFIED(value))
+	else if (GIT_ATTR_UNSPECIFIED(value))
 		*out = merge_driver_name__text;
 
 	else

data/vendor/libgit2/src/merge_file.c

@@ -9,7 +9,7 @@
 
 #include "repository.h"
 #include "posix.h"
-#include "futils.h"
+#include "fileops.h"
 #include "index.h"
 #include "diff_xdiff.h"
 #include "merge.h"
@@ -130,7 +130,7 @@ static int merge_file__xdiff(
 
 	if ((xdl_result = xdl_merge(&ancestor_mmfile, &our_mmfile,
 		&their_mmfile, &xmparam, &mmbuffer)) < 0) {
-		git_error_set(GIT_ERROR_MERGE, "failed to merge files");
+		giterr_set(GITERR_MERGE, "failed to merge files");
 		error = -1;
 		goto done;
 	}

data/vendor/libgit2/src/mwindow.c

@@ -8,7 +8,7 @@
 #include "mwindow.h"
 
 #include "vector.h"
-#include "futils.h"
+#include "fileops.h"
 #include "map.h"
 #include "global.h"
 #include "strmap.h"
@@ -44,28 +44,31 @@ int git_mwindow_global_init(void)
 	assert(!git__pack_cache);
 
 	git__on_shutdown(git_mwindow_files_free);
-	return git_strmap_new(&git__pack_cache);
+	return git_strmap_alloc(&git__pack_cache);
 }
 
 int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 {
-	struct git_pack_file *pack;
-	char *packname;
 	int error;
+	char *packname;
+	git_strmap_iter pos;
+	struct git_pack_file *pack;
 
 	if ((error = git_packfile__name(&packname, path)) < 0)
 		return error;
 
 	if (git_mutex_lock(&git__mwindow_mutex) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
+		giterr_set(GITERR_OS, "failed to lock mwindow mutex");
 		return -1;
 	}
 
-	pack = git_strmap_get(git__pack_cache, packname);
+	pos = git_strmap_lookup_index(git__pack_cache, packname);
 	git__free(packname);
 
-	if (pack != NULL) {
+	if (git_strmap_valid_index(git__pack_cache, pos)) {
+		pack = git_strmap_value_at(git__pack_cache, pos);
 		git_atomic_inc(&pack->refcount);
+
 		git_mutex_unlock(&git__mwindow_mutex);
 		*out = pack;
 		return 0;
@@ -79,7 +82,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 
 	git_atomic_inc(&pack->refcount);
 
-	error = git_strmap_set(git__pack_cache, pack->pack_name, pack);
+	git_strmap_insert(git__pack_cache, pack->pack_name, pack, &error);
 	git_mutex_unlock(&git__mwindow_mutex);
 
 	if (error < 0) {
@@ -94,6 +97,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 void git_mwindow_put_pack(struct git_pack_file *pack)
 {
 	int count;
+	git_strmap_iter pos;
 
 	if (git_mutex_lock(&git__mwindow_mutex) < 0)
 		return;
@@ -101,12 +105,13 @@ void git_mwindow_put_pack(struct git_pack_file *pack)
 	/* put before get would be a corrupted state */
 	assert(git__pack_cache);
 
+	pos = git_strmap_lookup_index(git__pack_cache, pack->pack_name);
 	/* if we cannot find it, the state is corrupted */
-	assert(git_strmap_exists(git__pack_cache, pack->pack_name));
+	assert(git_strmap_valid_index(git__pack_cache, pos));
 
 	count = git_atomic_dec(&pack->refcount);
 	if (count == 0) {
-		git_strmap_delete(git__pack_cache, pack->pack_name);
+		git_strmap_delete_at(git__pack_cache, pos);
 		git_packfile_free(pack);
 	}
 
@@ -117,7 +122,7 @@ void git_mwindow_put_pack(struct git_pack_file *pack)
 void git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
 		return;
 	}
 
@@ -167,11 +172,11 @@ void git_mwindow_free_all_locked(git_mwindow_file *mwf)
 /*
  * Check if a window 'win' contains the address 'offset'
  */
-int git_mwindow_contains(git_mwindow *win, off64_t offset)
+int git_mwindow_contains(git_mwindow *win, git_off_t offset)
 {
-	off64_t win_off = win->offset;
+	git_off_t win_off = win->offset;
 	return win_off <= offset
-		&& offset <= (off64_t)(win_off + win->window_map.len);
+		&& offset <= (git_off_t)(win_off + win->window_map.len);
 }
 
 /*
@@ -224,7 +229,7 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf)
 	}
 
 	if (!lru_w) {
-		git_error_set(GIT_ERROR_OS, "failed to close memory window; couldn't find LRU");
+		giterr_set(GITERR_OS, "failed to close memory window; couldn't find LRU");
 		return -1;
 	}
 
@@ -246,12 +251,12 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf)
 static git_mwindow *new_window(
 	git_mwindow_file *mwf,
 	git_file fd,
-	off64_t size,
-	off64_t offset)
+	git_off_t size,
+	git_off_t offset)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
 	size_t walign = git_mwindow__window_size / 2;
-	off64_t len;
+	git_off_t len;
 	git_mwindow *w;
 
 	w = git__malloc(sizeof(*w));
@@ -263,8 +268,8 @@ static git_mwindow *new_window(
 	w->offset = (offset / walign) * walign;
 
 	len = size - w->offset;
-	if (len > (off64_t)git_mwindow__window_size)
-		len = (off64_t)git_mwindow__window_size;
+	if (len > (git_off_t)git_mwindow__window_size)
+		len = (git_off_t)git_mwindow__window_size;
 
 	ctl->mapped += (size_t)len;
 
@@ -311,7 +316,7 @@ static git_mwindow *new_window(
 unsigned char *git_mwindow_open(
 	git_mwindow_file *mwf,
 	git_mwindow **cursor,
-	off64_t offset,
+	git_off_t offset,
 	size_t extra,
 	unsigned int *left)
 {
@@ -319,7 +324,7 @@ unsigned char *git_mwindow_open(
 	git_mwindow *w = *cursor;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
 		return NULL;
 	}
 
@@ -371,7 +376,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	int ret;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
@@ -411,7 +416,7 @@ void git_mwindow_close(git_mwindow **window)
 	git_mwindow *w = *window;
 	if (w) {
 		if (git_mutex_lock(&git__mwindow_mutex)) {
-			git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
+			giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
 			return;
 		}
 

data/vendor/libgit2/src/mwindow.h

@@ -16,7 +16,7 @@
 typedef struct git_mwindow {
 	struct git_mwindow *next;
 	git_map window_map;
-	off64_t offset;
+	git_off_t offset;
 	size_t last_used;
 	size_t inuse_cnt;
 } git_mwindow;
@@ -24,7 +24,7 @@ typedef struct git_mwindow {
 typedef struct git_mwindow_file {
 	git_mwindow *windows;
 	int fd;
-	off64_t size;
+	git_off_t size;
 } git_mwindow_file;
 
 typedef struct git_mwindow_ctl {
@@ -37,10 +37,10 @@ typedef struct git_mwindow_ctl {
 	git_vector windowfiles;
 } git_mwindow_ctl;
 
-int git_mwindow_contains(git_mwindow *win, off64_t offset);
+int git_mwindow_contains(git_mwindow *win, git_off_t offset);
 void git_mwindow_free_all(git_mwindow_file *mwf); /* locks */
 void git_mwindow_free_all_locked(git_mwindow_file *mwf); /* run under lock */
-unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, off64_t offset, size_t extra, unsigned int *left);
+unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, git_off_t offset, size_t extra, unsigned int *left);
 int git_mwindow_file_register(git_mwindow_file *mwf);
 void git_mwindow_file_deregister(git_mwindow_file *mwf);
 void git_mwindow_close(git_mwindow **w_cursor);

data/vendor/libgit2/src/netops.c

@@ -37,17 +37,14 @@ void gitno_buffer_setup_callback(
 static int recv_stream(gitno_buffer *buf)
 {
 	git_stream *io = (git_stream *) buf->cb_data;
-	size_t readlen = buf->len - buf->offset;
-	ssize_t ret;
+	int ret;
 
-	readlen = min(readlen, INT_MAX);
-
-	ret = git_stream_read(io, buf->data + buf->offset, (int)readlen);
+	ret = git_stream_read(io, buf->data + buf->offset, buf->len - buf->offset);
 	if (ret < 0)
 		return -1;
 
 	buf->offset += ret;
-	return (int)ret;
+	return ret;
 }
 
 void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len)
@@ -122,79 +119,183 @@ int gitno__match_host(const char *pattern, const char *host)
 	return -1;
 }
 
-int gitno_connection_data_handle_redirect(
-		git_net_url *url,
-		const char *redirect_str,
+static const char *prefix_http = "http://";
+static const char *prefix_https = "https://";
+
+int gitno_connection_data_from_url(
+		gitno_connection_data *data,
+		const char *url,
 		const char *service_suffix)
 {
-	git_net_url tmp = GIT_NET_URL_INIT;
-	int error = 0;
+	int error = -1;
+	const char *default_port = NULL, *path_search_start = NULL;
+	char *original_host = NULL;
 
-	assert(url && redirect_str);
+	/* service_suffix is optional */
+	assert(data && url);
 
-	if (redirect_str[0] == '/') {
-		git__free(url->path);
+	/* Save these for comparison later */
+	original_host = data->host;
+	data->host = NULL;
+	gitno_connection_data_free_ptrs(data);
 
-		if ((url->path = git__strdup(redirect_str)) == NULL) {
-			error = -1;
-			goto done;
+	if (!git__prefixcmp(url, prefix_http)) {
+		path_search_start = url + strlen(prefix_http);
+		default_port = "80";
+
+		if (data->use_ssl) {
+			giterr_set(GITERR_NET, "redirect from HTTPS to HTTP is not allowed");
+			goto cleanup;
 		}
-	} else {
-		git_net_url *original = url;
+	} else if (!git__prefixcmp(url, prefix_https)) {
+		path_search_start = url + strlen(prefix_https);
+		default_port = "443";
+		data->use_ssl = true;
+	} else if (url[0] == '/')
+		default_port = data->use_ssl ? "443" : "80";
+
+	if (!default_port) {
+		giterr_set(GITERR_NET, "unrecognized URL prefix");
+		goto cleanup;
+	}
 
-		if ((error = git_net_url_parse(&tmp, redirect_str)) < 0)
-			goto done;
+	error = gitno_extract_url_parts(
+		&data->host, &data->port, &data->path, &data->user, &data->pass,
+		url, default_port);
 
-		/* Validate that this is a legal redirection */
+	if (url[0] == '/') {
+		/* Relative redirect; reuse original host name and port */
+		path_search_start = url;
+		git__free(data->host);
+		data->host = original_host;
+		original_host = NULL;
+	}
 
-		if (original->scheme &&
-		    strcmp(original->scheme, tmp.scheme) != 0 &&
-			strcmp(tmp.scheme, "https") != 0) {
-			git_error_set(GIT_ERROR_NET, "cannot redirect from '%s' to '%s'",
-				original->scheme, tmp.scheme);
+	if (!error) {
+		const char *path = strchr(path_search_start, '/');
+		size_t pathlen = strlen(path);
+		size_t suffixlen = service_suffix ? strlen(service_suffix) : 0;
+
+		if (suffixlen &&
+		    !memcmp(path + pathlen - suffixlen, service_suffix, suffixlen)) {
+			git__free(data->path);
+			data->path = git__strndup(path, pathlen - suffixlen);
+		} else {
+			git__free(data->path);
+			data->path = git__strdup(path);
+		}
 
+		/* Check for errors in the resulting data */
+		if (original_host && url[0] != '/' && strcmp(original_host, data->host)) {
+			giterr_set(GITERR_NET, "cross host redirect not allowed");
 			error = -1;
-			goto done;
 		}
+	}
 
-		if (original->host &&
-		    git__strcasecmp(original->host, tmp.host) != 0) {
-			git_error_set(GIT_ERROR_NET, "cannot redirect from '%s' to '%s'",
-				original->host, tmp.host);
+cleanup:
+	if (original_host) git__free(original_host);
+	return error;
+}
 
-			error = -1;
-			goto done;
-		}
+void gitno_connection_data_free_ptrs(gitno_connection_data *d)
+{
+	git__free(d->host); d->host = NULL;
+	git__free(d->port); d->port = NULL;
+	git__free(d->path); d->path = NULL;
+	git__free(d->user); d->user = NULL;
+	git__free(d->pass); d->pass = NULL;
+}
 
-		git_net_url_swap(url, &tmp);
+int gitno_extract_url_parts(
+	char **host_out,
+	char **port_out,
+	char **path_out,
+	char **username_out,
+	char **password_out,
+	const char *url,
+	const char *default_port)
+{
+	struct http_parser_url u = {0};
+	bool has_host, has_port, has_path, has_userinfo;
+	git_buf host = GIT_BUF_INIT,
+		port = GIT_BUF_INIT,
+		path = GIT_BUF_INIT,
+		username = GIT_BUF_INIT,
+		password = GIT_BUF_INIT;
+	int error = 0;
+
+	if (http_parser_parse_url(url, strlen(url), false, &u)) {
+		giterr_set(GITERR_NET, "malformed URL '%s'", url);
+		error = GIT_EINVALIDSPEC;
+		goto done;
 	}
 
-	/* Remove the service suffix if it was given to us */
-	if (service_suffix) {
-		const char *service_query = strchr(service_suffix, '?');
-		size_t suffix_len = service_query ?
-			(size_t)(service_query - service_suffix) : strlen(service_suffix);
-		size_t path_len = strlen(url->path);
+	has_host = !!(u.field_set & (1 << UF_HOST));
+	has_port = !!(u.field_set & (1 << UF_PORT));
+	has_path = !!(u.field_set & (1 << UF_PATH));
+	has_userinfo = !!(u.field_set & (1 << UF_USERINFO));
 
-		if (suffix_len && path_len >= suffix_len) {
-			size_t suffix_offset = path_len - suffix_len;
+	if (has_host) {
+		const char *url_host = url + u.field_data[UF_HOST].off;
+		size_t url_host_len = u.field_data[UF_HOST].len;
+		git_buf_decode_percent(&host, url_host, url_host_len);
+	}
 
-			if (git__strncmp(url->path + suffix_offset, service_suffix, suffix_len) == 0 &&
-			    (!service_query || git__strcmp(url->query, service_query + 1) == 0)) {
-				/* Ensure we leave a minimum of '/' as the path */
-				if (suffix_offset == 0)
-					suffix_offset++;
+	if (has_port) {
+		const char *url_port = url + u.field_data[UF_PORT].off;
+		size_t url_port_len = u.field_data[UF_PORT].len;
+		git_buf_put(&port, url_port, url_port_len);
+	} else {
+		git_buf_puts(&port, default_port);
+	}
 
-				url->path[suffix_offset] = '\0';
+	if (has_path && path_out) {
+		const char *url_path = url + u.field_data[UF_PATH].off;
+		size_t url_path_len = u.field_data[UF_PATH].len;
+		git_buf_decode_percent(&path, url_path, url_path_len);
+	} else if (path_out) {
+		giterr_set(GITERR_NET, "invalid url, missing path");
+		error = GIT_EINVALIDSPEC;
+		goto done;
+	}
 
-				git__free(url->query);
-				url->query = NULL;
-			}
+	if (has_userinfo) {
+		const char *url_userinfo = url + u.field_data[UF_USERINFO].off;
+		size_t url_userinfo_len = u.field_data[UF_USERINFO].len;
+		const char *colon = memchr(url_userinfo, ':', url_userinfo_len);
+
+		if (colon) {
+			const char *url_username = url_userinfo;
+			size_t url_username_len = colon - url_userinfo;
+			const char *url_password = colon + 1;
+			size_t url_password_len = url_userinfo_len - (url_username_len + 1);
+
+			git_buf_decode_percent(&username, url_username, url_username_len);
+			git_buf_decode_percent(&password, url_password, url_password_len);
+		} else {
+			git_buf_decode_percent(&username, url_userinfo, url_userinfo_len);
 		}
 	}
 
+	if (git_buf_oom(&host) ||
+		git_buf_oom(&port) ||
+		git_buf_oom(&path) ||
+		git_buf_oom(&username) ||
+		git_buf_oom(&password))
+		return -1;
+
+	*host_out = git_buf_detach(&host);
+	*port_out = git_buf_detach(&port);
+	if (path_out)
+		*path_out = git_buf_detach(&path);
+	*username_out = git_buf_detach(&username);
+	*password_out = git_buf_detach(&password);
+
 done:
-	git_net_url_dispose(&tmp);
+	git_buf_free(&host);
+	git_buf_free(&port);
+	git_buf_free(&path);
+	git_buf_free(&username);
+	git_buf_free(&password);
 	return error;
 }
-