rugged 0.17.0.b6 → 0.17.0.b7

data/vendor/libgit2/src/submodule.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2012 the libgit2 contributors
+ *
+ * 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_submodule_h__
+#define INCLUDE_submodule_h__
+
+/* Notes:
+ *
+ * Submodule information can be in four places: the index, the config files
+ * (both .git/config and .gitmodules), the HEAD tree, and the working
+ * directory.
+ *
+ * In the index:
+ * - submodule is found by path
+ * - may be missing, present, or of the wrong type
+ * - will have an oid if present
+ *
+ * In the HEAD tree:
+ * - submodule is found by path
+ * - may be missing, present, or of the wrong type
+ * - will have an oid if present
+ *
+ * In the config files:
+ * - submodule is found by submodule "name" which is usually the path
+ * - may be missing or present
+ * - will have a name, path, url, and other properties
+ *
+ * In the working directory:
+ * - submodule is found by path
+ * - may be missing, an empty directory, a checked out directory,
+ *   or of the wrong type
+ * - if checked out, will have a HEAD oid
+ * - if checked out, will have git history that can be used to compare oids
+ * - if checked out, may have modified files and/or untracked files
+ */
+
+/**
+ * Description of submodule
+ *
+ * This record describes a submodule found in a repository.  There should be
+ * an entry for every submodule found in the HEAD and index, and for every
+ * submodule described in .gitmodules.  The fields are as follows:
+ *
+ * - `owner` is the git_repository containing this submodule
+ * - `name` is the name of the submodule from .gitmodules.
+ * - `path` is the path to the submodule from the repo root.  It is almost
+ *    always the same as `name`.
+ * - `url` is the url for the submodule.
+ * - `tree_oid` is the SHA1 for the submodule path in the repo HEAD.
+ * - `index_oid` is the SHA1 for the submodule recorded in the index.
+ * - `workdir_oid` is the SHA1 for the HEAD of the checked out submodule.
+ * - `update` is a git_submodule_update_t value - see gitmodules(5) update.
+ * - `ignore` is a git_submodule_ignore_t value - see gitmodules(5) ignore.
+ * - `fetch_recurse` is 0 or 1 - see gitmodules(5) fetchRecurseSubmodules.
+ * - `refcount` tracks how many hashmap entries there are for this submodule.
+ *   It only comes into play if the name and path of the submodule differ.
+ * - `flags` is for internal use, tracking where this submodule has been
+ *   found (head, index, config, workdir) and other misc info about it.
+ *
+ * If the submodule has been added to .gitmodules but not yet git added,
+ * then the `index_oid` will be valid and zero.  If the submodule has been
+ * deleted, but the delete has not been committed yet, then the `index_oid`
+ * will be set, but the `url` will be NULL.
+ */
+struct git_submodule {
+	git_repository *owner;
+	char *name;
+	char *path; /* important: may point to same string data as "name" */
+	char *url;
+	uint32_t flags;
+	git_oid head_oid;
+	git_oid index_oid;
+	git_oid wd_oid;
+	/* information from config */
+	git_submodule_update_t update;
+	git_submodule_update_t update_default;
+	git_submodule_ignore_t ignore;
+	git_submodule_ignore_t ignore_default;
+	int fetch_recurse;
+	/* internal information */
+	int refcount;
+};
+
+/* Additional flags on top of public GIT_SUBMODULE_STATUS values */
+enum {
+	GIT_SUBMODULE_STATUS__WD_SCANNED          = (1u << 20),
+	GIT_SUBMODULE_STATUS__HEAD_OID_VALID      = (1u << 21),
+	GIT_SUBMODULE_STATUS__INDEX_OID_VALID     = (1u << 22),
+	GIT_SUBMODULE_STATUS__WD_OID_VALID        = (1u << 23),
+	GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE  = (1u << 24),
+	GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE = (1u << 25),
+	GIT_SUBMODULE_STATUS__WD_NOT_SUBMODULE    = (1u << 26),
+	GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES = (1u << 27),
+};
+
+#define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
+	((S) & ~(0xFFFFFFFFu << 20))
+
+#endif

data/vendor/libgit2/src/tag.c

@@ -393,22 +393,53 @@ int git_tag__parse(git_tag *tag, git_odb_object *obj)
 }
 
 typedef struct {
- git_vector *taglist;
- const char *pattern;
+	git_repository *repo;
+	git_tag_foreach_cb cb;
+	void *cb_data;
+} tag_cb_data;
+
+static int tags_cb(const char *ref, void *data)
+{
+	git_oid oid;
+	tag_cb_data *d = (tag_cb_data *)data;
+
+	if (git__prefixcmp(ref, GIT_REFS_TAGS_DIR) != 0)
+		return 0; /* no tag */
+
+	if (git_reference_name_to_oid(&oid, d->repo, ref) < 0)
+		return -1;
+
+	return d->cb(ref, &oid, d->cb_data);
+}
+
+int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
+{
+	tag_cb_data data;
+
+	assert(repo && cb);
+
+	data.cb = cb;
+	data.cb_data = cb_data;
+	data.repo = repo;
+
+	return git_reference_foreach(repo, GIT_REF_OID | GIT_REF_PACKED,
+				     &tags_cb, &data);
+}
+
+typedef struct {
+	git_vector *taglist;
+	const char *pattern;
 } tag_filter_data;
 
 #define GIT_REFS_TAGS_DIR_LEN strlen(GIT_REFS_TAGS_DIR)
 
-static int tag_list_cb(const char *tag_name, void *payload)
+static int tag_list_cb(const char *tag_name, git_oid *oid, void *data)
 {
-	tag_filter_data *filter;
+	tag_filter_data *filter = (tag_filter_data *)data;
+	GIT_UNUSED(oid);
 
-	if (git__prefixcmp(tag_name, GIT_REFS_TAGS_DIR) != 0)
-		return 0;
-
-	filter = (tag_filter_data *)payload;
 	if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
-		return git_vector_insert(filter->taglist, git__strdup(tag_name));
+		return git_vector_insert(filter->taglist, git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN));
 
 	return 0;
 }
@@ -427,7 +458,7 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
 	filter.taglist = &taglist;
 	filter.pattern = pattern;
 
-	error = git_reference_foreach(repo, GIT_REF_OID|GIT_REF_PACKED, &tag_list_cb, (void *)&filter);
+	error = git_tag_foreach(repo, &tag_list_cb, (void *)&filter);
 	if (error < 0) {
 		git_vector_free(&taglist);
 		return -1;
@@ -445,20 +476,5 @@ int git_tag_list(git_strarray *tag_names, git_repository *repo)
 
 int git_tag_peel(git_object **tag_target, git_tag *tag)
 {
-	int error;
-	git_object *target;
-
-	assert(tag_target && tag);
-
-	if (git_tag_target(&target, tag) < 0)
-		return -1;
-
-	if (git_object_type(target) == GIT_OBJ_TAG) {
-		error = git_tag_peel(tag_target, (git_tag *)target);
-		git_object_free(target);
-		return error;
-	}
-
-	*tag_target = target;
-	return 0;
+	return git_object_peel(tag_target, (git_object *)tag, GIT_OBJ_ANY);
 }

data/vendor/libgit2/src/thread-utils.h

@@ -38,13 +38,13 @@ GIT_INLINE(void) git_atomic_set(git_atomic *a, int val)
 #define git_mutex_unlock(a) pthread_mutex_unlock(a)
 #define git_mutex_free(a)	pthread_mutex_destroy(a)
 
-/* Pthreads condition vars -- disabled by now */
-#define git_cond unsigned int //pthread_cond_t
-#define git_cond_init(c, a)	(void)0		//pthread_cond_init(c, a)
-#define git_cond_free(c) (void)0		//pthread_cond_destroy(c)
-#define git_cond_wait(c, l)	(void)0		//pthread_cond_wait(c, l)
-#define git_cond_signal(c)	(void)0		//pthread_cond_signal(c)
-#define git_cond_broadcast(c) (void)0	//pthread_cond_broadcast(c)
+/* Pthreads condition vars */
+#define git_cond pthread_cond_t
+#define git_cond_init(c)	pthread_cond_init(c, NULL)
+#define git_cond_free(c) 	pthread_cond_destroy(c)
+#define git_cond_wait(c, l)	pthread_cond_wait(c, l)
+#define git_cond_signal(c)	pthread_cond_signal(c)
+#define git_cond_broadcast(c)	pthread_cond_broadcast(c)
 
 GIT_INLINE(int) git_atomic_inc(git_atomic *a)
 {

data/vendor/libgit2/src/transport.h

@@ -21,11 +21,17 @@
 
 #define GIT_CAP_OFS_DELTA "ofs-delta"
 #define GIT_CAP_MULTI_ACK "multi_ack"
+#define GIT_CAP_SIDE_BAND "side-band"
+#define GIT_CAP_SIDE_BAND_64K "side-band-64k"
+#define GIT_CAP_INCLUDE_TAG "include-tag"
 
 typedef struct git_transport_caps {
 	int common:1,
 		ofs_delta:1,
-		multi_ack: 1;
+		multi_ack: 1,
+		side_band:1,
+		side_band_64k:1,
+		include_tag:1;
 } git_transport_caps;
 
 #ifdef GIT_SSL
@@ -84,6 +90,9 @@ struct git_transport {
 	gitno_buffer buffer;
 	GIT_SOCKET socket;
 	git_transport_caps caps;
+	void *cb_data;
+	git_atomic cancel;
+
 	/**
 	 * Connect and store the remote heads
 	 */
@@ -113,6 +122,11 @@ struct git_transport {
 	 * Free the associated resources
 	 */
 	void (*free)(struct git_transport *transport);
+	/**
+	 * Callbacks for the progress and error output
+	 */
+	void (*progress_cb)(const char *str, int len, void *data);
+	void (*error_cb)(const char *str, int len, void *data);
 };
 
 

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

@@ -24,7 +24,7 @@
 
 typedef struct {
 	git_transport parent;
-	char buff[1024];
+	char buff[65536];
 #ifdef GIT_WIN32
 	WSADATA wsd;
 #endif

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

@@ -4,7 +4,6 @@
  * 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 <stdlib.h>
 #include "git2.h"
 #include "http_parser.h"
@@ -20,6 +19,13 @@
 #include "filebuf.h"
 #include "repository.h"
 #include "protocol.h"
+#if GIT_WINHTTP
+# include <winhttp.h>
+# pragma comment(lib, "winhttp.lib")
+#endif
+
+#define WIDEN2(s) L ## s
+#define WIDEN(s) WIDEN2(s)
 
 enum last_cb {
 	NONE,
@@ -43,10 +49,15 @@ typedef struct {
 	char *host;
 	char *port;
 	char *service;
-	char buffer[4096];
+	char buffer[65536];
 #ifdef GIT_WIN32
 	WSADATA wsd;
 #endif
+#ifdef GIT_WINHTTP
+	HINTERNET session;
+	HINTERNET connection;
+	HINTERNET request;
+#endif
 } transport_http;
 
 static int gen_request(git_buf *buf, const char *path, const char *host, const char *op,
@@ -77,17 +88,156 @@ static int gen_request(git_buf *buf, const char *path, const char *host, const c
 	return 0;
 }
 
-static int do_connect(transport_http *t, const char *host, const char *port)
+static int send_request(transport_http *t, const char *service, void *data, ssize_t content_length, int ls)
+{
+#ifndef GIT_WINHTTP
+	git_buf request = GIT_BUF_INIT;
+	const char *verb;
+	int error = -1;
+
+	verb = ls ? "GET" : "POST";
+	/* Generate and send the HTTP request */
+	if (gen_request(&request, t->path, t->host, verb, service, content_length, ls) < 0) {
+		giterr_set(GITERR_NET, "Failed to generate request");
+		return -1;
+	}
+
+
+	if (gitno_send((git_transport *) t, request.ptr, request.size, 0) < 0)
+		goto cleanup;
+
+	if (content_length) {
+		if (gitno_send((git_transport *) t, data, content_length, 0) < 0)
+			goto cleanup;
+	}
+
+	error = 0;
+
+cleanup:
+	git_buf_free(&request);
+	return error;
+
+#else
+	wchar_t *verb;
+	wchar_t url[GIT_WIN_PATH], ct[GIT_WIN_PATH];
+	git_buf buf = GIT_BUF_INIT;
+	BOOL ret;
+	DWORD flags;
+	void *buffer;
+	wchar_t *types[] = {
+		L"*/*",
+		NULL,
+	};
+
+	verb = ls ? L"GET" : L"POST";
+	buffer = data ? data : WINHTTP_NO_REQUEST_DATA;
+	flags = t->parent.use_ssl ? WINHTTP_FLAG_SECURE : 0;
+
+	if (ls)
+		git_buf_printf(&buf, "%s/info/refs?service=git-%s", t->path, service);
+	else
+		git_buf_printf(&buf, "%s/git-%s", t->path, service);
+
+	if (git_buf_oom(&buf))
+		return -1;
+
+	git__utf8_to_16(url, GIT_WIN_PATH, git_buf_cstr(&buf));
+
+	t->request = WinHttpOpenRequest(t->connection, verb, url, NULL, WINHTTP_NO_REFERER, types, flags);
+	if (t->request == NULL) {
+		git_buf_free(&buf);
+		giterr_set(GITERR_OS, "Failed to open request");
+		return -1;
+	}
+
+	git_buf_clear(&buf);
+	if (git_buf_printf(&buf, "Content-Type: application/x-git-%s-request", service) < 0)
+		goto on_error;
+
+	git__utf8_to_16(ct, GIT_WIN_PATH, git_buf_cstr(&buf));
+
+	if (WinHttpAddRequestHeaders(t->request, ct, (ULONG) -1L, WINHTTP_ADDREQ_FLAG_ADD) == FALSE) {
+		giterr_set(GITERR_OS, "Failed to add a header to the request");
+		goto on_error;
+	}
+
+	if (!t->parent.check_cert) {
+		int flags = SECURITY_FLAG_IGNORE_CERT_CN_INVALID | SECURITY_FLAG_IGNORE_CERT_DATE_INVALID | SECURITY_FLAG_IGNORE_UNKNOWN_CA;
+		if (WinHttpSetOption(t->request, WINHTTP_OPTION_SECURITY_FLAGS, &flags, sizeof(flags)) == FALSE) {
+			giterr_set(GITERR_OS, "Failed to set options to ignore cert errors");
+			goto on_error;
+		}
+	}
+
+	if (WinHttpSendRequest(t->request, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
+		data, (DWORD)content_length, (DWORD)content_length, 0) == FALSE) {
+		giterr_set(GITERR_OS, "Failed to send request");
+		goto on_error;
+	}
+
+	ret = WinHttpReceiveResponse(t->request, NULL);
+	if (ret == FALSE) {
+		giterr_set(GITERR_OS, "Failed to receive response");
+		goto on_error;
+	}
+
+	return 0;
+
+on_error:
+	git_buf_free(&buf);
+	if (t->request)
+		WinHttpCloseHandle(t->request);
+	t->request = NULL;
+	return -1;
+#endif
+}
+
+static int do_connect(transport_http *t)
 {
+#ifndef GIT_WINHTTP
 	if (t->parent.connected && http_should_keep_alive(&t->parser))
 		return 0;
 
-	if (gitno_connect((git_transport *) t, host, port) < 0)
+	if (gitno_connect((git_transport *) t, t->host, t->port) < 0)
 		return -1;
 
 	t->parent.connected = 1;
 
 	return 0;
+#else
+	wchar_t *ua = L"git/1.0 (libgit2 " WIDEN(LIBGIT2_VERSION) L")";
+	wchar_t host[GIT_WIN_PATH];
+	int32_t port;
+
+	t->session = WinHttpOpen(ua, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
+		WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
+
+	if (t->session == NULL) {
+		giterr_set(GITERR_OS, "Failed to init WinHTTP");
+		goto on_error;
+	}
+
+	git__utf8_to_16(host, GIT_WIN_PATH, t->host);
+
+	if (git__strtol32(&port, t->port, NULL, 10) < 0)
+		goto on_error;
+
+	t->connection = WinHttpConnect(t->session, host, port, 0);
+	if (t->connection == NULL) {
+		giterr_set(GITERR_OS, "Failed to connect to host");
+		goto on_error;
+	}
+
+	t->parent.connected = 1;
+	return 0;
+
+on_error:
+	if (t->session) {
+		WinHttpCloseHandle(t->session);
+		t->session = NULL;
+	}
+	return -1;
+#endif
 }
 
 /*
@@ -216,13 +366,18 @@ static int http_recv_cb(gitno_buffer *buf)
 	git_transport *transport = (git_transport *) buf->cb_data;
 	transport_http *t = (transport_http *) transport;
 	size_t old_len;
-	gitno_buffer inner;
 	char buffer[2048];
+#ifdef GIT_WINHTTP
+	DWORD recvd;
+#else
+	gitno_buffer inner;
 	int error;
+#endif
 
 	if (t->transfer_finished)
 		return 0;
 
+#ifndef GIT_WINHTTP
 	gitno_buffer_setup(transport, &inner, buffer, sizeof(buffer));
 
 	if ((error = gitno_recv(&inner)) < 0)
@@ -232,8 +387,23 @@ static int http_recv_cb(gitno_buffer *buf)
 	http_parser_execute(&t->parser, &t->settings, inner.data, inner.offset);
 	if (t->error < 0)
 		return t->error;
+#else
+	old_len = buf->offset;
+	if (WinHttpReadData(t->request, buffer, sizeof(buffer), &recvd) == FALSE) {
+		giterr_set(GITERR_OS, "Failed to read data from the network");
+		return t->error = -1;
+	}
+
+	if (buf->len - buf->offset < recvd) {
+		giterr_set(GITERR_NET, "Can't fit data in the buffer");
+		return t->error = -1;
+	}
+
+	memcpy(buf->data + buf->offset, buffer, recvd);
+	buf->offset += recvd;
+#endif
 
-	return buf->offset - old_len;
+	return (int)(buf->offset - old_len);
 }
 
 /* Set up the gitno_buffer so calling gitno_recv() grabs data from the HTTP response */
@@ -241,6 +411,8 @@ static void setup_gitno_buffer(git_transport *transport)
 {
 	transport_http *t = (transport_http *) transport;
 
+	/* WinHTTP takes care of this for us */
+#ifndef GIT_WINHTTP
 	http_parser_init(&t->parser, HTTP_RESPONSE);
 	t->parser.data = t;
 	t->transfer_finished = 0;
@@ -250,6 +422,7 @@ static void setup_gitno_buffer(git_transport *transport)
 	t->settings.on_headers_complete = on_headers_complete;
 	t->settings.on_body = on_body_fill_buffer;
 	t->settings.on_message_complete = on_message_complete;
+#endif
 
 	gitno_buffer_setup_callback(transport, &transport->buffer, t->buffer, sizeof(t->buffer), http_recv_cb, t);
 }
@@ -289,17 +462,10 @@ static int http_connect(git_transport *transport, int direction)
 	t->service = git__strdup(service);
 	GITERR_CHECK_ALLOC(t->service);
 
-	if ((ret = do_connect(t, t->host, t->port)) < 0)
+	if ((ret = do_connect(t)) < 0)
 		goto cleanup;
 
-	/* Generate and send the HTTP request */
-	if ((ret = gen_request(&request, t->path, t->host, "GET", service, 0, 1)) < 0) {
-		giterr_set(GITERR_NET, "Failed to generate request");
-		goto cleanup;
-	}
-
-
-	if (gitno_send(transport, request.ptr, request.size, 0) < 0)
+	if ((ret = send_request(t, "upload-pack", NULL, 0, 1)) < 0)
 		goto cleanup;
 
 	setup_gitno_buffer(transport);
@@ -311,10 +477,7 @@ static int http_connect(git_transport *transport, int direction)
 		giterr_set(GITERR_NET, "Invalid HTTP response");
 		return t->error = -1;
 	} else {
-		/* Remove the comment and flush pkts */
-		git_vector_remove(&transport->refs, 0);
-		git__free(pkt);
-		pkt = git_vector_get(&transport->refs, 0);
+		/* Remove the comment pkt from the list */
 		git_vector_remove(&transport->refs, 0);
 		git__free(pkt);
 	}
@@ -332,36 +495,24 @@ cleanup:
 static int http_negotiation_step(struct git_transport *transport, void *data, size_t len)
 {
 	transport_http *t = (transport_http *) transport;
-	git_buf request = GIT_BUF_INIT;
 	int ret;
 
 	/* First, send the data as a HTTP POST request */
-	if ((ret = do_connect(t, t->host, t->port)) < 0)
+	if ((ret = do_connect(t)) < 0)
 		return -1;
 
-	if ((ret = gen_request(&request, t->path, t->host, "POST", "upload-pack", len, 0)) < 0)
-		goto on_error;
-
-	if ((ret = gitno_send(transport, request.ptr, request.size, 0)) < 0)
-		goto on_error;
-
-	if ((ret = gitno_send(transport, data, len, 0)) < 0)
-		goto on_error;
-
-	git_buf_free(&request);
+	if (send_request(t, "upload-pack", data, len, 0) < 0)
+		return -1;
 
 	/* Then we need to set up the buffer to grab data from the HTTP response */
 	setup_gitno_buffer(transport);
 
 	return 0;
-
-on_error:
-	git_buf_free(&request);
-	return -1;
 }
 
 static int http_close(git_transport *transport)
 {
+#ifndef GIT_WINHTTP
 	if (gitno_ssl_teardown(transport) < 0)
 		return -1;
 
@@ -369,6 +520,16 @@ static int http_close(git_transport *transport)
 		giterr_set(GITERR_OS, "Failed to close the socket: %s", strerror(errno));
 		return -1;
 	}
+#else
+	transport_http *t = (transport_http *) transport;
+
+	if (t->request)
+		WinHttpCloseHandle(t->request);
+	if (t->connection)
+		WinHttpCloseHandle(t->connection);
+	if (t->session)
+		WinHttpCloseHandle(t->session);
+#endif
 
 	transport->connected = 0;
 
@@ -445,7 +606,7 @@ int git_transport_http(git_transport **out)
 
 int git_transport_https(git_transport **out)
 {
-#ifdef GIT_SSL
+#if defined(GIT_SSL) || defined(GIT_WINHTTP)
 	transport_http *t;
 	if (git_transport_http((git_transport **)&t) < 0)
 		return -1;