rugged 0.21.0 → 0.21.2

data/vendor/libgit2/src/mwindow.c

@@ -11,10 +11,6 @@
 #include "fileops.h"
 #include "map.h"
 #include "global.h"
-#include "strmap.h"
-#include "pack.h"
-
-GIT__USE_STRMAP;
 
 #define DEFAULT_WINDOW_SIZE \
 	(sizeof(void*) >= 8 \
@@ -30,127 +26,20 @@ size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
 /* Whenever you want to read or modify this, grab git__mwindow_mutex */
 static git_mwindow_ctl mem_ctl;
 
-/* Global list of mwindow files, to open packs once across repos */
-git_strmap *git__pack_cache = NULL;
-
-/**
- * Run under mwindow lock
- */
-int git_mwindow_files_init(void)
-{
-	if (git__pack_cache)
-		return 0;
-
-	return git_strmap_alloc(&git__pack_cache);
-}
-
-void git_mwindow_files_free(void)
-{
-	git_strmap *tmp = git__pack_cache;
-
-	git__pack_cache = NULL;
-	git_strmap_free(tmp);
-}
-
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
-{
-	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) {
-		giterr_set(GITERR_OS, "failed to lock mwindow mutex");
-		return -1;
-	}
-
-	if (git_mwindow_files_init() < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
-		git__free(packname);
-		return -1;
-	}
-
-	pos = git_strmap_lookup_index(git__pack_cache, packname);
-	git__free(packname);
-
-	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;
-	}
-
-	/* If we didn't find it, we need to create it */
-	if ((error = git_packfile_alloc(&pack, path)) < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
-		return error;
-	}
-
-	git_atomic_inc(&pack->refcount);
-
-	git_strmap_insert(git__pack_cache, pack->pack_name, pack, error);
-	git_mutex_unlock(&git__mwindow_mutex);
-
-	if (error < 0) {
-		git_packfile_free(pack);
-		return -1;
-	}
-
-	*out = pack;
-	return 0;
-}
-
-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;
-
-	/* 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_valid_index(git__pack_cache, pos));
-
-	count = git_atomic_dec(&pack->refcount);
-	if (count == 0) {
-		git_strmap_delete_at(git__pack_cache, pos);
-		git_packfile_free(pack);
-	}
-
-	git_mutex_unlock(&git__mwindow_mutex);
-	return;
-}
-
-void git_mwindow_free_all(git_mwindow_file *mwf)
-{
-	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
-		return;
-	}
-
-	git_mwindow_free_all_locked(mwf);
-
-	git_mutex_unlock(&git__mwindow_mutex);
-}
-
 /*
  * Free all the windows in a sequence, typically because we're done
  * with the file
  */
-void git_mwindow_free_all_locked(git_mwindow_file *mwf)
+void git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
 	size_t i;
 
+	if (git_mutex_lock(&git__mwindow_mutex)) {
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		return;
+	}
+
 	/*
 	 * Remove these windows from the global list
 	 */
@@ -178,6 +67,8 @@ void git_mwindow_free_all_locked(git_mwindow_file *mwf)
 		mwf->windows = w->next;
 		git__free(w);
 	}
+
+	git_mutex_unlock(&git__mwindow_mutex);
 }
 
 /*

data/vendor/libgit2/src/mwindow.h

@@ -36,18 +36,10 @@ typedef struct git_mwindow_ctl {
 } git_mwindow_ctl;
 
 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 */
+void git_mwindow_free_all(git_mwindow_file *mwf);
 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);
 
-int git_mwindow_files_init(void);
-void git_mwindow_files_free(void);
-
-struct git_pack_file; /* just declaration to avoid cyclical includes */
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path);
-void git_mwindow_put_pack(struct git_pack_file *pack);
-
 #endif

data/vendor/libgit2/src/netops.c

@@ -460,7 +460,7 @@ int gitno_connect(gitno_socket *s_out, const char *host, const char *port, int f
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_family = AF_UNSPEC;
 
-	if ((ret = p_getaddrinfo(host, port, &hints, &info)) < 0) {
+	if ((ret = p_getaddrinfo(host, port, &hints, &info)) != 0) {
 		giterr_set(GITERR_NET,
 			"Failed to resolve address for %s: %s", host, p_gai_strerror(ret));
 		return -1;
@@ -717,6 +717,9 @@ int gitno_extract_url_parts(
 	if (u.field_set & (1 << UF_PATH)) {
 		*path = git__substrdup(_path, u.field_data[UF_PATH].len);
 		GITERR_CHECK_ALLOC(*path);
+	} else {
+		giterr_set(GITERR_NET, "invalid url, missing path");
+		return GIT_EINVALIDSPEC;
 	}
 
 	if (u.field_set & (1 << UF_USERINFO)) {

data/vendor/libgit2/src/odb_pack.c

@@ -210,7 +210,7 @@ static int packfile_load__cb(void *data, git_buf *path)
 			return 0;
 	}
 
-	error = git_mwindow_get_pack(&pack, path->ptr);
+	error = git_packfile_alloc(&pack, path->ptr);
 
 	/* ignore missing .pack file as git does */
 	if (error == GIT_ENOTFOUND) {
@@ -605,7 +605,7 @@ static void pack_backend__free(git_odb_backend *_backend)
 
 	for (i = 0; i < backend->packs.length; ++i) {
 		struct git_pack_file *p = git_vector_get(&backend->packs, i);
-		git_mwindow_put_pack(p);
+		git_packfile_free(p);
 	}
 
 	git_vector_free(&backend->packs);
@@ -647,7 +647,7 @@ int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx)
 	if (pack_backend__alloc(&backend, 1) < 0)
 		return -1;
 
-	if (git_mwindow_get_pack(&packfile, idx) < 0 ||
+	if (git_packfile_alloc(&packfile, idx) < 0 ||
 		git_vector_insert(&backend->packs, packfile) < 0)
 	{
 		pack_backend__free((git_odb_backend *)backend);
@@ -664,9 +664,6 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 	struct pack_backend *backend = NULL;
 	git_buf path = GIT_BUF_INIT;
 
-	if (git_mwindow_files_init() < 0)
-		return -1;
-
 	if (pack_backend__alloc(&backend, 8) < 0)
 		return -1;
 

data/vendor/libgit2/src/pack.c

@@ -620,7 +620,7 @@ int git_packfile_unpack(
 	struct pack_chain_elem *elem = NULL, *stack;
 	git_pack_cache_entry *cached = NULL;
 	struct pack_chain_elem small_stack[SMALL_STACK_SIZE];
-	size_t stack_size, elem_pos;
+	size_t stack_size = 0, elem_pos;
 	git_otype base_type;
 
 	/*
@@ -744,7 +744,7 @@ cleanup:
 		git__free(obj->data);
 
 	if (elem)
-		*obj_offset = elem->offset;
+		*obj_offset = curpos;
 
 	git_array_clear(chain);
 	return error;
@@ -968,10 +968,10 @@ void git_packfile_free(struct git_pack_file *p)
 
 	cache_free(&p->bases);
 
-	if (p->mwf.fd >= 0) {
-		git_mwindow_free_all_locked(&p->mwf);
+	git_mwindow_free_all(&p->mwf);
+
+	if (p->mwf.fd >= 0)
 		p_close(p->mwf.fd);
-	}
 
 	pack_index_free(p);
 
@@ -1063,23 +1063,6 @@ cleanup:
 	return -1;
 }
 
-int git_packfile__name(char **out, const char *path)
-{
-	size_t path_len;
-	git_buf buf = GIT_BUF_INIT;
-
-	path_len = strlen(path);
-
-	if (path_len < strlen(".idx"))
-		return git_odb__error_notfound("invalid packfile path", NULL);
-
-	if (git_buf_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0)
-		return -1;
-
-	*out = git_buf_detach(&buf);
-	return 0;
-}
-
 int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 {
 	struct stat st;

data/vendor/libgit2/src/pack.h

@@ -90,7 +90,6 @@ struct git_pack_file {
 	git_mwindow_file mwf;
 	git_map index_map;
 	git_mutex lock; /* protect updates to mwf and index_map */
-	git_atomic refcount;
 
 	uint32_t num_objects;
 	uint32_t num_bad_objects;
@@ -124,8 +123,6 @@ typedef struct git_packfile_stream {
 
 size_t git_packfile__object_header(unsigned char *hdr, size_t size, git_otype type);
 
-int git_packfile__name(char **out, const char *path);
-
 int git_packfile_unpack_header(
 		size_t *size_p,
 		git_otype *type_p,

data/vendor/libgit2/src/path.c

@@ -494,23 +494,33 @@ bool git_path_is_empty_dir(const char *path)
 		WIN32_FIND_DATAW findData;
 		HANDLE hFind = FindFirstFileW(filter_w, &findData);
 
+		/* FindFirstFile will fail if there are no children to the given
+		 * path, which can happen if the given path is a file (and obviously
+		 * has no children) or if the given path is an empty mount point.
+		 * (Most directories have at least directory entries '.' and '..',
+		 * but ridiculously another volume mounted in another drive letter's
+		 * path space do not, and thus have nothing to enumerate.)  If
+		 * FindFirstFile fails, check if this is a directory-like thing
+		 * (a mount point).
+		 */
+		if (hFind == INVALID_HANDLE_VALUE)
+			return git_path_isdir(path);
+
 		/* If the find handle was created successfully, then it's a directory */
-		if (hFind != INVALID_HANDLE_VALUE) {
-			empty = true;
-
-			do {
-				/* Allow the enumeration to return . and .. and still be considered
-				 * empty. In the special case of drive roots (i.e. C:\) where . and
-				 * .. do not occur, we can still consider the path to be an empty
-				 * directory if there's nothing there. */
-				if (!git_path_is_dot_or_dotdotW(findData.cFileName)) {
-					empty = false;
-					break;
-				}
-			} while (FindNextFileW(hFind, &findData));
-
-			FindClose(hFind);
-		}
+		empty = true;
+
+		do {
+			/* Allow the enumeration to return . and .. and still be considered
+			 * empty. In the special case of drive roots (i.e. C:\) where . and
+			 * .. do not occur, we can still consider the path to be an empty
+			 * directory if there's nothing there. */
+			if (!git_path_is_dot_or_dotdotW(findData.cFileName)) {
+				empty = false;
+				break;
+			}
+		} while (FindNextFileW(hFind, &findData));
+
+		FindClose(hFind);
 	}
 
 	return empty;

data/vendor/libgit2/src/pool.c

@@ -7,7 +7,7 @@ struct git_pool_page {
 	git_pool_page *next;
 	uint32_t size;
 	uint32_t avail;
-	char data[GIT_FLEX_ARRAY];
+	GIT_ALIGN(char data[GIT_FLEX_ARRAY], 8);
 };
 
 struct pool_freelist {
@@ -146,7 +146,7 @@ GIT_INLINE(void) pool_remove_page(
 void *git_pool_malloc(git_pool *pool, uint32_t items)
 {
 	git_pool_page *scan = pool->open, *prev;
-	uint32_t size = items * pool->item_size;
+	uint32_t size = ((items * pool->item_size) + 7) & ~7;
 	void *ptr = NULL;
 
 	pool->has_string_alloc = 0;

data/vendor/libgit2/src/refspec.c

@@ -181,39 +181,63 @@ int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
 static int refspec_transform(
 	git_buf *out, const char *from, const char *to, const char *name)
 {
-	size_t to_len   = to   ? strlen(to)   : 0;
-	size_t from_len = from ? strlen(from) : 0;
-	size_t name_len = name ? strlen(name) : 0;
+	const char *from_star, *to_star;
+	const char *name_slash, *from_slash;
+	size_t replacement_len, star_offset;
 
 	git_buf_sanitize(out);
+	git_buf_clear(out);
 
-	if (git_buf_set(out, to, to_len) < 0)
-		return -1;
+	/*
+	 * There are two parts to each side of a refspec, the bit
+	 * before the star and the bit after it. The star can be in
+	 * the middle of the pattern, so we need to look at each bit
+	 * individually.
+	 */
+	from_star = strchr(from, '*');
+	to_star = strchr(to, '*');
 
-	if (to_len > 0) {
-		/* No '*' at the end of 'to' means that refspec is mapped to one
-		 * specific branch, so no actual transformation is needed.
-		 */
-		if (out->ptr[to_len - 1] != '*')
-			return 0;
-		git_buf_shorten(out, 1); /* remove trailing '*' copied from 'to' */
-	}
+	assert(from_star && to_star);
+
+	/* star offset, both in 'from' and in 'name' */
+	star_offset = from_star - from;
+
+	/* the first half is copied over */
+	git_buf_put(out, to, to_star - to);
+
+	/* then we copy over the replacement, from the star's offset to the next slash in 'name' */
+	name_slash = strchr(name + star_offset, '/');
+	if (!name_slash)
+		name_slash = strrchr(name, '\0');
 
-	if (from_len > 0) /* ignore trailing '*' from 'from' */
-		from_len--;
-	if (from_len > name_len)
-		from_len = name_len;
+	/* if there is no slash after the star in 'from', we want to copy everything over */
+	from_slash = strchr(from + star_offset, '/');
+	if (!from_slash)
+		name_slash = strrchr(name, '\0');
 
-	return git_buf_put(out, name + from_len, name_len - from_len);
+	replacement_len = (name_slash - name) - star_offset;
+	git_buf_put(out, name + star_offset, replacement_len);
+
+	return git_buf_puts(out, to_star + 1);
 }
 
 int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *name)
 {
+        git_buf_sanitize(out);
+
+	if (!spec->pattern)
+		return git_buf_puts(out, spec->dst);
+
 	return refspec_transform(out, spec->src, spec->dst, name);
 }
 
 int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *name)
 {
+        git_buf_sanitize(out);
+
+	if (!spec->pattern)
+		return git_buf_puts(out, spec->src);
+
 	return refspec_transform(out, spec->dst, spec->src, name);
 }
 

data/vendor/libgit2/src/remote.c

@@ -691,6 +691,11 @@ int git_remote_ls(const git_remote_head ***out, size_t *size, git_remote *remote
 {
 	assert(remote);
 
+	if (!remote->transport) {
+		giterr_set(GITERR_NET, "No transport bound to this remote");
+		return -1;
+	}
+
 	return remote->transport->ls(out, size, remote->transport);
 }
 
@@ -1052,16 +1057,20 @@ static int update_tips_for_spec(
 		if (autotag && !git_odb_exists(odb, &head->oid))
 			continue;
 
-		if (git_vector_insert(&update_heads, head) < 0)
+		if (!autotag && git_vector_insert(&update_heads, head) < 0)
 			goto on_error;
 
 		error = git_reference_name_to_id(&old, remote->repo, refname.ptr);
 		if (error < 0 && error != GIT_ENOTFOUND)
 			goto on_error;
 
-		if (error == GIT_ENOTFOUND)
+		if (error == GIT_ENOTFOUND) {
 			memset(&old, 0, GIT_OID_RAWSZ);
 
+			if (autotag && git_vector_insert(&update_heads, head) < 0)
+				goto on_error;
+		}
+
 		if (!git_oid__cmp(&old, &head->oid))
 			continue;
 
@@ -1932,6 +1941,8 @@ int git_remote_default_branch(git_buf *out, git_remote *remote)
 	size_t heads_len, i;
 	int error;
 
+	assert(out);
+
 	if ((error = git_remote_ls(&heads, &heads_len, remote)) < 0)
 		return error;
 

data/vendor/libgit2/src/repository.c

@@ -1551,8 +1551,10 @@ int git_repository_head_unborn(git_repository *repo)
 	error = git_repository_head(&ref, repo);
 	git_reference_free(ref);
 
-	if (error == GIT_EUNBORNBRANCH)
+	if (error == GIT_EUNBORNBRANCH) {
+		giterr_clear();
 		return 1;
+	}
 
 	if (error < 0)
 		return -1;

data/vendor/libgit2/src/revwalk.c

@@ -48,9 +48,6 @@ static int mark_uninteresting(git_revwalk *walk, git_commit_list_node *commit)
 
 	assert(commit);
 
-	git_array_init_to_size(pending, 2);
-	GITERR_CHECK_ARRAY(pending);
-
 	do {
 		commit->uninteresting = 1;
 

data/vendor/libgit2/src/stash.c

@@ -232,7 +232,8 @@ static int build_untracked_tree(
 	}
 
 	if (flags & GIT_STASH_INCLUDE_IGNORED) {
-		opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
+		opts.flags |= GIT_DIFF_INCLUDE_IGNORED |
+			GIT_DIFF_RECURSE_IGNORED_DIRS;
 		data.include_ignored = true;
 	}
 
@@ -447,10 +448,11 @@ static int ensure_there_are_changes_to_stash(
 
 	if (include_untracked_files)
 		opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED |
-		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+			GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
 
 	if (include_ignored_files)
-		opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED;
+		opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED |
+			GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
 
 	error = git_status_foreach_ext(repo, &opts, is_dirty_cb, NULL);
 

data/vendor/libgit2/src/tag.c

@@ -406,8 +406,9 @@ int git_tag_delete(git_repository *repo, const char *tag_name)
 	if (error < 0)
 		return error;
 
-	if ((error = git_reference_delete(tag_ref)) == 0)
-		git_reference_free(tag_ref);
+	error = git_reference_delete(tag_ref);
+
+	git_reference_free(tag_ref);
 
 	return error;
 }

data/vendor/libgit2/src/transports/http.c

@@ -537,7 +537,23 @@ replay:
 	}
 
 	while (!*bytes_read && !t->parse_finished) {
-		t->parse_buffer.offset = 0;
+		size_t data_offset;
+
+		/*
+		 * Make the parse_buffer think it's as full of data as
+		 * the buffer, so it won't try to recv more data than
+		 * we can put into it.
+		 *
+		 * data_offset is the actual data offset from which we
+		 * should tell the parser to start reading.
+		 */
+		if (buf_size >= t->parse_buffer.len) {
+			t->parse_buffer.offset = 0;
+		} else {
+			t->parse_buffer.offset = t->parse_buffer.len - buf_size;
+		}
+
+		data_offset = t->parse_buffer.offset;
 
 		if (gitno_recv(&t->parse_buffer) < 0)
 			return -1;
@@ -558,8 +574,8 @@ replay:
 
 		bytes_parsed = http_parser_execute(&t->parser,
 			&t->settings,
-			t->parse_buffer.data,
-			t->parse_buffer.offset);
+			t->parse_buffer.data + data_offset,
+			t->parse_buffer.offset - data_offset);
 
 		t->parser.data = NULL;
 
@@ -577,7 +593,7 @@ replay:
 		if (t->parse_error < 0)
 			return -1;
 
-		if (bytes_parsed != t->parse_buffer.offset) {
+		if (bytes_parsed != t->parse_buffer.offset - data_offset) {
 			giterr_set(GITERR_NET,
 				"HTTP parser error: %s",
 				http_errno_description((enum http_errno)t->parser.http_errno));

data/vendor/libgit2/src/transports/ssh.c

@@ -5,6 +5,10 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#ifdef GIT_SSH
+#include <libssh2.h>
+#endif
+
 #include "git2.h"
 #include "buffer.h"
 #include "netops.h"
@@ -12,8 +16,6 @@
 
 #ifdef GIT_SSH
 
-#include <libssh2.h>
-
 #define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport)
 
 static const char prefix_ssh[] = "ssh://";
@@ -132,11 +134,22 @@ static int ssh_stream_write(
 	size_t len)
 {
 	ssh_stream *s = (ssh_stream *)stream;
+	size_t off = 0;
+	ssize_t ret = 0;
 
 	if (!s->sent_command && send_command(s) < 0)
 		return -1;
 
-	if (libssh2_channel_write(s->channel, buffer, len) < LIBSSH2_ERROR_NONE) {
+	do {
+		ret = libssh2_channel_write(s->channel, buffer + off, len - off);
+		if (ret < 0)
+			break;
+
+		off += ret;
+
+	} while (off < len);
+
+	if (ret < 0) {
 		ssh_error(s->session, "SSH could not write data");
 		return -1;
 	}
@@ -274,6 +287,10 @@ static int ssh_agent_auth(LIBSSH2_SESSION *session, git_cred_ssh_key *c) {
 	}
 
 shutdown:
+
+	if (rc != LIBSSH2_ERROR_NONE)
+		ssh_error(session, "error authenticating");
+
 	libssh2_agent_disconnect(agent);
 	libssh2_agent_free(agent);
 
@@ -287,6 +304,7 @@ static int _git_ssh_authenticate_session(
 	int rc;
 
 	do {
+		giterr_clear();
 		switch (cred->credtype) {
 		case GIT_CREDTYPE_USERPASS_PLAINTEXT: {
 			git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
@@ -340,7 +358,8 @@ static int _git_ssh_authenticate_session(
 	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
 
 	if (rc != LIBSSH2_ERROR_NONE) {
-		ssh_error(session, "Failed to authenticate SSH session");
+		if (!giterr_last())
+			ssh_error(session, "Failed to authenticate SSH session");
 		return -1;
 	}