rugged 1.7.2 → 1.9.4

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

@@ -0,0 +1,128 @@
+/*
+ * 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 "httpparser.h"
+
+#include <string.h>
+
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+
+#include "http_parser.h"
+
+static int on_message_begin(http_parser *p)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_message_begin(parser);
+}
+
+static int on_url(http_parser *p, const char *str, size_t len)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_url(parser, str, len);
+}
+
+static int on_header_field(http_parser *p, const char *str, size_t len)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_header_field(parser, str, len);
+}
+
+static int on_header_value(http_parser *p, const char *str, size_t len)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_header_value(parser, str, len);
+}
+
+static int on_headers_complete(http_parser *p)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_headers_complete(parser);
+}
+
+static int on_body(http_parser *p, const char *buf, size_t len)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_body(parser, buf, len);
+}
+
+static int on_message_complete(http_parser *p)
+{
+	git_http_parser *parser = (git_http_parser *)p;
+	return parser->settings.on_message_complete(parser);
+}
+
+void git_http_parser_init(
+	git_http_parser *parser,
+	git_http_parser_t type,
+	git_http_parser_settings *settings)
+{
+	http_parser_init(&parser->parser, (enum http_parser_type)type);
+	memcpy(&parser->settings, settings, sizeof(git_http_parser_settings));
+}
+
+size_t git_http_parser_execute(
+	git_http_parser *parser,
+	const char *data,
+	size_t len)
+{
+	struct http_parser_settings settings_proxy;
+
+	memset(&settings_proxy, 0, sizeof(struct http_parser_settings));
+
+	settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL;
+	settings_proxy.on_url = parser->settings.on_url ? on_url : NULL;
+	settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL;
+	settings_proxy.on_header_value = parser->settings.on_header_value ? on_header_value : NULL;
+	settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL;
+	settings_proxy.on_body = parser->settings.on_body ? on_body : NULL;
+	settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL;
+
+	return http_parser_execute(&parser->parser, &settings_proxy, data, len);
+}
+
+#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN)
+
+# include <llhttp.h>
+
+size_t git_http_parser_execute(
+	git_http_parser *parser,
+	const char* data,
+	size_t len)
+{
+	llhttp_errno_t error;
+	size_t parsed_len;
+
+	/*
+	 * Unlike http_parser, which returns the number of parsed
+	 * bytes in the _execute() call, llhttp returns an error
+	 * code.
+	 */
+
+	if (data == NULL || len == 0)
+		error = llhttp_finish(parser);
+	else
+		error = llhttp_execute(parser, data, len);
+
+	parsed_len = len;
+
+	/*
+	 * Adjust number of parsed bytes in case of error.
+	 */
+	if (error != HPE_OK) {
+		parsed_len = llhttp_get_error_pos(parser) - data;
+
+		/* This isn't a real pause, just a way to stop parsing early. */
+		if (error == HPE_PAUSED_UPGRADE)
+			llhttp_resume_after_upgrade(parser);
+	}
+
+	return parsed_len;
+}
+
+#else
+# error unknown http-parser
+#endif

data/vendor/libgit2/src/libgit2/transports/httpparser.h

@@ -0,0 +1,99 @@
+/*
+ * 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_transports_httpparser_h__
+#define INCLUDE_transports_httpparser_h__
+
+#include "git2_util.h"
+
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+
+# include <http_parser.h>
+
+typedef enum {
+	GIT_HTTP_PARSER_OK     = HPE_OK,
+	GIT_HTTP_PARSER_PAUSED = HPE_PAUSED,
+} git_http_parser_error_t;
+
+typedef enum {
+	GIT_HTTP_PARSER_REQUEST  = HTTP_REQUEST,
+	GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE,
+} git_http_parser_t;
+
+typedef struct git_http_parser git_http_parser;
+
+typedef struct {
+	int (*on_message_begin)(git_http_parser *);
+	int (*on_url)(git_http_parser *, const char *, size_t);
+	int (*on_header_field)(git_http_parser *, const char *, size_t);
+	int (*on_header_value)(git_http_parser *, const char *, size_t);
+	int (*on_headers_complete)(git_http_parser *);
+	int (*on_body)(git_http_parser *, const char *, size_t);
+	int (*on_message_complete)(git_http_parser *);
+} git_http_parser_settings;
+
+struct git_http_parser {
+	http_parser parser;
+	git_http_parser_settings settings;
+	void *data;
+};
+
+void git_http_parser_init(
+	git_http_parser *parser,
+	git_http_parser_t type,
+	git_http_parser_settings *settings);
+
+size_t git_http_parser_execute(
+	git_http_parser *parser,
+	const char *data,
+	size_t len);
+
+# define git_http_parser_status_code(parser) parser->parser.status_code
+# define git_http_parser_keep_alive(parser) http_should_keep_alive(&parser->parser)
+# define git_http_parser_pause(parser) (http_parser_pause(&parser->parser, 1), 0)
+# define git_http_parser_resume(parser) http_parser_pause(&parser->parser, 0)
+# define git_http_parser_remain_after_pause(parser) 1
+# define git_http_parser_errno(parser) parser->parser.http_errno
+# define git_http_parser_errmsg(parser, errno) http_errno_description(errno)
+
+#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN)
+
+# include <llhttp.h>
+
+typedef enum {
+	GIT_HTTP_PARSER_OK     = HPE_OK,
+	GIT_HTTP_PARSER_PAUSED = HPE_PAUSED,
+} git_http_parser_error_t;
+
+typedef enum {
+	GIT_HTTP_PARSER_REQUEST  = HTTP_REQUEST,
+	GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE,
+} git_http_parser_t;
+
+typedef llhttp_t git_http_parser;
+typedef llhttp_settings_t git_http_parser_settings;
+
+# define git_http_parser_init(parser, direction, settings) llhttp_init(parser, (llhttp_type_t)direction, settings)
+
+size_t git_http_parser_execute(
+	git_http_parser *parser,
+	const char *data,
+	size_t len);
+
+# define git_http_parser_status_code(parser) parser->status_code
+# define git_http_parser_keep_alive(parser) llhttp_should_keep_alive(parser)
+# define git_http_parser_pause(parser) (llhttp_pause(parser), GIT_HTTP_PARSER_PAUSED)
+# define git_http_parser_resume(parser) llhttp_resume(parser)
+# define git_http_parser_remain_after_pause(parser) 0
+# define git_http_parser_errno(parser) parser->error
+# define git_http_parser_errmsg(parser, errno) llhttp_get_error_reason(parser)
+
+#else
+# error unknown http-parser
+#endif
+
+#endif

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

@@ -41,6 +41,9 @@ typedef struct {
 	git_vector refs;
 	unsigned connected : 1,
 		have_refs : 1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type;
+#endif
 } transport_local;
 
 static void free_head(git_remote_head *head)
@@ -58,7 +61,7 @@ static void free_heads(git_vector *heads)
 	git_vector_foreach(heads, i, head)
 		free_head(head);
 
-	git_vector_free(heads);
+	git_vector_dispose(heads);
 }
 
 static int add_ref(transport_local *t, const char *name)
@@ -108,10 +111,6 @@ static int add_ref(transport_local *t, const char *name)
 		return error;
 	}
 
-	/* If it's not a tag, we don't need to try to peel it */
-	if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
-		return 0;
-
 	if ((error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJECT_ANY)) < 0)
 		return error;
 
@@ -186,7 +185,7 @@ static int store_refs(transport_local *t)
 	return 0;
 
 on_error:
-	git_vector_free(&t->refs);
+	git_vector_dispose(&t->refs);
 	git_strarray_dispose(&ref_names);
 	return -1;
 }
@@ -235,6 +234,10 @@ static int local_connect(
 
 	t->repo = repo;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	t->oid_type = repo->oid_type;
+#endif
+
 	if (store_refs(t) < 0)
 		return -1;
 
@@ -271,7 +274,7 @@ static int local_oid_type(git_oid_t *out, git_transport *transport)
 {
 	transport_local *t = (transport_local *)transport;
 
-	*out = t->repo->oid_type;
+	*out = t->oid_type;
 
 	return 0;
 }
@@ -303,6 +306,11 @@ static int local_negotiate_fetch(
 
 	GIT_UNUSED(wants);
 
+	if (wants->depth) {
+		git_error_set(GIT_ERROR_NET, "shallow fetch is not supported by the local transport");
+		return GIT_ENOTSUPPORTED;
+	}
+
 	/* Fill in the loids */
 	git_vector_foreach(&t->refs, i, rhead) {
 		git_object *obj;
@@ -453,7 +461,7 @@ static int local_push(
 			default:
 				last = git_error_last();
 
-				if (last && last->message)
+				if (last->klass != GIT_ERROR_NONE)
 					status->msg = git__strdup(last->message);
 				else
 					status->msg = git__strdup("Unspecified error encountered");

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

@@ -64,13 +64,13 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp
 
 		if (t->wrapped->close(t->wrapped) < 0)
 			return -1;
-	}
 
-	git__free(t->caps.object_format);
-	t->caps.object_format = NULL;
+		git__free(t->caps.object_format);
+		t->caps.object_format = NULL;
 
-	git__free(t->caps.agent);
-	t->caps.agent = NULL;
+		git__free(t->caps.agent);
+		t->caps.agent = NULL;
+	}
 
 	return 0;
 }
@@ -124,7 +124,7 @@ static void free_symrefs(git_vector *symrefs)
 		git__free(spec);
 	}
 
-	git_vector_free(symrefs);
+	git_vector_dispose(symrefs);
 }
 
 static int git_smart__connect(
@@ -249,6 +249,9 @@ static int git_smart__capabilities(unsigned int *capabilities, git_transport *tr
 
 	*capabilities = 0;
 
+	if (t->caps.push_options)
+		*capabilities |= GIT_REMOTE_CAPABILITY_PUSH_OPTIONS;
+
 	if (t->caps.want_tip_sha1)
 		*capabilities |= GIT_REMOTE_CAPABILITY_TIP_OID;
 
@@ -370,17 +373,27 @@ static int git_smart__close(git_transport *transport)
 	git_vector *common = &t->common;
 	unsigned int i;
 	git_pkt *p;
+	git_smart_service_t service;
 	int ret;
 	git_smart_subtransport_stream *stream;
 	const char flush[] = "0000";
 
+	if (t->direction == GIT_DIRECTION_FETCH) {
+		service = GIT_SERVICE_UPLOADPACK;
+	} else if (t->direction == GIT_DIRECTION_PUSH) {
+		service = GIT_SERVICE_RECEIVEPACK;
+	} else {
+		git_error_set(GIT_ERROR_NET, "invalid direction");
+		return -1;
+	}
+
 	/*
 	 * If we're still connected at this point and not using RPC,
 	 * we should say goodbye by sending a flush, or git-daemon
 	 * will complain that we disconnected unexpectedly.
 	 */
 	if (t->connected && !t->rpc &&
-	    !t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) {
+	    !t->wrapped->action(&stream, t->wrapped, t->url, service)) {
 		t->current_stream->write(t->current_stream, flush, 4);
 	}
 
@@ -389,7 +402,7 @@ static int git_smart__close(git_transport *transport)
 	git_vector_foreach(common, i, p)
 		git_pkt_free(p);
 
-	git_vector_free(common);
+	git_vector_dispose(common);
 
 	if (t->url) {
 		git__free(t->url);
@@ -414,11 +427,11 @@ static void git_smart__free(git_transport *transport)
 	/* Free the subtransport */
 	t->wrapped->free(t->wrapped);
 
-	git_vector_free(&t->heads);
+	git_vector_dispose(&t->heads);
 	git_vector_foreach(refs, i, p)
 		git_pkt_free(p);
 
-	git_vector_free(refs);
+	git_vector_dispose(refs);
 
 	git_remote_connect_options_dispose(&t->connect_opts);
 
@@ -511,9 +524,8 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
 	if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0 ||
 	    git_vector_init(&t->heads, 16, ref_name_cmp) < 0 ||
 	    definition->callback(&t->wrapped, &t->parent, definition->param) < 0) {
-		git_vector_free(&t->refs);
-		git_vector_free(&t->heads);
-		t->wrapped->free(t->wrapped);
+		git_vector_dispose(&t->refs);
+		git_vector_dispose(&t->heads);
 		git__free(t);
 		return -1;
 	}

data/vendor/libgit2/src/libgit2/transports/smart.h

@@ -38,6 +38,7 @@
 #define GIT_CAP_SHALLOW "shallow"
 #define GIT_CAP_OBJECT_FORMAT "object-format="
 #define GIT_CAP_AGENT "agent="
+#define GIT_CAP_PUSH_OPTIONS "push-options"
 
 extern bool git_smart__ofs_delta_enabled;
 
@@ -146,7 +147,8 @@ typedef struct transport_smart_caps {
 	             thin_pack:1,
 	             want_tip_sha1:1,
 	             want_reachable_sha1:1,
-	             shallow:1;
+	             shallow:1,
+	             push_options:1;
 	char *object_format;
 	char *agent;
 } transport_smart_caps;
@@ -203,7 +205,7 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs);
 /* smart_pkt.c */
 typedef struct {
 	git_oid_t oid_type;
-	int seen_capabilities: 1;
+	unsigned int seen_capabilities: 1;
 } git_pkt_parse_data;
 
 int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data);

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

@@ -238,13 +238,13 @@ static int set_data(
 
 		if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0)
 			format_str = caps + CONST_STRLEN("object-format=");
-		else if ((format_str = strstr(caps, " object-format=")) != NULL)
+		else if ((format_str = git__memmem(caps, len - (caps - line), " object-format=", CONST_STRLEN(" object-format="))) != NULL)
 			format_str += CONST_STRLEN(" object-format=");
 	}
 
 	if (format_str) {
-		if ((eos = strchr(format_str, ' ')) == NULL)
-			eos = strchr(format_str, '\0');
+		if ((eos = memchr(format_str, ' ', len - (format_str - line))) == NULL)
+			eos = memchr(format_str, '\0', len - (format_str - line));
 
 		GIT_ASSERT(eos);
 
@@ -536,10 +536,10 @@ static int parse_len(size_t *out, const char *line, size_t linelen)
 	num[PKT_LEN_SIZE] = '\0';
 
 	for (i = 0; i < PKT_LEN_SIZE; ++i) {
-		if (!isxdigit(num[i])) {
+		if (!git__isxdigit(num[i])) {
 			/* Make sure there are no special characters before passing to error message */
 			for (k = 0; k < PKT_LEN_SIZE; ++k) {
-				if(!isprint(num[k])) {
+				if(!git__isprint(num[k])) {
 					num[k] = '.';
 				}
 			}

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

@@ -59,7 +59,7 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 				return recvd;
 
 			if (recvd == 0) {
-				git_error_set(GIT_ERROR_NET, "early EOF");
+				git_error_set(GIT_ERROR_NET, "could not read refs from remote repository");
 				return GIT_EEOF;
 			}
 
@@ -194,6 +194,12 @@ int git_smart__detect_caps(
 			continue;
 		}
 
+		if (!git__prefixcmp(ptr, GIT_CAP_PUSH_OPTIONS)) {
+			caps->common = caps->push_options = 1;
+			ptr += strlen(GIT_CAP_PUSH_OPTIONS);
+			continue;
+		}
+
 		if (!git__prefixcmp(ptr, GIT_CAP_THIN_PACK)) {
 			caps->common = caps->thin_pack = 1;
 			ptr += strlen(GIT_CAP_THIN_PACK);
@@ -285,7 +291,7 @@ static int recv_pkt(
 		if ((ret = git_smart__recv(t)) < 0) {
 			return ret;
 		} else if (ret == 0) {
-			git_error_set(GIT_ERROR_NET, "early EOF");
+			git_error_set(GIT_ERROR_NET, "could not read from remote repository");
 			return GIT_EEOF;
 		}
 	} while (error);
@@ -311,6 +317,13 @@ static int store_common(transport_smart *t)
 		if ((error = recv_pkt(&pkt, NULL, t)) < 0)
 			return error;
 
+		if (t->rpc && (pkt->type == GIT_PKT_SHALLOW ||
+		               pkt->type == GIT_PKT_UNSHALLOW ||
+		               pkt->type == GIT_PKT_FLUSH)) {
+			git__free(pkt);
+			continue;
+		}
+
 		if (pkt->type != GIT_PKT_ACK) {
 			git__free(pkt);
 			return 0;
@@ -388,6 +401,7 @@ static int setup_shallow_roots(
 
 		memcpy(out->ptr, wants->shallow_roots,
 		       sizeof(git_oid) * wants->shallow_roots_len);
+		out->size = wants->shallow_roots_len;
 	}
 
 	return 0;
@@ -427,6 +441,9 @@ int git_smart__negotiate_fetch(
 		if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
 			goto on_error;
 
+		if (!t->rpc)
+			git_str_clear(&data);
+
 		while ((error = recv_pkt((git_pkt **)&pkt, NULL, t)) == 0) {
 			bool complete = false;
 
@@ -778,33 +795,54 @@ done:
 static int gen_pktline(git_str *buf, git_push *push)
 {
 	push_spec *spec;
+	char *option;
 	size_t i, len;
-	char old_id[GIT_OID_SHA1_HEXSIZE+1], new_id[GIT_OID_SHA1_HEXSIZE+1];
-
-	old_id[GIT_OID_SHA1_HEXSIZE] = '\0'; new_id[GIT_OID_SHA1_HEXSIZE] = '\0';
+	char old_id[GIT_OID_MAX_HEXSIZE + 1], new_id[GIT_OID_MAX_HEXSIZE + 1];
+	size_t old_id_len, new_id_len;
 
 	git_vector_foreach(&push->specs, i, spec) {
-		len = 2*GIT_OID_SHA1_HEXSIZE + 7 + strlen(spec->refspec.dst);
+		len = strlen(spec->refspec.dst) + 7;
 
 		if (i == 0) {
-			++len; /* '\0' */
+			/* Need a leading \0 */
+			++len;
+
 			if (push->report_status)
 				len += strlen(GIT_CAP_REPORT_STATUS) + 1;
+
+			if (git_vector_length(&push->remote_push_options) > 0)
+				len += strlen(GIT_CAP_PUSH_OPTIONS) + 1;
+
 			len += strlen(GIT_CAP_SIDE_BAND_64K) + 1;
 		}
 
+		old_id_len = git_oid_hexsize(git_oid_type(&spec->roid));
+		new_id_len = git_oid_hexsize(git_oid_type(&spec->loid));
+
+		len += (old_id_len + new_id_len);
+
 		git_oid_fmt(old_id, &spec->roid);
+		old_id[old_id_len] = '\0';
+
 		git_oid_fmt(new_id, &spec->loid);
+		new_id[new_id_len] = '\0';
 
-		git_str_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst);
+		git_str_printf(buf, "%04"PRIxZ"%.*s %.*s %s", len,
+			(int)old_id_len, old_id, (int)new_id_len, new_id,
+			spec->refspec.dst);
 
 		if (i == 0) {
 			git_str_putc(buf, '\0');
+
 			/* Core git always starts their capabilities string with a space */
 			if (push->report_status) {
 				git_str_putc(buf, ' ');
 				git_str_printf(buf, GIT_CAP_REPORT_STATUS);
 			}
+			if (git_vector_length(&push->remote_push_options) > 0) {
+				git_str_putc(buf, ' ');
+				git_str_printf(buf, GIT_CAP_PUSH_OPTIONS);
+			}
 			git_str_putc(buf, ' ');
 			git_str_printf(buf, GIT_CAP_SIDE_BAND_64K);
 		}
@@ -812,6 +850,13 @@ static int gen_pktline(git_str *buf, git_push *push)
 		git_str_putc(buf, '\n');
 	}
 
+	if (git_vector_length(&push->remote_push_options) > 0) {
+		git_str_printf(buf, "0000");
+		git_vector_foreach(&push->remote_push_options, i, option) {
+			git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option);
+		}
+	}
+
 	git_str_puts(buf, "0000");
 	return git_str_oom(buf) ? -1 : 0;
 }
@@ -940,7 +985,7 @@ static int parse_report(transport_smart *transport, git_push *push)
 			}
 
 			if (recvd == 0) {
-				git_error_set(GIT_ERROR_NET, "early EOF");
+				git_error_set(GIT_ERROR_NET, "could not read report from remote repository");
 				error = GIT_EEOF;
 				goto done;
 			}
@@ -1157,7 +1202,7 @@ int git_smart__push(git_transport *transport, git_push *push)
 #ifdef PUSH_DEBUG
 {
 	git_remote_head *head;
-	char hex[GIT_OID_SHA1_HEXSIZE+1]; hex[GIT_OID_SHA1_HEXSIZE] = '\0';
+	char hex[GIT_OID_MAX_HEXSIZE+1], hex[GIT_OID_MAX_HEXSIZE] = '\0';
 
 	git_vector_foreach(&push->remote->refs, i, head) {
 		git_oid_fmt(hex, &head->oid);