rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/libgit2/transaction.c

@@ -8,7 +8,6 @@
 #include "transaction.h"
 
 #include "repository.h"
-#include "strmap.h"
 #include "refdb.h"
 #include "pool.h"
 #include "reflog.h"
@@ -44,17 +43,23 @@ typedef struct {
 		remove :1;
 } transaction_node;
 
+GIT_HASHMAP_STR_SETUP(git_transaction_nodemap, transaction_node *);
+
 struct git_transaction {
 	transaction_t type;
 	git_repository *repo;
 	git_refdb *db;
 	git_config *cfg;
+	void *cfg_data;
 
-	git_strmap *locks;
+	git_transaction_nodemap locks;
 	git_pool pool;
 };
 
-int git_transaction_config_new(git_transaction **out, git_config *cfg)
+int git_transaction_config_new(
+	git_transaction **out,
+	git_config *cfg,
+	void *data)
 {
 	git_transaction *tx;
 
@@ -66,6 +71,8 @@ int git_transaction_config_new(git_transaction **out, git_config *cfg)
 
 	tx->type = TRANSACTION_CONFIG;
 	tx->cfg = cfg;
+	tx->cfg_data = data;
+
 	*out = tx;
 	return 0;
 }
@@ -88,11 +95,6 @@ int git_transaction_new(git_transaction **out, git_repository *repo)
 		goto on_error;
 	}
 
-	if ((error = git_strmap_new(&tx->locks)) < 0) {
-		error = -1;
-		goto on_error;
-	}
-
 	if ((error = git_repository_refdb(&tx->db, repo)) < 0)
 		goto on_error;
 
@@ -124,7 +126,7 @@ int git_transaction_lock_ref(git_transaction *tx, const char *refname)
 	if ((error = git_refdb_lock(&node->payload, tx->db, refname)) < 0)
 		return error;
 
-	if ((error = git_strmap_set(tx->locks, node->name, node)) < 0)
+	if ((error = git_transaction_nodemap_put(&tx->locks, node->name, node)) < 0)
 		goto cleanup;
 
 	return 0;
@@ -138,8 +140,11 @@ cleanup:
 static int find_locked(transaction_node **out, git_transaction *tx, const char *refname)
 {
 	transaction_node *node;
+	int error;
+
+	error = git_transaction_nodemap_get(&node, &tx->locks, refname);
 
-	if ((node = git_strmap_get(tx->locks, refname)) == NULL) {
+	if (error != 0) {
 		git_error_set(GIT_ERROR_REFERENCE, "the specified reference is not locked");
 		return GIT_ENOTFOUND;
 	}
@@ -328,18 +333,20 @@ static int update_target(git_refdb *db, transaction_node *node)
 int git_transaction_commit(git_transaction *tx)
 {
 	transaction_node *node;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	int error = 0;
 
 	GIT_ASSERT_ARG(tx);
 
 	if (tx->type == TRANSACTION_CONFIG) {
-		error = git_config_unlock(tx->cfg, true);
+		error = git_config_unlock(tx->cfg, tx->cfg_data, true);
 		tx->cfg = NULL;
+		tx->cfg_data = NULL;
 
 		return error;
 	}
 
-	git_strmap_foreach_value(tx->locks, node, {
+	while (git_transaction_nodemap_iterate(&iter, NULL, &node, &tx->locks) == 0) {
 		if (node->reflog) {
 			if ((error = tx->db->backend->reflog_write(tx->db->backend, node->reflog)) < 0)
 				return error;
@@ -355,7 +362,7 @@ int git_transaction_commit(git_transaction *tx)
 			if ((error = update_target(tx->db, node)) < 0)
 				return error;
 		}
-	});
+	}
 
 	return 0;
 }
@@ -364,30 +371,29 @@ void git_transaction_free(git_transaction *tx)
 {
 	transaction_node *node;
 	git_pool pool;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	if (!tx)
 		return;
 
 	if (tx->type == TRANSACTION_CONFIG) {
-		if (tx->cfg) {
-			git_config_unlock(tx->cfg, false);
-			git_config_free(tx->cfg);
-		}
+		if (tx->cfg)
+			git_config_unlock(tx->cfg, tx->cfg_data, false);
 
 		git__free(tx);
 		return;
 	}
 
 	/* start by unlocking the ones we've left hanging, if any */
-	git_strmap_foreach_value(tx->locks, node, {
+	while (git_transaction_nodemap_iterate(&iter, NULL, &node, &tx->locks) == 0) {
 		if (node->committed)
 			continue;
 
 		git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);
-	});
+	}
 
 	git_refdb_free(tx->db);
-	git_strmap_free(tx->locks);
+	git_transaction_nodemap_dispose(&tx->locks);
 
 	/* tx is inside the pool, so we need to extract the data */
 	memcpy(&pool, &tx->pool, sizeof(git_pool));

data/vendor/libgit2/src/libgit2/transaction.h

@@ -9,6 +9,9 @@
 
 #include "common.h"
 
-int git_transaction_config_new(git_transaction **out, git_config *cfg);
+int git_transaction_config_new(
+	git_transaction **out,
+	git_config *cfg,
+	void *data);
 
 #endif

data/vendor/libgit2/src/libgit2/transport.c

@@ -22,6 +22,7 @@ typedef struct transport_definition {
 
 static git_smart_subtransport_definition http_subtransport_definition = { git_smart_subtransport_http, 1, NULL };
 static git_smart_subtransport_definition git_subtransport_definition = { git_smart_subtransport_git, 0, NULL };
+
 #ifdef GIT_SSH
 static git_smart_subtransport_definition ssh_subtransport_definition = { git_smart_subtransport_ssh, 0, NULL };
 #endif
@@ -33,11 +34,13 @@ static transport_definition transports[] = {
 	{ "http://",  git_transport_smart, &http_subtransport_definition },
 	{ "https://", git_transport_smart, &http_subtransport_definition },
 	{ "file://",  git_transport_local, NULL },
+
 #ifdef GIT_SSH
 	{ "ssh://",   git_transport_smart, &ssh_subtransport_definition },
 	{ "ssh+git://",   git_transport_smart, &ssh_subtransport_definition },
 	{ "git+ssh://",   git_transport_smart, &ssh_subtransport_definition },
 #endif
+
 	{ NULL, 0, 0 }
 };
 
@@ -200,7 +203,7 @@ int git_transport_unregister(const char *scheme)
 			git__free(d);
 
 			if (!custom_transports.length)
-				git_vector_free(&custom_transports);
+				git_vector_dispose(&custom_transports);
 
 			error = 0;
 			goto done;

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

@@ -324,12 +324,14 @@ static int sspi_init_context(
 	return 0;
 }
 
+#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK) || defined(GIT_WIN32)
 int git_http_auth_negotiate(
 	git_http_auth_context **out,
 	const git_net_url *url)
 {
 	return sspi_init_context(out, GIT_HTTP_AUTH_NEGOTIATE, url);
 }
+#endif
 
 int git_http_auth_ntlm(
 	git_http_auth_context **out,

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

@@ -161,7 +161,7 @@ static void ssh_custom_free(struct git_credential *cred)
 
 	if (c->publickey) {
 		/* Zero the memory which previously held the publickey */
-		size_t key_len = strlen(c->publickey);
+		size_t key_len = c->publickey_len;
 		git__memzero(c->publickey, key_len);
 		git__free(c->publickey);
 	}
@@ -204,7 +204,7 @@ int git_credential_ssh_key_memory_new(
 	const char *privatekey,
 	const char *passphrase)
 {
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
+#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS
 	return git_credential_ssh_key_type_new(
 		cred,
 		username,

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

@@ -39,7 +39,7 @@ typedef struct {
  */
 static int gen_proto(git_str *request, const char *cmd, const char *url)
 {
-	char *delim, *repo;
+	const char *delim, *repo;
 	char host[] = "host=";
 	size_t len;
 

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

@@ -9,7 +9,6 @@
 
 #ifndef GIT_WINHTTP
 
-#include "http_parser.h"
 #include "net.h"
 #include "remote.h"
 #include "smart.h"
@@ -334,7 +333,7 @@ static int lookup_proxy(
 		return 0;
 	}
 
-	if (!proxy ||
+	if (!proxy || !*proxy ||
 	    (error = git_net_url_parse_http(&transport->proxy.url, proxy)) < 0)
 		goto done;
 

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

@@ -15,14 +15,4 @@
 
 extern bool git_http__expect_continue;
 
-GIT_INLINE(int) git_http__user_agent(git_str *buf)
-{
-	const char *ua = git_libgit2__user_agent();
-
-	if (!ua)
-		ua = "libgit2 " LIBGIT2_VERSION;
-
-	return git_str_printf(buf, "git/2.0 (%s)", ua);
-}
-
 #endif

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

@@ -7,7 +7,7 @@
 
 #include "common.h"
 #include "git2.h"
-#include "http_parser.h"
+
 #include "vector.h"
 #include "trace.h"
 #include "httpclient.h"
@@ -21,6 +21,7 @@
 #include "streams/socket.h"
 #include "streams/tls.h"
 #include "auth.h"
+#include "httpparser.h"
 
 static git_http_auth_scheme auth_schemes[] = {
 	{ GIT_HTTP_AUTH_NEGOTIATE, "Negotiate", GIT_CREDENTIAL_DEFAULT, git_http_auth_negotiate },
@@ -108,7 +109,7 @@ struct git_http_client {
 	git_http_server_t current_server;
 	http_client_state state;
 
-	http_parser parser;
+	git_http_parser parser;
 
 	git_http_server server;
 	git_http_server proxy;
@@ -154,7 +155,7 @@ void git_http_response_dispose(git_http_response *response)
 	memset(response, 0, sizeof(git_http_response));
 }
 
-static int on_header_complete(http_parser *parser)
+static int on_header_complete(git_http_parser *parser)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 	git_http_client *client = ctx->client;
@@ -219,7 +220,7 @@ static int on_header_complete(http_parser *parser)
 	return 0;
 }
 
-static int on_header_field(http_parser *parser, const char *str, size_t len)
+static int on_header_field(git_http_parser *parser, const char *str, size_t len)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 
@@ -254,7 +255,7 @@ static int on_header_field(http_parser *parser, const char *str, size_t len)
 	return 0;
 }
 
-static int on_header_value(http_parser *parser, const char *str, size_t len)
+static int on_header_value(git_http_parser *parser, const char *str, size_t len)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 
@@ -342,7 +343,7 @@ static int resend_needed(git_http_client *client, git_http_response *response)
 	return 0;
 }
 
-static int on_headers_complete(http_parser *parser)
+static int on_headers_complete(git_http_parser *parser)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 
@@ -364,8 +365,8 @@ static int on_headers_complete(http_parser *parser)
 		return ctx->parse_status = PARSE_STATUS_ERROR;
 	}
 
-	ctx->response->status = parser->status_code;
-	ctx->client->keepalive = http_should_keep_alive(parser);
+	ctx->response->status = git_http_parser_status_code(parser);
+	ctx->client->keepalive = git_http_parser_keep_alive(parser);
 
 	/* Prepare for authentication */
 	collect_authinfo(&ctx->response->server_auth_schemetypes,
@@ -378,18 +379,15 @@ static int on_headers_complete(http_parser *parser)
 	ctx->response->resend_credentials = resend_needed(ctx->client,
 	                                                  ctx->response);
 
-	/* Stop parsing. */
-	http_parser_pause(parser, 1);
-
-	if (ctx->response->content_type || ctx->response->chunked)
+	if (ctx->response->content_length || ctx->response->chunked)
 		ctx->client->state = READING_BODY;
 	else
 		ctx->client->state = DONE;
 
-	return 0;
+	return git_http_parser_pause(parser);
 }
 
-static int on_body(http_parser *parser, const char *buf, size_t len)
+static int on_body(git_http_parser *parser, const char *buf, size_t len)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 	size_t max_len;
@@ -411,7 +409,7 @@ static int on_body(http_parser *parser, const char *buf, size_t len)
 	return 0;
 }
 
-static int on_message_complete(http_parser *parser)
+static int on_message_complete(git_http_parser *parser)
 {
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 
@@ -555,7 +553,7 @@ static int apply_credentials(
 {
 	git_http_auth_context *auth = server->auth_context;
 	git_vector *challenges = &server->auth_challenges;
-	const char *challenge;
+	const char *challenge = NULL;
 	git_str token = GIT_STR_INIT;
 	int error = 0;
 
@@ -651,6 +649,30 @@ static int puts_host_and_port(git_str *buf, git_net_url *url, bool force_port)
 	return git_str_oom(buf) ? -1 : 0;
 }
 
+static int append_user_agent(git_str *buf)
+{
+	const char *product = git_settings__user_agent_product();
+	const char *comment = git_settings__user_agent();
+
+	GIT_ASSERT(product && comment);
+
+	if (!*product)
+		return 0;
+
+	git_str_puts(buf, "User-Agent: ");
+	git_str_puts(buf, product);
+
+	if (*comment) {
+		git_str_puts(buf, " (");
+		git_str_puts(buf, comment);
+		git_str_puts(buf, ")");
+	}
+
+	git_str_puts(buf, "\r\n");
+
+	return git_str_oom(buf) ? -1 : 0;
+}
+
 static int generate_connect_request(
 	git_http_client *client,
 	git_http_request *request)
@@ -665,9 +687,7 @@ static int generate_connect_request(
 	puts_host_and_port(buf, &client->server.url, true);
 	git_str_puts(buf, " HTTP/1.1\r\n");
 
-	git_str_puts(buf, "User-Agent: ");
-	git_http__user_agent(buf);
-	git_str_puts(buf, "\r\n");
+	append_user_agent(buf);
 
 	git_str_puts(buf, "Host: ");
 	puts_host_and_port(buf, &client->server.url, true);
@@ -711,9 +731,7 @@ static int generate_request(
 
 	git_str_puts(buf, " HTTP/1.1\r\n");
 
-	git_str_puts(buf, "User-Agent: ");
-	git_http__user_agent(buf);
-	git_str_puts(buf, "\r\n");
+	append_user_agent(buf);
 
 	git_str_puts(buf, "Host: ");
 	puts_host_and_port(buf, request->url, false);
@@ -768,25 +786,37 @@ static int check_certificate(
 	void *cert_cb_payload)
 {
 	git_cert *cert;
-	git_error_state last_error = {0};
+	git_error *last_error;
 	int error;
 
 	if ((error = git_stream_certificate(&cert, stream)) < 0)
 		return error;
 
-	git_error_state_capture(&last_error, GIT_ECERTIFICATE);
+	/*
+	 * Allow callers to set an error - but save ours and clear
+	 * it, so that we can detect if they set one and restore it
+	 * if we need to.
+	 */
+	git_error_save(&last_error);
+	git_error_clear();
 
 	error = cert_cb(cert, is_valid, url->host, cert_cb_payload);
 
-	if (error == GIT_PASSTHROUGH && !is_valid)
-		return git_error_state_restore(&last_error);
-	else if (error == GIT_PASSTHROUGH)
-		error = 0;
-	else if (error && !git_error_last())
-		git_error_set(GIT_ERROR_HTTP,
-		              "user rejected certificate for %s", url->host);
+	if (error == GIT_PASSTHROUGH) {
+		error = is_valid ? 0 : -1;
 
-	git_error_state_free(&last_error);
+		if (error) {
+			git_error_restore(last_error);
+			last_error = NULL;
+		}
+	} else if (error) {
+		if (!git_error_exists())
+			git_error_set(GIT_ERROR_HTTP,
+		              "user rejected certificate for %s",
+			      url->host);
+	}
+
+	git_error_free(last_error);
 	return error;
 }
 
@@ -864,9 +894,29 @@ GIT_INLINE(int) server_setup_from_url(
 	return 0;
 }
 
+static bool parser_settings_initialized;
+static git_http_parser_settings parser_settings;
+
+GIT_INLINE(git_http_parser_settings *) http_client_parser_settings(void)
+{
+	if (!parser_settings_initialized) {
+		parser_settings.on_header_field = on_header_field;
+		parser_settings.on_header_value = on_header_value;
+		parser_settings.on_headers_complete = on_headers_complete;
+		parser_settings.on_body = on_body;
+		parser_settings.on_message_complete = on_message_complete;
+
+		parser_settings_initialized = true;
+	}
+
+	return &parser_settings;
+}
+
 static void reset_parser(git_http_client *client)
 {
-	http_parser_init(&client->parser, HTTP_RESPONSE);
+	git_http_parser_init(&client->parser,
+	                     GIT_HTTP_PARSER_RESPONSE,
+	                     http_client_parser_settings());
 }
 
 static int setup_hosts(
@@ -1109,27 +1159,9 @@ GIT_INLINE(int) client_read(git_http_client *client)
 	return (int)read_len;
 }
 
-static bool parser_settings_initialized;
-static http_parser_settings parser_settings;
-
-GIT_INLINE(http_parser_settings *) http_client_parser_settings(void)
-{
-	if (!parser_settings_initialized) {
-		parser_settings.on_header_field = on_header_field;
-		parser_settings.on_header_value = on_header_value;
-		parser_settings.on_headers_complete = on_headers_complete;
-		parser_settings.on_body = on_body;
-		parser_settings.on_message_complete = on_message_complete;
-
-		parser_settings_initialized = true;
-	}
-
-	return &parser_settings;
-}
-
 GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 {
-	http_parser *parser = &client->parser;
+	git_http_parser *parser = &client->parser;
 	http_parser_context *ctx = (http_parser_context *) parser->data;
 	unsigned char http_errno;
 	int read_len;
@@ -1143,11 +1175,10 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 	if (!client->read_buf.size && (read_len = client_read(client)) < 0)
 		return read_len;
 
-	parsed_len = http_parser_execute(parser,
-		http_client_parser_settings(),
+	parsed_len = git_http_parser_execute(parser,
 		client->read_buf.ptr,
 		client->read_buf.size);
-	http_errno = client->parser.http_errno;
+	http_errno = git_http_parser_errno(parser);
 
 	if (parsed_len > INT_MAX) {
 		git_error_set(GIT_ERROR_HTTP, "unexpectedly large parse");
@@ -1166,26 +1197,29 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 	 * (This can happen in response to an expect/continue request,
 	 * where the server gives you a 100 and 200 simultaneously.)
 	 */
-	if (http_errno == HPE_PAUSED) {
+	if (http_errno == GIT_HTTP_PARSER_PAUSED) {
+		size_t additional_size;
+
+		git_http_parser_resume(parser);
+
 		/*
-		 * http-parser has a "feature" where it will not deliver the
-		 * final byte when paused in a callback.  Consume that byte.
-		 * https://github.com/nodejs/http-parser/issues/97
+		 * http-parser has a "feature" where it will not deliver
+		 * the final byte when paused in a callback.  Consume
+		 * that byte.
 		 */
-		GIT_ASSERT(client->read_buf.size > parsed_len);
+		if ((additional_size = git_http_parser_remain_after_pause(parser)) > 0) {
+			GIT_ASSERT((client->read_buf.size - parsed_len) >= additional_size);
 
-		http_parser_pause(parser, 0);
-
-		parsed_len += http_parser_execute(parser,
-			http_client_parser_settings(),
-			client->read_buf.ptr + parsed_len,
-			1);
+			parsed_len += git_http_parser_execute(parser,
+				client->read_buf.ptr + parsed_len,
+				additional_size);
+		}
 	}
 
 	/* Most failures will be reported in http_errno */
-	else if (parser->http_errno != HPE_OK) {
+	else if (git_http_parser_errno(parser) != GIT_HTTP_PARSER_OK) {
 		git_error_set(GIT_ERROR_HTTP, "http parser error: %s",
-		              http_errno_description(http_errno));
+		              git_http_parser_errmsg(parser, http_errno));
 		return -1;
 	}
 
@@ -1193,7 +1227,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 	else if (parsed_len != client->read_buf.size) {
 		git_error_set(GIT_ERROR_HTTP,
 		              "http parser did not consume entire buffer: %s",
-			      http_errno_description(http_errno));
+		              git_http_parser_errmsg(parser, http_errno));
 		return -1;
 	}
 
@@ -1209,13 +1243,16 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 }
 
 /*
- * See if we've consumed the entire response body.  If the client was
- * reading the body but did not consume it entirely, it's possible that
- * they knew that the stream had finished (in a git response, seeing a
- * final flush) and stopped reading.  But if the response was chunked,
- * we may have not consumed the final chunk marker.  Consume it to
- * ensure that we don't have it waiting in our socket.  If there's
- * more than just a chunk marker, close the connection.
+ * Try to consume any remaining response body. The client may have
+ * decided that it did not need to consume the entire response body.
+ * For example, the client saw a redirect in the header and ignored
+ * the body. Or the client saw a particular sequence (like a final
+ * flush in a git response) and stopped reading (but there were
+ * additional response bytes, perhaps because the response was chunked).
+ * Do one more read to try to clear this out; this takes care of small
+ * remainders, like a chunk response or a small redirect message. If
+ * there is too much data, we'll just leave it and close the
+ * connection.
  */
 static void complete_response_body(git_http_client *client)
 {
@@ -1232,7 +1269,7 @@ static void complete_response_body(git_http_client *client)
 
 	/* If there was an error, just close the connection. */
 	if (client_read_and_parse(client) < 0 ||
-	    parser_context.error != HPE_OK ||
+	    parser_context.error != GIT_HTTP_PARSER_OK ||
 	    (parser_context.parse_status != PARSE_STATUS_OK &&
 	     parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) {
 		git_error_clear();
@@ -1240,6 +1277,7 @@ static void complete_response_body(git_http_client *client)
 	}
 
 done:
+	client->parser.data = NULL;
 	git_str_clear(&client->read_buf);
 }
 
@@ -1407,9 +1445,9 @@ int git_http_client_read_response(
 	git_http_response_dispose(response);
 
 	if (client->current_server == PROXY) {
-		git_vector_free_deep(&client->proxy.auth_challenges);
+		git_vector_dispose_deep(&client->proxy.auth_challenges);
 	} else if(client->current_server == SERVER) {
-		git_vector_free_deep(&client->server.auth_challenges);
+		git_vector_dispose_deep(&client->server.auth_challenges);
 	}
 
 	client->state = READING_RESPONSE;
@@ -1429,6 +1467,7 @@ int git_http_client_read_response(
 done:
 	git_str_dispose(&parser_context.parse_header_name);
 	git_str_dispose(&parser_context.parse_header_value);
+	client->parser.data = NULL;
 
 	return error;
 }
@@ -1484,6 +1523,8 @@ done:
 	if (error < 0)
 		client->connected = 0;
 
+	client->parser.data = NULL;
+
 	return error;
 }
 
@@ -1506,7 +1547,7 @@ int git_http_client_skip_body(git_http_client *client)
 	do {
 		error = client_read_and_parse(client);
 
-		if (parser_context.error != HPE_OK ||
+		if (parser_context.error != GIT_HTTP_PARSER_OK ||
 		    (parser_context.parse_status != PARSE_STATUS_OK &&
 		     parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) {
 			git_error_set(GIT_ERROR_HTTP,
@@ -1518,6 +1559,8 @@ int git_http_client_skip_body(git_http_client *client)
 	if (error < 0)
 		client->connected = 0;
 
+	client->parser.data = NULL;
+
 	return error;
 }
 
@@ -1565,7 +1608,7 @@ GIT_INLINE(void) http_server_close(git_http_server *server)
 
 	git_net_url_dispose(&server->url);
 
-	git_vector_free_deep(&server->auth_challenges);
+	git_vector_dispose_deep(&server->auth_challenges);
 	free_auth_context(server);
 }